/*
SQLite format specification:
- Initially only replaces sectors/ and sectors2/
-
+
If map.sqlite does not exist in the save dir
or the block was not found in the database
the map will try to load from sectors folder.
In either case, map.sqlite will be created
and all future saves will save there.
-
+
Structure of map.sqlite:
Tables:
blocks
MapSector * sector = m_sector_cache;
return sector;
}
-
+
core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
-
+
if(n == NULL)
return NULL;
-
+
MapSector *sector = n->getValue();
-
+
// Cache the last result
m_sector_cache_p = p;
m_sector_cache = sector;
MapSector *sector = getSectorNoGenerateNoEx(p);
if(sector == NULL)
throw InvalidPositionException();
-
+
return sector;
}
}
MapBlock * Map::getBlockNoCreate(v3s16 p3d)
-{
+{
MapBlock *block = getBlockNoCreateNoEx(p3d);
if(block == NULL)
throw InvalidPositionException();
v3s16(0,-1,0), // bottom
v3s16(-1,0,0), // left
};
-
+
if(from_nodes.size() == 0)
return;
-
+
u32 blockchangecount = 0;
core::map<v3s16, u8> unlighted_nodes;
MapBlock *block = NULL;
// Cache this a bit, too
bool block_checked_in_modified = false;
-
+
for(; j.atEnd() == false; j++)
{
v3s16 pos = j.getNode()->getKey();
v3s16 blockpos = getNodeBlockPos(pos);
-
+
// Only fetch a new block if the block position has changed
try{
if(block == NULL || blockpos != blockpos_last){
}
}
-
+
/*
Enable this to disable proper lighting for speeding up map
generation for testing or whatever
/*
Add intial metadata
*/
-
+
std::string metadata_name = nodemgr->get(n).metadata_name;
if(metadata_name != ""){
NodeMetadata *meta = NodeMetadata::create(metadata_name, m_gamedef);
core::list<v3s16> *unloaded_blocks)
{
bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
-
+
// Profile modified reasons
Profiler modprofiler;
-
+
core::list<v2s16> sector_deletion_queue;
u32 deleted_blocks_count = 0;
u32 saved_blocks_count = 0;
core::list<MapBlock*> blocks;
sector->getBlocks(blocks);
-
+
for(core::list<MapBlock*>::Iterator i = blocks.begin();
i != blocks.end(); i++)
{
MapBlock *block = (*i);
-
+
block->incrementUsageTimer(dtime);
-
+
if(block->getUsageTimer() > unload_timeout)
{
v3s16 p = block->getPos();
}
}
endSave();
-
+
// Finally delete the empty sectors
deleteSectors(sector_deletion_queue);
-
+
if(deleted_blocks_count != 0)
{
PrintInfo(infostream); // ServerMap/ClientMap:
i != blocks.end(); i++)
{
MapBlock *block = (*i);
-
+
if(block->getUsageTimer() > timeout)
{
// Save if modified
// list of nodes that due to viscosity have not reached their max level height
UniqueQueue<v3s16> must_reflow;
-
+
// List of MapBlocks that will require a lighting update (due to lava)
core::map<v3s16, MapBlock*> lighting_modified_blocks;
}
break;
case LIQUID_SOURCE:
- // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
+ // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
if (liquid_kind == CONTENT_AIR)
liquid_kind = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing);
if (nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing) != liquid_kind) {
if(enable_mapgen_debug_info)
infostream<<"initBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
<<blockpos.Z<<")"<<std::endl;
-
+
// Do nothing if not inside limits (+-1 because of neighbors)
if(blockpos_over_limit(blockpos - v3s16(1,1,1)) ||
blockpos_over_limit(blockpos + v3s16(1,1,1)))
data->no_op = true;
return;
}
-
+
data->no_op = false;
data->seed = m_seed;
data->blockpos = blockpos;
*/
{
//TimeTaker timer("initBlockMake() create area");
-
+
for(s16 x=-1; x<=1; x++)
for(s16 z=-1; z<=1; z++)
{
}
}
}
-
+
/*
Now we have a big empty area.
Make a ManualMapVoxelManipulator that contains this and the
neighboring blocks
*/
-
+
// The area that contains this block and it's neighbors
v3s16 bigarea_blocks_min = blockpos - v3s16(1,1,1);
v3s16 bigarea_blocks_max = blockpos + v3s16(1,1,1);
-
+
data->vmanip = new ManualMapVoxelManipulator(this);
//data->vmanip->setMap(this);
v3s16 p = data->transforming_liquid.pop_front();
m_transforming_liquid.push_back(p);
}
-
+
/*
Get central block
*/
}*/
#endif
updateLighting(lighting_update_blocks, changed_blocks);
-
+
/*
Set lighting to non-expired state in all of them.
This is cheating, but it is not fast enough if all of them
Set central block as generated
*/
block->setGenerated(true);
-
+
/*
Save changed parts of map
NOTE: Will be saved later.
DSTACKF("%s: p2d=(%d,%d)",
__FUNCTION_NAME,
p2d.X, p2d.Y);
-
+
/*
Check if it exists already in memory
*/
ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
if(sector != NULL)
return sector;
-
+
/*
Try to load it from disk (with blocks)
*/
/*
Generate blank sector
*/
-
+
sector = new ServerMapSector(this, p2d, m_gamedef);
-
+
// Sector position on map in nodes
v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
Insert to container
*/
m_sectors.insert(p2d, sector);
-
+
return sector;
}
)
{
DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z);
-
+
/*infostream<<"generateBlock(): "
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<std::endl;*/
-
+
bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
TimeTaker timer("generateBlock");
-
+
//MapBlock *block = original_dummy;
-
+
v2s16 p2d(p.X, p.Z);
v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
-
+
/*
Do not generate over-limit
*/
{
DSTACKF("%s: p=(%d,%d,%d)",
__FUNCTION_NAME, p.X, p.Y, p.Z);
-
+
/*
Do not create over-limit
*/
|| p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
throw InvalidPositionException("createBlock(): pos. over limit");
-
+
v2s16 p2d(p.X, p.Z);
s16 block_y = p.Y;
/*
DSTACKF("%s: p=(%d,%d,%d), allow_generate=%d",
__FUNCTION_NAME,
p.X, p.Y, p.Z, allow_generate);
-
+
{
MapBlock *block = getBlockNoCreateNoEx(p);
if(block && block->isDummy() == false)
// Queue event
dispatchEvent(&event);
-
+
return block;
}
}
/*
Determine from map generator noise functions
*/
-
+
s16 level = mapgen::find_ground_level_from_noise(m_seed, p2d, 1);
return level;
void ServerMap::verifyDatabase() {
if(m_database)
return;
-
+
{
std::string dbp = m_savedir + DIR_DELIM + "map.sqlite";
bool needs_create = false;
int d;
-
+
/*
Open the database connection
*/
-
+
createDirs(m_savedir);
-
+
if(!fs::PathExists(dbp))
needs_create = true;
-
+
d = sqlite3_open_v2(dbp.c_str(), &m_database, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if(d != SQLITE_OK) {
infostream<<"WARNING: Database failed to open: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot open database file");
}
-
+
if(needs_create)
createDatabase();
-
+
d = sqlite3_prepare(m_database, "SELECT `data` FROM `blocks` WHERE `pos`=? LIMIT 1", -1, &m_database_read, NULL);
if(d != SQLITE_OK) {
infostream<<"WARNING: Database read statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot prepare read statement");
}
-
+
d = sqlite3_prepare(m_database, "REPLACE INTO `blocks` VALUES(?, ?)", -1, &m_database_write, NULL);
if(d != SQLITE_OK) {
infostream<<"WARNING: Database write statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot prepare write statement");
}
-
+
d = sqlite3_prepare(m_database, "SELECT `pos` FROM `blocks`", -1, &m_database_list, NULL);
if(d != SQLITE_OK) {
infostream<<"WARNING: Database list statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot prepare read statement");
}
-
+
infostream<<"Server: Database opened"<<std::endl;
}
}
infostream<<"WARNING: Not saving map, saving disabled."<<std::endl;
return;
}
-
+
if(save_level == MOD_STATE_CLEAN)
infostream<<"ServerMap: Saving whole map, this can take time."
<<std::endl;
-
+
if(m_map_metadata_changed || save_level == MOD_STATE_CLEAN)
{
saveMapMeta();
// Profile modified reasons
Profiler modprofiler;
-
+
u32 sector_meta_count = 0;
u32 block_count = 0;
u32 block_count_all = 0; // Number of blocks in memory
-
+
// Don't do anything with sqlite unless something is really saved
bool save_started = false;
{
ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue();
assert(sector->getId() == MAPSECTOR_SERVER);
-
+
if(sector->differs_from_disk || save_level == MOD_STATE_CLEAN)
{
saveSectorMeta(sector);
core::list<MapBlock*> blocks;
sector->getBlocks(blocks);
core::list<MapBlock*>::Iterator j;
-
+
for(j=blocks.begin(); j!=blocks.end(); j++)
{
MapBlock *block = *j;
-
+
block_count_all++;
if(block->getModified() >= save_level)
errorstream<<"Map::listAllLoadableBlocks(): Result will be missing "
<<"all blocks that are stored in flat files"<<std::endl;
}
-
+
{
verifyDatabase();
-
+
while(sqlite3_step(m_database_list) == SQLITE_ROW)
{
sqlite3_int64 block_i = sqlite3_column_int64(m_database_list, 0);
void ServerMap::saveMapMeta()
{
DSTACK(__FUNCTION_NAME);
-
+
infostream<<"ServerMap::saveMapMeta(): "
<<"seed="<<m_seed
<<std::endl;
createDirs(m_savedir);
-
+
std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
std::ofstream os(fullpath.c_str(), std::ios_base::binary);
if(os.good() == false)
<<"could not open"<<fullpath<<std::endl;
throw FileNotGoodException("Cannot open chunk metadata");
}
-
+
Settings params;
params.setU64("seed", m_seed);
params.writeLines(os);
os<<"[end_of_params]\n";
-
+
m_map_metadata_changed = false;
}
void ServerMap::loadMapMeta()
{
DSTACK(__FUNCTION_NAME);
-
+
infostream<<"ServerMap::loadMapMeta(): Loading map metadata"
<<std::endl;
v2s16 pos = sector->getPos();
std::string dir = getSectorDir(pos);
createDirs(dir);
-
+
std::string fullpath = dir + DIR_DELIM + "meta";
std::ofstream o(fullpath.c_str(), std::ios_base::binary);
if(o.good() == false)
throw FileNotGoodException("Cannot open sector metafile");
sector->serialize(o, version);
-
+
sector->differs_from_disk = false;
}
if(save_after_load)
saveSectorMeta(sector);
}
-
+
sector->differs_from_disk = false;
return sector;
{
return false;
}
-
+
return true;
}
{
return false;
}
-
+
/*
Load blocks
*/
u8 version = SER_FMT_VER_HIGHEST;
// Get destination
v3s16 p3d = block->getPos();
-
-
+
+
#if 0
v2s16 p2d(p3d.X, p3d.Z);
std::string sectordir = getSectorDir(p2d);
[0] u8 serialization version
[1] data
*/
-
+
verifyDatabase();
-
+
std::ostringstream o(std::ios_base::binary);
-
+
o.write((char*)&version, 1);
-
+
// Write basic data
block->serialize(o, version, true);
-
+
// Write block to database
-
+
std::string tmp = o.str();
const char *bytes = tmp.c_str();
-
+
if(sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(p3d)) != SQLITE_OK)
infostream<<"WARNING: Block position failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
if(sqlite3_bind_blob(m_database_write, 2, (void *)bytes, o.tellp(), NULL) != SQLITE_OK) // TODO this mught not be the right length
<<sqlite3_errmsg(m_database)<<std::endl;
// Make ready for later reuse
sqlite3_reset(m_database_write);
-
+
// We just wrote it to the disk so clear modified flag
block->resetModified();
}
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
throw FileNotGoodException("Cannot open block file");
-
+
v3s16 p3d = getBlockPos(sectordir, blockfile);
v2s16 p2d(p3d.X, p3d.Z);
-
+
assert(sector->getPos() == p2d);
-
+
u8 version = SER_FMT_VER_INVALID;
is.read((char*)&version, 1);
block = sector->createBlankBlockNoInsert(p3d.Y);
created_new = true;
}
-
+
// Read basic data
block->deSerialize(is, version, true);
// If it's a new block, insert it to the map
if(created_new)
sector->insertBlock(block);
-
+
/*
Save blocks loaded in old format in new format
*/
if(version < SER_FMT_VER_HIGHEST || save_after_load)
{
saveBlock(block);
-
+
// Should be in database now, so delete the old file
fs::RecursiveDelete(fullpath);
}
-
+
// We just loaded it from the disk, so it's up-to-date.
block->resetModified();
try {
std::istringstream is(*blob, std::ios_base::binary);
-
+
u8 version = SER_FMT_VER_INVALID;
is.read((char*)&version, 1);
block = sector->createBlankBlockNoInsert(p3d.Y);
created_new = true;
}
-
+
// Read basic data
block->deSerialize(is, version, true);
-
+
// If it's a new block, insert it to the map
if(created_new)
sector->insertBlock(block);
-
+
/*
Save blocks loaded in old format in new format
*/
// Only save if asked to; no need to update version
if(save_after_load)
saveBlock(block);
-
+
// We just loaded it from, so it's up-to-date.
block->resetModified();
if(!loadFromFolders()) {
verifyDatabase();
-
+
if(sqlite3_bind_int64(m_database_read, 1, getBlockAsInteger(blockpos)) != SQLITE_OK)
infostream<<"WARNING: Could not bind block position for load: "
<<sqlite3_errmsg(m_database)<<std::endl;
Make sure sector is loaded
*/
MapSector *sector = createSector(p2d);
-
+
/*
Load block
*/
const char * data = (const char *)sqlite3_column_blob(m_database_read, 0);
size_t len = sqlite3_column_bytes(m_database_read, 0);
-
+
std::string datastr(data, len);
-
+
loadBlock(&datastr, blockpos, sector, false);
sqlite3_step(m_database_read);
return getBlockNoCreateNoEx(blockpos);
}
sqlite3_reset(m_database_read);
-
+
// Not found in database, try the files
}
loadlayout = 2;
sectordir = getSectorDir(p2d, 2);
}
-
+
/*
Make sure sector is loaded
*/
}
catch(InvalidFilenameException &e)
{
- return false;
+ return NULL;
}
catch(FileNotGoodException &e)
{
- return false;
+ return NULL;
}
catch(std::exception &e)
{
- return false;
+ return NULL;
}
}
-
+
/*
Make sure file exists
*/
{
m_camera_mutex.Init();
assert(m_camera_mutex.IsInitialized());
-
+
m_box = core::aabbox3d<f32>(-BS*1000000,-BS*1000000,-BS*1000000,
BS*1000000,BS*1000000,BS*1000000);
}
ClientMap::~ClientMap()
{
/*JMutexAutoLock lock(mesh_mutex);
-
+
if(mesh != NULL)
{
mesh->drop();
catch(InvalidPositionException &e)
{
}
-
+
// Create a sector
ClientMapSector *sector = new ClientMapSector(this, p2d, m_gamedef);
-
+
{
//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
m_sectors.insert(p2d, sector);
}
-
+
return sector;
}
ClientMapSector *sector = NULL;
//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
-
+
core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p2d);
if(n != NULL)
DSTACK(__FUNCTION_NAME);
bool is_transparent_pass = pass == scene::ESNRP_TRANSPARENT;
-
+
std::string prefix;
if(pass == scene::ESNRP_SOLID)
prefix = "CM: solid: ";
/*
Get time for measuring timeout.
-
+
Measuring time is very useful for long delays when the
machine is swapping a lot.
*/
*/
v3s16 cam_pos_nodes = floatToInt(camera_position, BS);
-
+
v3s16 box_nodes_d = m_control.wanted_range * v3s16(1,1,1);
v3s16 p_nodes_min = cam_pos_nodes - box_nodes_d;
p_nodes_max.X / MAP_BLOCKSIZE + 1,
p_nodes_max.Y / MAP_BLOCKSIZE + 1,
p_nodes_max.Z / MAP_BLOCKSIZE + 1);
-
+
u32 vertex_count = 0;
u32 meshbuffer_count = 0;
-
+
// For limiting number of mesh updates per frame
u32 mesh_update_count = 0;
-
+
// Number of blocks in rendering range
u32 blocks_in_range = 0;
// Number of blocks occlusion culled
/*
Collect a set of blocks for drawing
*/
-
+
core::map<v3s16, MapBlock*> drawset;
{
{
MapSector *sector = si.getNode()->getValue();
v2s16 sp = sector->getPos();
-
+
if(m_control.range_all == false)
{
if(sp.X < p_blocks_min.X
core::list< MapBlock * > sectorblocks;
sector->getBlocks(sectorblocks);
-
+
/*
Loop through blocks in sector
*/
u32 sector_blocks_drawn = 0;
-
+
core::list< MapBlock * >::Iterator i;
for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
{
Compare block position to camera position, skip
if not seen on display
*/
-
+
float range = 100000 * BS;
if(m_control.range_all == false)
range = m_control.wanted_range * BS;
continue;*/
blocks_in_range++;
-
+
#if 1
/*
Update expired mesh (used for day/night change)
*/
bool mesh_expired = false;
-
+
{
JMutexAutoLock lock(block->mesh_mutex);
f32 faraway = BS*50;
//f32 faraway = m_control.wanted_range * BS;
-
+
/*
This has to be done with the mesh_mutex unlocked
*/
(mesh_update_count < 3
&& (d < faraway || mesh_update_count < 2)
)
- ||
+ ||
(m_control.range_all && mesh_update_count < 20)
)
)
blocks_occlusion_culled++;
continue;
}
-
+
// This block is in range. Reset usage timer.
block->resetUsageTimer();
JMutexAutoLock lock(block->mesh_mutex);
scene::SMesh *mesh = block->mesh;
-
+
if(mesh == NULL){
blocks_in_range_without_mesh++;
continue;
}
}
-
+
// Limit block count in case of a sudden increase
blocks_would_have_drawn++;
if(blocks_drawn >= m_control.wanted_max_blocks
&& m_control.range_all == false
&& d > m_control.wanted_min_range * BS)
continue;
-
+
// Add to set
drawset[block->getPos()] = block;
-
+
sector_blocks_drawn++;
blocks_drawn++;
m_last_drawn_sectors[sp] = true;
}
} // ScopeProfiler
-
+
/*
Draw the selected MapBlocks
*/
}
}
}
-
+
MapBlock *block = i.getNode()->getValue();
/*
scene::SMesh *mesh = block->mesh;
assert(mesh);
-
+
u32 c = mesh->getMeshBufferCount();
bool stuff_actually_drawn = false;
for(u32 i=0; i<c; i++)
}
}
} // ScopeProfiler
-
+
// Log only on solid pass because values are the same
if(pass == scene::ESNRP_SOLID){
g_profiler->avg("CM: blocks in range", blocks_in_range);
(float)blocks_in_range_without_mesh/blocks_in_range);
g_profiler->avg("CM: blocks drawn", blocks_drawn);
}
-
+
g_profiler->avg(prefix+"vertices drawn", vertex_count);
if(blocks_had_pass_meshbuf != 0)
g_profiler->avg(prefix+"meshbuffers per block",
core::list< MapBlock * > sectorblocks;
sector->getBlocks(sectorblocks);
-
+
core::list< MapBlock * >::Iterator i;
for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
{
{
continue;
}
-
+
{
JMutexAutoLock lock(block->mesh_mutex);
if(block->mesh != NULL)
n = m_loaded_blocks.find(p);
if(n != NULL)
continue;
-
+
bool block_data_inexistent = false;
try
{
<<" wanted area: ";
a.print(infostream);
infostream<<std::endl;*/
-
+
MapBlock *block = m_map->getBlockNoCreate(p);
if(block->isDummy())
block_data_inexistent = true;
{
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
*/
continue;
MapNode &n = m_data[m_area.index(p)];
-
+
v3s16 blockpos = getNodeBlockPos(p);
-
+
try
{
// Get block
blockpos_last = blockpos;
block_checked_in_modified = false;
}
-
+
// Calculate relative position in block
v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
//m_map->setNode(m_area.MinEdge + p, n);
block->setNode(relpos, n);
-
+
/*
Make sure block is in modified_blocks
*/
VoxelArea block_area_nodes
(p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
-
+
u32 size_MB = block_area_nodes.getVolume()*4/1000000;
if(size_MB >= 1)
{
n = m_loaded_blocks.find(p);
if(n != NULL)
continue;
-
+
bool block_data_inexistent = false;
try
{
{
if(m_area.getExtent() == v3s16(0,0,0))
return;
-
+
/*
Copy data of all blocks
*/