#endif
#include "common_irrlicht.h"
-#include "heightmap.h"
-#include "loadstatus.h"
+//#include "heightmap.h"
#include "mapnode.h"
#include "mapblock.h"
#include "mapsector.h"
#include "constants.h"
#include "voxel.h"
-
-class Map;
-
-/*
- A cache for short-term fast access to map data
-
- NOTE: This doesn't really make anything more efficient
- NOTE: Use VoxelManipulator, if possible
- TODO: Get rid of this?
- NOTE: CONFIRMED: THIS CACHE DOESN'T MAKE ANYTHING ANY FASTER
-*/
-class MapBlockPointerCache : public NodeContainer
-{
-public:
- MapBlockPointerCache(Map *map);
- ~MapBlockPointerCache();
-
- virtual u16 nodeContainerId() const
- {
- return NODECONTAINER_ID_MAPBLOCKCACHE;
- }
-
- MapBlock * getBlockNoCreate(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;
- }
-
- // virtual from NodeContainer
- MapNode getNode(v3s16 p)
- {
- v3s16 blockpos = getNodeBlockPos(p);
- MapBlock * blockref = getBlockNoCreate(blockpos);
- v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
-
- return blockref->getNodeNoCheck(relpos);
- }
-
- // virtual from NodeContainer
- void setNode(v3s16 p, MapNode & n)
- {
- v3s16 blockpos = getNodeBlockPos(p);
- MapBlock * block = getBlockNoCreate(blockpos);
- v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
- block->setNodeNoCheck(relpos, n);
- m_modified_blocks[blockpos] = block;
- }
-
- core::map<v3s16, MapBlock*> m_modified_blocks;
-
-private:
- Map *m_map;
- core::map<v3s16, MapBlock*> m_blocks;
-
- u32 m_from_cache_count;
- u32 m_from_map_count;
-};
-
-class CacheLock
-{
-public:
- CacheLock()
- {
- m_count = 0;
- m_count_mutex.Init();
- m_cache_mutex.Init();
- m_waitcache_mutex.Init();
- }
-
- void cacheCreated()
- {
- //dstream<<"cacheCreated() begin"<<std::endl;
- JMutexAutoLock waitcachelock(m_waitcache_mutex);
- JMutexAutoLock countlock(m_count_mutex);
-
- // If this is the first cache, grab the cache lock
- if(m_count == 0)
- m_cache_mutex.Lock();
-
- m_count++;
-
- //dstream<<"cacheCreated() end"<<std::endl;
- }
-
- void cacheRemoved()
- {
- //dstream<<"cacheRemoved() begin"<<std::endl;
- JMutexAutoLock countlock(m_count_mutex);
-
- assert(m_count > 0);
-
- m_count--;
-
- // If this is the last one, release the cache lock
- if(m_count == 0)
- m_cache_mutex.Unlock();
-
- //dstream<<"cacheRemoved() end"<<std::endl;
- }
-
- /*
- This lock should be taken when removing stuff that can be
- pointed by the cache.
-
- You'll want to grab this in a SharedPtr.
- */
- JMutexAutoLock * waitCaches()
- {
- //dstream<<"waitCaches() begin"<<std::endl;
- JMutexAutoLock waitcachelock(m_waitcache_mutex);
- JMutexAutoLock *lock = new JMutexAutoLock(m_cache_mutex);
- //dstream<<"waitCaches() end"<<std::endl;
- return lock;
- }
-
-private:
- // Count of existing caches
- u32 m_count;
- JMutex m_count_mutex;
- // This is locked always when there are some caches
- JMutex m_cache_mutex;
- // Locked so that when waitCaches() is called, no more caches are created
- JMutex m_waitcache_mutex;
-};
+#include "mapchunk.h"
#define MAPTYPE_BASE 0
#define MAPTYPE_SERVER 1
#define MAPTYPE_CLIENT 2
-class Map : public NodeContainer, public Heightmappish
+class Map : public NodeContainer
{
-protected:
-
- std::ostream &m_dout;
-
- core::map<v2s16, MapSector*> 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;
-
- WrapperHeightmap m_hwrapper;
-
public:
- v3s16 drawoffset; // for drawbox()
-
- /*
- Used by MapBlockPointerCache.
-
- waitCaches() can be called to remove all caches before continuing
- */
- CacheLock m_blockcachelock;
-
Map(std::ostream &dout);
virtual ~Map();
return MAPTYPE_BASE;
}
+ virtual void drop()
+ {
+ delete this;
+ }
+
void updateCamera(v3f pos, v3f dir)
{
JMutexAutoLock lock(m_camera_mutex);
m_camera_direction = dir;
}
- /*void StartUpdater()
- {
- updater.Start();
- }
-
- void StopUpdater()
- {
- updater.setRun(false);
- while(updater.IsRunning())
- sleep_s(1);
- }
-
- bool UpdaterIsRunning()
- {
- return updater.IsRunning();
- }*/
-
static core::aabbox3d<f32> getNodeBox(v3s16 p)
{
return core::aabbox3d<f32>(
(float)p.Z * BS + 0.5*BS
);
}
-
- //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<v3s16, MapBlock*> &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);
}
// virtual from NodeContainer
+ // throws InvalidPositionException if not found
MapNode getNode(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
}
// virtual from NodeContainer
+ // throws InvalidPositionException if not found
void setNode(v3s16 p, MapNode & n)
{
v3s16 blockpos = getNodeBlockPos(p);
blockref->setNode(relpos, n);
}*/
- void unspreadLight(core::map<v3s16, u8> & from_nodes,
+ void unspreadLight(enum LightBank bank,
+ core::map<v3s16, u8> & from_nodes,
core::map<v3s16, bool> & light_sources,
core::map<v3s16, MapBlock*> & modified_blocks);
- void unLightNeighbors(v3s16 pos, u8 lightwas,
+ void unLightNeighbors(enum LightBank bank,
+ v3s16 pos, u8 lightwas,
core::map<v3s16, bool> & light_sources,
core::map<v3s16, MapBlock*> & modified_blocks);
- void spreadLight(core::map<v3s16, bool> & from_nodes,
+ void spreadLight(enum LightBank bank,
+ core::map<v3s16, bool> & from_nodes,
core::map<v3s16, MapBlock*> & modified_blocks);
- void lightNeighbors(v3s16 pos,
+ void lightNeighbors(enum LightBank bank,
+ v3s16 pos,
core::map<v3s16, MapBlock*> & modified_blocks);
- v3s16 getBrightestNeighbour(v3s16 p);
+ v3s16 getBrightestNeighbour(enum LightBank bank, v3s16 p);
s16 propagateSunlight(v3s16 start,
core::map<v3s16, MapBlock*> & modified_blocks);
+ void updateLighting(enum LightBank bank,
+ core::map<v3s16, MapBlock*> & a_blocks,
+ core::map<v3s16, MapBlock*> & modified_blocks);
+
void updateLighting(core::map<v3s16, MapBlock*> & a_blocks,
core::map<v3s16, MapBlock*> & modified_blocks);
void removeNodeAndUpdate(v3s16 p,
core::map<v3s16, MapBlock*> &modified_blocks);
+#ifndef SERVER
+ void expireMeshes(bool only_daynight_diffed);
+
/*
- Updates the faces of the given block and blocks on the
+ Update the faces of the given block and blocks on the
leading edge.
*/
- void updateMeshes(v3s16 blockpos);
+ void updateMeshes(v3s16 blockpos, u32 daynight_ratio);
+
+ // Update meshes that touch the node
+ //void updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio);
+#endif
+
+ /*
+ Takes the blocks at the edges into account
+ */
+ bool dayNightDiffed(v3s16 blockpos);
//core::aabbox3d<s16> getDisplayedBlockArea();
// For debug printing
virtual void PrintInfo(std::ostream &out);
-};
+
+ void transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks);
-// Master heightmap parameters
-struct HMParams
-{
- HMParams()
- {
- blocksize = 64;
- randmax = "constant 70.0";
- randfactor = "constant 0.6";
- base = "linear 0 80 0";
- }
- s16 blocksize;
- std::string randmax;
- std::string randfactor;
- std::string base;
-};
+ /*
+ Variables
+ */
+
+protected:
-// Map parameters
-struct MapParams
-{
- MapParams()
- {
- plants_amount = 1.0;
- ravines_amount = 1.0;
- //max_objects_in_block = 30;
- }
- float plants_amount;
- float ravines_amount;
- //u16 max_objects_in_block;
+ std::ostream &m_dout;
+
+ core::map<v2s16, MapSector*> 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;
+
+ //WrapperHeightmap m_hwrapper;
+
+ // Queued transforming water nodes
+ UniqueQueue<v3s16> m_transforming_liquid;
};
+/*
+ ServerMap
+
+ This is the only map class that is able to generate map.
+*/
+
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
}
/*
- 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)
+ {
+ 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)
+ {
+ 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<v2s16, MapChunk*>::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)
+ {
+ /*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;
+ }
+
+ /*
+ Generate a chunk.
+
+ All chunks touching this one can be altered also.
+ */
+ MapChunk* generateChunkRaw(v2s16 chunkpos,
+ core::map<v3s16, MapBlock*> &changed_blocks);
+
+ /*
+ Generate a chunk and its neighbors so that it won't be touched
+ anymore.
+ */
+ MapChunk* generateChunk(v2s16 chunkpos,
+ core::map<v3s16, MapBlock*> &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<v3s16, MapBlock*> &changed_blocks);
+
+ MapSector * emergeSector(v2s16 p)
+ {
+ core::map<v3s16, MapBlock*> changed_blocks;
+ return emergeSector(p, changed_blocks);
+ }
+
+ MapBlock * generateBlock(
+ v3s16 p,
+ MapBlock *original_dummy,
+ ServerMapSector *sector,
+ core::map<v3s16, MapBlock*> &changed_blocks,
+ core::map<v3s16, MapBlock*> &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<v3s16, MapBlock*> &changed_blocks,
+ core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
+ );
+
+#if 0
/*
Forcefully get a block from somewhere.
core::map<v3s16, MapBlock*> &changed_blocks,
core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
);
+#endif
+ /*
+ Misc. helper functions for fiddling with directory and file
+ names when saving
+ */
void createDir(std::string path);
void createSaveDir();
// returns something like "xxxxxxxx"
void save(bool only_changed);
void loadAll();
-
+
+ // TODO
+ void saveMapMeta();
+ void loadMapMeta();
+
+ // TODO
+ void saveChunkMeta();
+ void loadChunkMeta();
+
+ // DEPRECATED
void saveMasterHeightmap();
void loadMasterHeightmap();
// 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);
void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector);
// Gets from master heightmap
+ // DEPRECATED?
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
+ s16 m_chunksize;
+ // Chunks
+ core::map<v2s16, MapChunk*> m_chunks;
+};
+
+/*
+ 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
return MAPTYPE_CLIENT;
}
+ void drop()
+ {
+ ISceneNode::drop();
+ }
+
/*
Forcefully get a sector from somewhere
*/
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<v3s16, MapBlock*> *affected_blocks=NULL);
+ bool clearTempMod(v3s16 p,
+ core::map<v3s16, MapBlock*> *affected_blocks=NULL);
+ // Efficient implementation needs a cache of TempMods
+ //void clearTempMods();
// For debug printing
virtual void PrintInfo(std::ostream &out);
core::aabbox3d<f32> m_box;
// This is the master heightmap mesh
- scene::SMesh *mesh;
- JMutex mesh_mutex;
+ //scene::SMesh *mesh;
+ //JMutex mesh_mutex;
+
+ MapDrawControl &m_control;
};
+#endif
+
class MapVoxelManipulator : public VoxelManipulator
{
public:
void blitBack(core::map<v3s16, MapBlock*> & modified_blocks);
-private:
+protected:
Map *m_map;
/*
- NOTE: This might be used or not
- bool is dummy value
- SUGG: How 'bout an another VoxelManipulator for storing the
- information about which block is loaded?
+ key = blockpos
+ value = block existed when loaded
*/
core::map<v3s16, bool> m_loaded_blocks;
};
+class ManualMapVoxelManipulator : public MapVoxelManipulator
+{
+public:
+ ManualMapVoxelManipulator(Map *map);
+ virtual ~ManualMapVoxelManipulator();
+
+ 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<v3s16, MapBlock*> * modified_blocks);
+
+protected:
+ bool m_create_area;
+};
+
#endif
projects / oweals / minetest.git / blobdiff