X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.h;h=fa52dc26b33ca1de90ed7e3031e9a60410d9b003;hb=94c9686020798c8ec8113c242dc1dfe0c2accf71;hp=482ab2ac79ef03e547af42d067e29125925d6bc9;hpb=24c4b7c68d283a4d1de72a3eb68f1268f1fe34e3;p=minetest.git diff --git a/src/map.h b/src/map.h index 482ab2ac7..fa52dc26b 100644 --- a/src/map.h +++ b/src/map.h @@ -1,5 +1,20 @@ /* -(c) 2010 Perttu Ahola +Minetest-c55 +Copyright (C) 2010-2011 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 +(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. + +You should have received a copy of the GNU 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. */ #ifndef MAP_HEADER @@ -8,7 +23,6 @@ #include #include #include -#include #ifdef _WIN32 #include @@ -19,47 +33,66 @@ #endif #include "common_irrlicht.h" -#include "heightmap.h" -#include "loadstatus.h" #include "mapnode.h" #include "mapblock.h" #include "mapsector.h" #include "constants.h" - -class InvalidFilenameException : public BaseException -{ -public: - InvalidFilenameException(const char *s): - BaseException(s) - {} -}; +#include "voxel.h" +#include "mapchunk.h" +#include "nodemetadata.h" #define MAPTYPE_BASE 0 #define MAPTYPE_SERVER 1 #define MAPTYPE_CLIENT 2 -class Map : public NodeContainer, public Heightmappish -{ -protected: - - std::ostream &m_dout; - - core::map m_sectors; - JMutex m_sector_mutex; - - v3f m_camera_position; - v3f m_camera_direction; - JMutex m_camera_mutex; - - // Be sure to set this to NULL when the cached sector is deleted - MapSector *m_sector_cache; - v2s16 m_sector_cache_p; +enum MapEditEventType{ + MEET_ADDNODE, + MEET_REMOVENODE, + MEET_OTHER +}; - WrapperHeightmap m_hwrapper; +struct MapEditEvent +{ + MapEditEventType type; + v3s16 p; + MapNode n; + core::map modified_blocks; + u16 already_known_by_peer; + + MapEditEvent(): + type(MEET_OTHER), + 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++) + { + v3s16 p = i.getNode()->getKey(); + bool v = i.getNode()->getValue(); + event->modified_blocks.insert(p, v); + } + return event; + } +}; +class MapEventReceiver +{ public: + // event shall be deleted by caller after the call. + virtual void onMapEditEvent(MapEditEvent *event) = 0; +}; - v3s16 drawoffset; // for drawbox() +class Map : public NodeContainer +{ +public: Map(std::ostream &dout); virtual ~Map(); @@ -73,59 +106,44 @@ class Map : public NodeContainer, public Heightmappish { return MAPTYPE_BASE; } - - void updateCamera(v3f pos, v3f dir) - { - JMutexAutoLock lock(m_camera_mutex); - m_camera_position = pos; - m_camera_direction = dir; - } - - /*void StartUpdater() - { - updater.Start(); - } - - void StopUpdater() + + /* + Drop (client) or delete (server) the map. + */ + virtual void drop() { - updater.setRun(false); - while(updater.IsRunning()) - sleep_s(1); + delete this; } - bool UpdaterIsRunning() - { - return updater.IsRunning(); - }*/ - - static core::aabbox3d getNodeBox(v3s16 p) - { - return core::aabbox3d( - (float)p.X * BS - 0.5*BS, - (float)p.Y * BS - 0.5*BS, - (float)p.Z * BS - 0.5*BS, - (float)p.X * BS + 0.5*BS, - (float)p.Y * BS + 0.5*BS, - (float)p.Z * BS + 0.5*BS - ); - } + void addEventReceiver(MapEventReceiver *event_receiver); + void removeEventReceiver(MapEventReceiver *event_receiver); + // event shall be deleted by caller after the call. + void dispatchEvent(MapEditEvent *event); - //bool sectorExists(v2s16 p); + // On failure returns NULL + MapSector * getSectorNoGenerateNoExNoLock(v2s16 p2d); + // On failure returns NULL + MapSector * getSectorNoGenerateNoEx(v2s16 p2d); + // On failure throws InvalidPositionException MapSector * getSectorNoGenerate(v2s16 p2d); + // Gets an existing sector or creates an empty one + //MapSector * getSectorCreate(v2s16 p2d); + /* This is overloaded by ClientMap and ServerMap to allow their differing fetch methods. */ - virtual MapSector * emergeSector(v2s16 p) = 0; - + virtual MapSector * emergeSector(v2s16 p){ return NULL; } + virtual MapSector * emergeSector(v2s16 p, + core::map &changed_blocks){ return NULL; } + // Returns InvalidPositionException if not found MapBlock * getBlockNoCreate(v3s16 p); - //virtual MapBlock * getBlock(v3s16 p, bool generate=true); + // Returns NULL if not found + MapBlock * getBlockNoCreateNoEx(v3s16 p); + // Gets an existing block or creates an empty one + //MapBlock * getBlockCreate(v3s16 p); - // Returns InvalidPositionException if not found - f32 getGroundHeight(v2s16 p, bool generate=false); - void setGroundHeight(v2s16 p, f32 y, bool generate=false); - // Returns InvalidPositionException if not found bool isNodeUnderground(v3s16 p); @@ -148,60 +166,69 @@ class Map : public NodeContainer, public Heightmappish } // 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->getNode(relpos); + return blockref->getNodeNoCheck(relpos); } // 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->setNode(relpos, n); + blockref->setNodeNoCheck(relpos, n); } - - /*MapNode getNodeGenerate(v3s16 p) + + // Returns a CONTENT_IGNORE node if not found + MapNode getNodeNoEx(v3s16 p) { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlock(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - - return blockref->getNode(relpos); - }*/ + try{ + v3s16 blockpos = getNodeBlockPos(p); + MapBlock * blockref = getBlockNoCreate(blockpos); + v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - /*void setNodeGenerate(v3s16 p, MapNode & n) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlock(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - blockref->setNode(relpos, n); - }*/ + return blockref->getNodeNoCheck(relpos); + } + catch(InvalidPositionException &e) + { + return MapNode(CONTENT_IGNORE); + } + } - void unspreadLight(core::map & from_nodes, + void unspreadLight(enum LightBank bank, + core::map & from_nodes, core::map & light_sources, core::map & modified_blocks); - void unLightNeighbors(v3s16 pos, u8 lightwas, + void unLightNeighbors(enum LightBank bank, + v3s16 pos, u8 lightwas, core::map & light_sources, core::map & modified_blocks); - void spreadLight(core::map & from_nodes, + void spreadLight(enum LightBank bank, + core::map & from_nodes, core::map & modified_blocks); - void lightNeighbors(v3s16 pos, + void lightNeighbors(enum LightBank bank, + v3s16 pos, core::map & modified_blocks); - v3s16 getBrightestNeighbour(v3s16 p); + v3s16 getBrightestNeighbour(enum LightBank bank, v3s16 p); s16 propagateSunlight(v3s16 start, core::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); @@ -212,12 +239,19 @@ class Map : public NodeContainer, public Heightmappish core::map &modified_blocks); void removeNodeAndUpdate(v3s16 p, core::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 removeNodeWithEvent(v3s16 p); /* - Updates the faces of the given block and blocks on the - leading edge. + Takes the blocks at the edges into account */ - void updateMeshes(v3s16 blockpos); + bool dayNightDiffed(v3s16 blockpos); //core::aabbox3d getDisplayedBlockArea(); @@ -240,43 +274,61 @@ class Map : public NodeContainer, public Heightmappish // For debug printing virtual void PrintInfo(std::ostream &out); -}; + + void transformLiquids(core::map & modified_blocks); -// Master heightmap parameters -struct HMParams -{ - HMParams() - { - heightmap_blocksize = 64; - height_randmax = "constant 70.0"; - height_randfactor = "constant 0.6"; - height_base = "linear 0 80 0"; - } - s16 heightmap_blocksize; - std::string height_randmax; - std::string height_randfactor; - std::string height_base; -}; + /* + Node metadata + These are basically coordinate wrappers to MapBlock + */ + + NodeMetadata* getNodeMetadata(v3s16 p); + void setNodeMetadata(v3s16 p, NodeMetadata *meta); + void removeNodeMetadata(v3s16 p); + void nodeMetadataStep(float dtime, + core::map &changed_blocks); + + /* + Misc. + */ + core::map *getSectorsPtr(){return &m_sectors;} -// Map parameters -struct MapParams -{ - MapParams() - { - plants_amount = 1.0; - //max_objects_in_block = 30; - } - float plants_amount; - //u16 max_objects_in_block; + /* + Variables + */ + +protected: + + std::ostream &m_dout; + + core::map m_event_receivers; + + core::map m_sectors; + //JMutex m_sector_mutex; + + // Be sure to set this to NULL when the cached sector is deleted + MapSector *m_sector_cache; + v2s16 m_sector_cache_p; + + // Queued transforming water nodes + UniqueQueue m_transforming_liquid; }; +/* + ServerMap + + 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, HMParams hmp, MapParams mp); + ServerMap(std::string savedir); ~ServerMap(); s32 mapType() const @@ -285,9 +337,180 @@ class ServerMap : public Map } /* - Forcefully get a sector from somewhere + Map generation */ - MapSector * emergeSector(v2s16 p); + + // 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) + - Create blank one + */ + ServerMapSector * createSector(v2s16 p); + + /* + Get a sector from somewhere. + - Check memory + - Check disk (loads blocks also) + - Generate chunk + */ + /*MapSector * emergeSector(v2s16 p, + core::map &changed_blocks);*/ + + /*MapSector * emergeSector(v2s16 p) + { + core::map changed_blocks; + return emergeSector(p, 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. @@ -313,7 +536,15 @@ class ServerMap : public Map core::map &changed_blocks, core::map &lighting_invalidated_blocks ); +#endif + + // Helper for placing objects on ground level + s16 findGroundLevel(v2s16 p2d); + /* + Misc. helper functions for fiddling with directory and file + names when saving + */ void createDir(std::string path); void createSaveDir(); // returns something like "xxxxxxxx" @@ -326,15 +557,20 @@ class ServerMap : public Map v3s16 getBlockPos(std::string sectordir, std::string blockfile); void save(bool only_changed); - void loadAll(); - - void saveMasterHeightmap(); - void loadMasterHeightmap(); - + //void loadAll(); + + // Saves map seed and possibly other stuff + void saveMapMeta(); + void loadMapMeta(); + + 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); @@ -349,28 +585,76 @@ class ServerMap : public Map // This will generate a sector with getSector if not found. void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector); - // Gets from master heightmap - void getSectorCorners(v2s16 p2d, s16 *corners); - // For debug printing virtual void PrintInfo(std::ostream &out); + bool isSavingEnabled(){ return m_map_saving_enabled; } + private: - UnlimitedHeightmap *m_heightmap; - MapParams m_params; + // Seed used for all kinds of randomness + u64 m_seed; std::string m_savedir; bool m_map_saving_enabled; + + // Chunk size in MapSectors + // If 0, chunks are disabled. + s16 m_chunksize; + // Chunks + core::map m_chunks; + + /* + 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; +}; + +/* + 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, - video::SMaterial *materials, + MapDrawControl &control, scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id @@ -383,6 +667,18 @@ class ClientMap : public Map, public scene::ISceneNode 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 */ @@ -394,23 +690,13 @@ class ClientMap : public Map, public scene::ISceneNode ISceneNode methods */ - virtual void OnRegisterSceneNode() - { - if(IsVisible) - { - //SceneManager->registerNodeForRendering(this, scene::ESNRP_SKY_BOX); - SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID); - SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT); - } - - ISceneNode::OnRegisterSceneNode(); - } + virtual void OnRegisterSceneNode(); virtual void render() { video::IVideoDriver* driver = SceneManager->getVideoDriver(); driver->setTransform(video::ETS_WORLD, AbsoluteTransformation); - renderMap(driver, m_materials, SceneManager->getSceneNodeRenderPass()); + renderMap(driver, SceneManager->getSceneNodeRenderPass()); } virtual const core::aabbox3d& getBoundingBox() const @@ -418,11 +704,34 @@ class ClientMap : public Map, public scene::ISceneNode return m_box; } - void renderMap(video::IVideoDriver* driver, - video::SMaterial *materials, s32 pass); + void renderMap(video::IVideoDriver* driver, s32 pass); - // Update master heightmap mesh - void updateMesh(); + /* + 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); @@ -430,14 +739,90 @@ class ClientMap : public Map, public scene::ISceneNode private: Client *m_client; - video::SMaterial *m_materials; - core::aabbox3d m_box; // This is the master heightmap mesh - scene::SMesh *mesh; - JMutex mesh_mutex; + //scene::SMesh *mesh; + //JMutex mesh_mutex; + + MapDrawControl &m_control; + + v3f m_camera_position; + v3f m_camera_direction; + JMutex m_camera_mutex; + }; #endif +class MapVoxelManipulator : public VoxelManipulator +{ +public: + MapVoxelManipulator(Map *map); + virtual ~MapVoxelManipulator(); + + virtual void clear() + { + VoxelManipulator::clear(); + m_loaded_blocks.clear(); + } + + virtual void emerge(VoxelArea a, s32 caller_id=-1); + + void blitBack(core::map & modified_blocks); + +protected: + Map *m_map; + /* + key = blockpos + value = block existed when loaded + */ + core::map 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); + + // This is much faster with big chunks of generated data + void blitBackAll(core::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 +