X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.h;h=54d8fe9eaf30b1c83524861494084d942de47b74;hb=5a34f40d80ea1a339b599bc11db549a6bd86912f;hp=6f7ac0d3bfc5a591f6ac5d2dc99ea47ed5642261;hpb=7cfb71385d00d1cbbbfd9c76f6c01adafa9e648a;p=dragonfireclient.git diff --git a/src/map.h b/src/map.h index 6f7ac0d3b..54d8fe9ea 100644 --- a/src/map.h +++ b/src/map.h @@ -1,18 +1,18 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +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 General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +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. */ @@ -20,26 +20,37 @@ with this program; if not, write to the Free Software Foundation, Inc., #ifndef MAP_HEADER #define MAP_HEADER -#include -#include #include +#include +#include +#include +#include -#ifdef _WIN32 - #include - #define sleep_s(x) Sleep((x*1000)) -#else - #include - #define sleep_s(x) sleep(x) -#endif - -#include "common_irrlicht.h" +#include "irrlichttypes_bloated.h" #include "mapnode.h" -#include "mapblock.h" -#include "mapsector.h" #include "constants.h" #include "voxel.h" -#include "mapchunk.h" -#include "nodemetadata.h" +#include "modifiedstate.h" +#include "util/container.h" +#include "nodetimer.h" + +class Database; +class ClientMap; +class MapSector; +class ServerMapSector; +class MapBlock; +class NodeMetadata; +class IGameDef; +class IRollbackReportSink; +class EmergeManager; +class ServerEnvironment; +struct BlockMakeData; +struct MapgenParams; + + +/* + MapEditEvent +*/ #define MAPTYPE_BASE 0 #define MAPTYPE_SERVER 1 @@ -50,10 +61,12 @@ enum MapEditEventType{ MEET_ADDNODE, // Node removed (changed to air) MEET_REMOVENODE, + // Node swapped (changed without metadata change) + MEET_SWAPNODE, // Node metadata of block changed (not knowing which node exactly) // p stores block coordinate MEET_BLOCK_NODE_METADATA_CHANGED, - // Anything else + // Anything else (modified_blocks are set unsent) MEET_OTHER }; @@ -62,7 +75,7 @@ struct MapEditEvent MapEditEventType type; v3s16 p; MapNode n; - core::map modified_blocks; + std::set modified_blocks; u16 already_known_by_peer; MapEditEvent(): @@ -70,22 +83,49 @@ struct MapEditEvent already_known_by_peer(0) { } - + MapEditEvent * clone() { MapEditEvent *event = new MapEditEvent(); event->type = type; event->p = p; event->n = n; - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd()==false; i++) + event->modified_blocks = modified_blocks; + return event; + } + + VoxelArea getArea() + { + switch(type){ + case MEET_ADDNODE: + return VoxelArea(p); + case MEET_REMOVENODE: + return VoxelArea(p); + case MEET_SWAPNODE: + return VoxelArea(p); + case MEET_BLOCK_NODE_METADATA_CHANGED: { - v3s16 p = i.getNode()->getKey(); - bool v = i.getNode()->getValue(); - event->modified_blocks.insert(p, v); + v3s16 np1 = p*MAP_BLOCKSIZE; + v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1); + return VoxelArea(np1, np2); } - return event; + case MEET_OTHER: + { + VoxelArea a; + for(std::set::iterator + i = modified_blocks.begin(); + i != modified_blocks.end(); ++i) + { + v3s16 p = *i; + v3s16 np1 = p*MAP_BLOCKSIZE; + v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1); + a.addPoint(np1); + a.addPoint(np2); + } + return a; + } + } + return VoxelArea(); } }; @@ -96,23 +136,23 @@ class MapEventReceiver virtual void onMapEditEvent(MapEditEvent *event) = 0; }; -class Map : public NodeContainer +class Map /*: public NodeContainer*/ { public: - Map(std::ostream &dout); + Map(std::ostream &dout, IGameDef *gamedef); virtual ~Map(); - virtual u16 nodeContainerId() const + /*virtual u16 nodeContainerId() const { return NODECONTAINER_ID_MAP; - } + }*/ virtual s32 mapType() const { return MAPTYPE_BASE; } - + /* Drop (client) or delete (server) the map. */ @@ -128,7 +168,7 @@ class Map : public NodeContainer // On failure returns NULL MapSector * getSectorNoGenerateNoExNoLock(v2s16 p2d); - // On failure returns NULL + // Same as the above (there exists no lock anymore) MapSector * getSectorNoGenerateNoEx(v2s16 p2d); // On failure throws InvalidPositionException MapSector * getSectorNoGenerate(v2s16 p2d); @@ -141,178 +181,191 @@ class Map : public NodeContainer */ virtual MapSector * emergeSector(v2s16 p){ return NULL; } virtual MapSector * emergeSector(v2s16 p, - core::map &changed_blocks){ return NULL; } + std::map &changed_blocks){ return NULL; } // Returns InvalidPositionException if not found MapBlock * getBlockNoCreate(v3s16 p); // Returns NULL if not found MapBlock * getBlockNoCreateNoEx(v3s16 p); - // Gets an existing block or creates an empty one - //MapBlock * getBlockCreate(v3s16 p); - + + /* Server overrides */ + virtual MapBlock * emergeBlock(v3s16 p, bool allow_generate=true) + { return getBlockNoCreateNoEx(p); } + // Returns InvalidPositionException if not found bool isNodeUnderground(v3s16 p); - - // virtual from NodeContainer - bool isValidPosition(v3s16 p) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock *blockref; - try{ - blockref = getBlockNoCreate(blockpos); - } - catch(InvalidPositionException &e) - { - return false; - } - return true; - /*v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - bool is_valid = blockref->isValidPosition(relpos); - return is_valid;*/ - } - - // virtual from NodeContainer - // throws InvalidPositionException if not found - MapNode getNode(v3s16 p) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlockNoCreate(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - return blockref->getNodeNoCheck(relpos); - } + bool isValidPosition(v3s16 p); - // virtual from NodeContainer // throws InvalidPositionException if not found - void setNode(v3s16 p, MapNode & n) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlockNoCreate(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - blockref->setNodeNoCheck(relpos, n); - } - - // Returns a CONTENT_IGNORE node if not found - MapNode getNodeNoEx(v3s16 p) - { - try{ - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlockNoCreate(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; + MapNode getNode(v3s16 p); - return blockref->getNodeNoCheck(relpos); - } - catch(InvalidPositionException &e) - { - return MapNode(CONTENT_IGNORE); - } - } + // throws InvalidPositionException if not found + void setNode(v3s16 p, MapNode & n); + + // Returns a CONTENT_IGNORE node if not found + MapNode getNodeNoEx(v3s16 p); void unspreadLight(enum LightBank bank, - core::map & from_nodes, - core::map & light_sources, - core::map & modified_blocks); + std::map & from_nodes, + std::set & light_sources, + std::map & modified_blocks); void unLightNeighbors(enum LightBank bank, v3s16 pos, u8 lightwas, - core::map & light_sources, - core::map & modified_blocks); - + std::set & light_sources, + std::map & modified_blocks); + void spreadLight(enum LightBank bank, - core::map & from_nodes, - core::map & modified_blocks); - + std::set & from_nodes, + std::map & modified_blocks); + void lightNeighbors(enum LightBank bank, v3s16 pos, - core::map & modified_blocks); + std::map & modified_blocks); v3s16 getBrightestNeighbour(enum LightBank bank, v3s16 p); s16 propagateSunlight(v3s16 start, - core::map & modified_blocks); - + std::map & modified_blocks); + void updateLighting(enum LightBank bank, - core::map & a_blocks, - core::map & modified_blocks); - - void updateLighting(core::map & a_blocks, - core::map & modified_blocks); - + std::map & a_blocks, + std::map & modified_blocks); + + void updateLighting(std::map & a_blocks, + std::map & modified_blocks); + /* These handle lighting but not faces. */ void addNodeAndUpdate(v3s16 p, MapNode n, - core::map &modified_blocks); + std::map &modified_blocks, + bool remove_metadata = true); void removeNodeAndUpdate(v3s16 p, - core::map &modified_blocks); + std::map &modified_blocks); /* Wrappers for the latter ones. These emit events. Return true if succeeded, false if not. */ - bool addNodeWithEvent(v3s16 p, MapNode n); + bool addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata = true); bool removeNodeWithEvent(v3s16 p); - + /* Takes the blocks at the edges into account */ - bool dayNightDiffed(v3s16 blockpos); + bool getDayNightDiff(v3s16 blockpos); //core::aabbox3d getDisplayedBlockArea(); //bool updateChangedVisibleArea(); - - virtual void save(bool only_changed){assert(0);}; + + // Call these before and after saving of many blocks + virtual void beginSave() {return;}; + virtual void endSave() {return;}; + + virtual void save(ModifiedState save_level){assert(0);}; + + // Server implements this. + // Client leaves it as no-op. + virtual void saveBlock(MapBlock *block){}; /* - Updates usage timers + Updates usage timers and unloads unused blocks and sectors. + Saves modified blocks before unloading on MAPTYPE_SERVER. */ - void timerUpdate(float dtime); - + void timerUpdate(float dtime, float unload_timeout, + std::list *unloaded_blocks=NULL); + + /* + Unloads all blocks with a zero refCount(). + Saves modified blocks before unloading on MAPTYPE_SERVER. + */ + void unloadUnreferencedBlocks(std::list *unloaded_blocks=NULL); + + // Deletes sectors and their blocks from memory // Takes cache into account - // sector mutex should be locked when calling - void deleteSectors(core::list &list, bool only_blocks); - - // Returns count of deleted sectors - u32 deleteUnusedSectors(float timeout, bool only_blocks=false, + // If deleted sector is in sector cache, clears cache + void deleteSectors(std::list &list); + +#if 0 + /* + Unload unused data + = flush changed to disk and delete from memory, if usage timer of + block is more than timeout + */ + void unloadUnusedData(float timeout, core::list *deleted_blocks=NULL); +#endif - // For debug printing + // For debug printing. Prints "Map: ", "ServerMap: " or "ClientMap: " virtual void PrintInfo(std::ostream &out); - - void transformLiquids(core::map & modified_blocks); + + void transformLiquids(std::map & modified_blocks); + void transformLiquidsFinite(std::map & modified_blocks); /* Node metadata These are basically coordinate wrappers to MapBlock */ - + NodeMetadata* getNodeMetadata(v3s16 p); - void setNodeMetadata(v3s16 p, NodeMetadata *meta); + + /** + * Sets metadata for a node. + * This method sets the metadata for a given node. + * On success, it returns @c true and the object pointed to + * by @p meta is then managed by the system and should + * not be deleted by the caller. + * + * In case of failure, the method returns @c false and the + * caller is still responsible for deleting the object! + * + * @param p node coordinates + * @param meta pointer to @c NodeMetadata object + * @return @c true on success, false on failure + */ + bool setNodeMetadata(v3s16 p, NodeMetadata *meta); void removeNodeMetadata(v3s16 p); - void nodeMetadataStep(float dtime, - core::map &changed_blocks); - + + /* + Node Timers + These are basically coordinate wrappers to MapBlock + */ + + NodeTimer getNodeTimer(v3s16 p); + void setNodeTimer(v3s16 p, NodeTimer t); + void removeNodeTimer(v3s16 p); + /* Misc. */ - core::map *getSectorsPtr(){return &m_sectors;} + std::map *getSectorsPtr(){return &m_sectors;} /* Variables */ - + + void transforming_liquid_add(v3s16 p); + s32 transforming_liquid_size(); + + virtual s16 getHeat(v3s16 p); + virtual s16 getHumidity(v3s16 p); + protected: + friend class LuaVoxelManip; - std::ostream &m_dout; + std::ostream &m_dout; // A bit deprecated, could be removed - core::map m_event_receivers; - - core::map m_sectors; - //JMutex m_sector_mutex; + IGameDef *m_gamedef; - // Be sure to set this to NULL when the cached sector is deleted + std::set m_event_receivers; + + std::map m_sectors; + + // Be sure to set this to NULL when the cached sector is deleted MapSector *m_sector_cache; v2s16 m_sector_cache_p; @@ -326,15 +379,13 @@ class Map : public NodeContainer This is the only map class that is able to generate map. */ -struct ChunkMakeData; - class ServerMap : public Map { public: /* savedir: directory to which map data should be saved */ - ServerMap(std::string savedir); + ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emerge); ~ServerMap(); s32 mapType() const @@ -342,208 +393,40 @@ class ServerMap : public Map return MAPTYPE_SERVER; } - /* - Map generation - */ - - // Returns the position of the chunk where the sector is in - v2s16 sector_to_chunk(v2s16 sectorpos) - { - if(m_chunksize == 0) - return v2s16(0,0); - sectorpos.X += m_chunksize / 2; - sectorpos.Y += m_chunksize / 2; - v2s16 chunkpos = getContainerPos(sectorpos, m_chunksize); - return chunkpos; - } - - // Returns the position of the (0,0) sector of the chunk - v2s16 chunk_to_sector(v2s16 chunkpos) - { - if(m_chunksize == 0) - return v2s16(0,0); - v2s16 sectorpos( - chunkpos.X * m_chunksize, - chunkpos.Y * m_chunksize - ); - sectorpos.X -= m_chunksize / 2; - sectorpos.Y -= m_chunksize / 2; - return sectorpos; - } - - /* - Get a chunk. - */ - MapChunk *getChunk(v2s16 chunkpos) - { - core::map::Node *n; - n = m_chunks.find(chunkpos); - if(n == NULL) - return NULL; - return n->getValue(); - } - - /* - True if the chunk and its neighbors are fully generated. - It means the chunk will not be touched in the future by the - generator. If false, generateChunk will make it true. - */ - bool chunkNonVolatile(v2s16 chunkpos) - { - if(m_chunksize == 0) - return true; - - /*for(s16 x=-1; x<=1; x++) - for(s16 y=-1; y<=1; y++)*/ - s16 x=0; - s16 y=0; - { - v2s16 chunkpos0 = chunkpos + v2s16(x,y); - MapChunk *chunk = getChunk(chunkpos); - if(chunk == NULL) - return false; - if(chunk->getGenLevel() != GENERATED_FULLY) - return false; - } - return true; - } - - /* - Returns true if any chunk is marked as modified - */ - bool anyChunkModified() - { - for(core::map::Iterator - i = m_chunks.getIterator(); - i.atEnd()==false; i++) - { - v2s16 p = i.getNode()->getKey(); - MapChunk *chunk = i.getNode()->getValue(); - if(chunk->isModified()) - return true; - } - return false; - } - - void setChunksNonModified() - { - for(core::map::Iterator - i = m_chunks.getIterator(); - i.atEnd()==false; i++) - { - v2s16 p = i.getNode()->getKey(); - MapChunk *chunk = i.getNode()->getValue(); - chunk->setModified(false); - } - } - - /* - Chunks are generated by using these and makeChunk(). - */ - void initChunkMake(ChunkMakeData &data, v2s16 chunkpos); - MapChunk* finishChunkMake(ChunkMakeData &data, - core::map &changed_blocks); - - /* - Generate a chunk. - - All chunks touching this one can be altered also. - */ - /*MapChunk* generateChunkRaw(v2s16 chunkpos, - core::map &changed_blocks, - bool force=false);*/ - - /* - Generate a chunk and its neighbors so that it won't be touched - anymore. - */ - /*MapChunk* generateChunk(v2s16 chunkpos, - core::map &changed_blocks);*/ - - /* - Generate a sector. - - This is mainly called by generateChunkRaw. - */ - //ServerMapSector * generateSector(v2s16 p); - /* Get a sector from somewhere. - Check memory - - Check disk (loads blocks also) + - Check disk (doesn't load blocks) - Create blank one */ ServerMapSector * createSector(v2s16 p); /* - Get a sector from somewhere. - - Check memory - - Check disk (loads blocks also) - - Generate chunk + Blocks are generated by using these and makeBlock(). */ - /*MapSector * emergeSector(v2s16 p, - core::map &changed_blocks);*/ - - /*MapSector * emergeSector(v2s16 p) - { - core::map changed_blocks; - return emergeSector(p, changed_blocks); - }*/ + bool initBlockMake(BlockMakeData *data, v3s16 blockpos); + MapBlock *finishBlockMake(BlockMakeData *data, + std::map &changed_blocks); - MapBlock * generateBlock( - v3s16 p, - MapBlock *original_dummy, - ServerMapSector *sector, - core::map &changed_blocks, - core::map &lighting_invalidated_blocks - ); - /* Get a block from somewhere. - Memory - Create blank */ MapBlock * createBlock(v3s16 p); - - /* - only_from_disk, changed_blocks and lighting_invalidated_blocks - are not properly used by the new map generator. - */ - MapBlock * emergeBlock( - v3s16 p, - bool only_from_disk, - core::map &changed_blocks, - core::map &lighting_invalidated_blocks - ); -#if 0 /* Forcefully get a block from somewhere. + - Memory + - Load from disk + - Create blank filled with CONTENT_IGNORE - Exceptions: - - InvalidPositionException: possible if only_from_disk==true - - changed_blocks: - - All already existing blocks that were modified are added. - - If found on disk, nothing will be added. - - If generated, the new block will not be included. - - lighting_invalidated_blocks: - - All blocks that have heavy-to-calculate lighting changes - are added. - - updateLighting() should be called for these. - - - A block that is in changed_blocks may not be in - lighting_invalidated_blocks. */ - MapBlock * emergeBlock( - v3s16 p, - bool only_from_disk, - core::map &changed_blocks, - core::map &lighting_invalidated_blocks - ); -#endif + MapBlock * emergeBlock(v3s16 p, bool create_blank=true); + // Carries out any initialization necessary before block is sent + void prepareBlock(MapBlock *block); + // Helper for placing objects on ground level s16 findGroundLevel(v2s16 p2d); @@ -557,212 +440,97 @@ class ServerMap : public Map // dirname: final directory name v2s16 getSectorPos(std::string dirname); v3s16 getBlockPos(std::string sectordir, std::string blockfile); + static std::string getBlockFilename(v3s16 p); - void save(bool only_changed); - //void loadAll(); - + /* + Database functions + */ + // Verify we can read/write to the database + void verifyDatabase(); + + // Returns true if the database file does not exist + bool loadFromFolders(); + + // Call these before and after saving of blocks + void beginSave(); + void endSave(); + + void save(ModifiedState save_level); + void listAllLoadableBlocks(std::list &dst); + void listAllLoadedBlocks(std::list &dst); // Saves map seed and possibly other stuff void saveMapMeta(); void loadMapMeta(); - - void saveChunkMeta(); - void loadChunkMeta(); - + + /*void saveChunkMeta(); + void loadChunkMeta();*/ + // The sector mutex should be locked when calling most of these - + // This only saves sector-specific data such as the heightmap // (no MapBlocks) // DEPRECATED? Sectors have no metadata anymore. void saveSectorMeta(ServerMapSector *sector); MapSector* loadSectorMeta(std::string dirname, bool save_after_load); - + bool loadSectorMeta(v2s16 p2d); + // Full load of a sector including all blocks. // returns true on success, false on failure. bool loadSectorFull(v2s16 p2d); // If sector is not found in memory, try to load it from disk. // Returns true if sector now resides in memory //bool deFlushSector(v2s16 p2d); - + void saveBlock(MapBlock *block); // This will generate a sector with getSector if not found. void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load=false); + MapBlock* loadBlock(v3s16 p); + // Database version + void loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load=false); // For debug printing virtual void PrintInfo(std::ostream &out); bool isSavingEnabled(){ return m_map_saving_enabled; } + u64 getSeed(); + s16 getWaterLevel(); + + virtual s16 updateBlockHeat(ServerEnvironment *env, v3s16 p, MapBlock *block = NULL); + virtual s16 updateBlockHumidity(ServerEnvironment *env, v3s16 p, MapBlock *block = NULL); + private: - // Seed used for all kinds of randomness - u64 m_seed; + // Emerge manager + EmergeManager *m_emerge; std::string m_savedir; bool m_map_saving_enabled; +#if 0 // Chunk size in MapSectors // If 0, chunks are disabled. s16 m_chunksize; // Chunks core::map m_chunks; +#endif /* Metadata is re-written on disk only if this is true. This is reset to false when written on disk. */ bool m_map_metadata_changed; + Database *dbase; }; -/* - ClientMap stuff -*/ - -#ifndef SERVER - -struct MapDrawControl -{ - MapDrawControl(): - range_all(false), - wanted_range(50), - wanted_max_blocks(0), - wanted_min_range(0), - blocks_drawn(0), - blocks_would_have_drawn(0) - { - } - // Overrides limits by drawing everything - bool range_all; - // Wanted drawing range - float wanted_range; - // Maximum number of blocks to draw - u32 wanted_max_blocks; - // Blocks in this range are drawn regardless of number of blocks drawn - float wanted_min_range; - // Number of blocks rendered is written here by the renderer - u32 blocks_drawn; - // Number of blocks that would have been drawn in wanted_range - u32 blocks_would_have_drawn; -}; - -class Client; - -/* - ClientMap - - This is the only map class that is able to render itself on screen. -*/ - -class ClientMap : public Map, public scene::ISceneNode -{ -public: - ClientMap( - Client *client, - MapDrawControl &control, - scene::ISceneNode* parent, - scene::ISceneManager* mgr, - s32 id - ); - - ~ClientMap(); - - s32 mapType() const - { - return MAPTYPE_CLIENT; - } - - void drop() - { - ISceneNode::drop(); - } - - void updateCamera(v3f pos, v3f dir) - { - JMutexAutoLock lock(m_camera_mutex); - m_camera_position = pos; - m_camera_direction = dir; - } - - /* - Forcefully get a sector from somewhere - */ - MapSector * emergeSector(v2s16 p); - - void deSerializeSector(v2s16 p2d, std::istream &is); - - /* - ISceneNode methods - */ - - virtual void OnRegisterSceneNode(); - - virtual void render() - { - video::IVideoDriver* driver = SceneManager->getVideoDriver(); - driver->setTransform(video::ETS_WORLD, AbsoluteTransformation); - renderMap(driver, SceneManager->getSceneNodeRenderPass()); - } - - virtual const core::aabbox3d& getBoundingBox() const - { - return m_box; - } - - void renderMap(video::IVideoDriver* driver, s32 pass); - - /* - Methods for setting temporary modifications to nodes for - drawing. - - Returns true if something changed. - - All blocks whose mesh could have been changed are inserted - to affected_blocks. - */ - bool setTempMod(v3s16 p, NodeMod mod, - core::map *affected_blocks=NULL); - bool clearTempMod(v3s16 p, - core::map *affected_blocks=NULL); - // Efficient implementation needs a cache of TempMods - //void clearTempMods(); - - void expireMeshes(bool only_daynight_diffed); - - /* - Update the faces of the given block and blocks on the - leading edge. - */ - void updateMeshes(v3s16 blockpos, u32 daynight_ratio); - - // Update meshes that touch the node - //void updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio); - - // For debug printing - virtual void PrintInfo(std::ostream &out); - -private: - Client *m_client; - - core::aabbox3d m_box; - - // This is the master heightmap mesh - //scene::SMesh *mesh; - //JMutex mesh_mutex; - - MapDrawControl &m_control; - - v3f m_camera_position; - v3f m_camera_direction; - JMutex m_camera_mutex; - -}; - -#endif +#define VMANIP_BLOCK_DATA_INEXIST 1 +#define VMANIP_BLOCK_CONTAINS_CIGNORE 2 class MapVoxelManipulator : public VoxelManipulator { public: MapVoxelManipulator(Map *map); virtual ~MapVoxelManipulator(); - + virtual void clear() { VoxelManipulator::clear(); @@ -771,15 +539,15 @@ class MapVoxelManipulator : public VoxelManipulator virtual void emerge(VoxelArea a, s32 caller_id=-1); - void blitBack(core::map & modified_blocks); + void blitBack(std::map & modified_blocks); protected: Map *m_map; /* key = blockpos - value = block existed when loaded + value = flags describing the block */ - core::map m_loaded_blocks; + std::map m_loaded_blocks; }; class ManualMapVoxelManipulator : public MapVoxelManipulator @@ -790,41 +558,18 @@ class ManualMapVoxelManipulator : public MapVoxelManipulator void setMap(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); + // This is much faster with big chunks of generated data - void blitBackAll(core::map * modified_blocks); + void blitBackAll(std::map * modified_blocks); protected: bool m_create_area; }; -struct ChunkMakeData -{ - bool no_op; - ManualMapVoxelManipulator vmanip; - u64 seed; - v2s16 chunkpos; - s16 y_blocks_min; - s16 y_blocks_max; - v2s16 sectorpos_base; - s16 sectorpos_base_size; - v2s16 sectorpos_bigbase; - s16 sectorpos_bigbase_size; - s16 max_spread_amount; - UniqueQueue transforming_liquid; - - ChunkMakeData(): - no_op(false), - vmanip(NULL), - seed(0) - {} -}; - -void makeChunk(ChunkMakeData *data); - #endif