X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.h;h=c48f337e07efc6a14dc714db0d985d56004b297b;hb=5e806690fc5e0067247bbc1e541ba03b83fb761b;hp=692b54318a4e17163b4c2c146415fd853086f671;hpb=22e186b4aa88b585e71500c4e9a03bf69b0b6191;p=minetest.git diff --git a/src/mapblock.h b/src/mapblock.h index 692b54318..c48f337e0 100644 --- a/src/mapblock.h +++ b/src/mapblock.h @@ -20,28 +20,25 @@ with this program; if not, write to the Free Software Foundation, Inc., #ifndef MAPBLOCK_HEADER #define MAPBLOCK_HEADER -#include -#include -#include +#include #include "debug.h" -#include "irrlichttypes.h" #include "irr_v3d.h" -#include "irr_aabb3d.h" #include "mapnode.h" #include "exceptions.h" -#include "serialization.h" #include "constants.h" -#include "voxel.h" #include "staticobject.h" #include "nodemetadata.h" #include "nodetimer.h" #include "modifiedstate.h" #include "util/numeric.h" // getContainerPos +#include "settings.h" +#include "mapgen.h" class Map; class NodeMetadataList; class IGameDef; class MapBlockMesh; +class VoxelManipulator; #define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff @@ -102,21 +99,46 @@ class NodeContainer }; #endif -/* - MapBlock itself -*/ +//// +//// MapBlock modified reason flags +//// + +#define MOD_REASON_INITIAL (1 << 0) +#define MOD_REASON_REALLOCATE (1 << 1) +#define MOD_REASON_SET_IS_UNDERGROUND (1 << 2) +#define MOD_REASON_SET_LIGHTING_COMPLETE (1 << 3) +#define MOD_REASON_SET_GENERATED (1 << 4) +#define MOD_REASON_SET_NODE (1 << 5) +#define MOD_REASON_SET_NODE_NO_CHECK (1 << 6) +#define MOD_REASON_SET_TIMESTAMP (1 << 7) +#define MOD_REASON_REPORT_META_CHANGE (1 << 8) +#define MOD_REASON_CLEAR_ALL_OBJECTS (1 << 9) +#define MOD_REASON_BLOCK_EXPIRED (1 << 10) +#define MOD_REASON_ADD_ACTIVE_OBJECT_RAW (1 << 11) +#define MOD_REASON_REMOVE_OBJECTS_REMOVE (1 << 12) +#define MOD_REASON_REMOVE_OBJECTS_DEACTIVATE (1 << 13) +#define MOD_REASON_TOO_MANY_OBJECTS (1 << 14) +#define MOD_REASON_STATIC_DATA_ADDED (1 << 15) +#define MOD_REASON_STATIC_DATA_REMOVED (1 << 16) +#define MOD_REASON_STATIC_DATA_CHANGED (1 << 17) +#define MOD_REASON_EXPIRE_DAYNIGHTDIFF (1 << 18) +#define MOD_REASON_UNKNOWN (1 << 19) + +//// +//// MapBlock itself +//// class MapBlock /*: public NodeContainer*/ { public: MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false); ~MapBlock(); - + /*virtual u16 nodeContainerId() const { return NODECONTAINER_ID_MAPBLOCK; }*/ - + Map * getParent() { return m_parent; @@ -124,127 +146,140 @@ class MapBlock /*: public NodeContainer*/ void reallocate() { - if(data != NULL) - delete[] data; - u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE; - data = new MapNode[l]; - for(u32 i=0; i m_modified){ + if (mod > m_modified) { m_modified = mod; m_modified_reason = reason; - m_modified_reason_too_long = false; - - if(m_modified >= MOD_STATE_WRITE_AT_UNLOAD){ + if (m_modified >= MOD_STATE_WRITE_AT_UNLOAD) m_disk_timestamp = m_timestamp; - } - } else if(mod == m_modified){ - if(!m_modified_reason_too_long){ - if(m_modified_reason.size() < 40) - m_modified_reason += ", " + reason; - else{ - m_modified_reason += "..."; - m_modified_reason_too_long = true; - } - } + } else if (mod == m_modified) { + m_modified_reason |= reason; } } - u32 getModified() + + inline u32 getModified() { return m_modified; } - std::string getModifiedReason() + + inline u32 getModifiedReason() { return m_modified_reason; } - void resetModified() + + std::string getModifiedReasonString(); + + inline void resetModified() { m_modified = MOD_STATE_CLEAN; - m_modified_reason = "none"; - m_modified_reason_too_long = false; + m_modified_reason = 0; + } + + //// + //// Flags + //// + + inline bool isDummy() + { + return (data == NULL); + } + + inline void unDummify() + { + assert(isDummy()); // Pre-condition + reallocate(); } - + // is_underground getter/setter - bool getIsUnderground() + inline bool getIsUnderground() { return is_underground; } - void setIsUnderground(bool a_is_underground) + + inline void setIsUnderground(bool a_is_underground) { is_underground = a_is_underground; - raiseModified(MOD_STATE_WRITE_NEEDED, "setIsUnderground"); + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND); } - void setLightingExpired(bool expired) + inline void setLightingComplete(u16 newflags) { - if(expired != m_lighting_expired){ - m_lighting_expired = expired; - raiseModified(MOD_STATE_WRITE_NEEDED, "setLightingExpired"); + if (newflags != m_lighting_complete) { + m_lighting_complete = newflags; + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_COMPLETE); } } - bool getLightingExpired() + + inline u16 getLightingComplete() { - return m_lighting_expired; + return m_lighting_complete; } - bool isGenerated() + inline void setLightingComplete(LightBank bank, u8 direction, + bool is_complete) { - return m_generated; + assert(direction >= 0 && direction <= 5); + if (bank == LIGHTBANK_NIGHT) { + direction += 6; + } + u16 newflags = m_lighting_complete; + if (is_complete) { + newflags |= 1 << direction; + } else { + newflags &= ~(1 << direction); + } + setLightingComplete(newflags); } - void setGenerated(bool b) + + inline bool isLightingComplete(LightBank bank, u8 direction) { - if(b != m_generated){ - raiseModified(MOD_STATE_WRITE_NEEDED, "setGenerated"); - m_generated = b; + assert(direction >= 0 && direction <= 5); + if (bank == LIGHTBANK_NIGHT) { + direction += 6; } + return (m_lighting_complete & (1 << direction)) != 0; } - bool isValid() + inline bool isGenerated() { - if(m_lighting_expired) - return false; - if(data == NULL) - return false; - return true; + return m_generated; } - /* - Position stuff - */ + inline void setGenerated(bool b) + { + if (b != m_generated) { + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_GENERATED); + m_generated = b; + } + } + + //// + //// Position stuff + //// - v3s16 getPos() + inline v3s16 getPos() { return m_pos; } - - v3s16 getPosRelative() + + inline v3s16 getPosRelative() { - return m_pos * MAP_BLOCKSIZE; + return m_pos_relative; } - - core::aabbox3d getBox() + + inline core::aabbox3d getBox() { return core::aabbox3d(getPosRelative(), getPosRelative() @@ -252,137 +287,150 @@ class MapBlock /*: public NodeContainer*/ - v3s16(1,1,1)); } - /* - Regular MapNode get-setters - */ - - bool isValidPosition(v3s16 p) + //// + //// Regular MapNode get-setters + //// + + inline bool isValidPosition(s16 x, s16 y, s16 z) { - if(data == NULL) - return false; - return (p.X >= 0 && p.X < MAP_BLOCKSIZE - && p.Y >= 0 && p.Y < MAP_BLOCKSIZE - && p.Z >= 0 && p.Z < MAP_BLOCKSIZE); + return data != NULL + && x >= 0 && x < MAP_BLOCKSIZE + && y >= 0 && y < MAP_BLOCKSIZE + && z >= 0 && z < MAP_BLOCKSIZE; } - MapNode getNode(s16 x, s16 y, s16 z) + inline bool isValidPosition(v3s16 p) { - if(data == NULL) - throw InvalidPositionException(); - if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException(); - if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException(); - if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException(); - return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x]; + return isValidPosition(p.X, p.Y, p.Z); } - - MapNode getNode(v3s16 p) + + inline MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position) { - return getNode(p.X, p.Y, p.Z); + *valid_position = isValidPosition(x, y, z); + + if (!*valid_position) + return MapNode(CONTENT_IGNORE); + + return data[z * zstride + y * ystride + x]; } - - MapNode getNodeNoEx(v3s16 p) + + inline MapNode getNode(v3s16 p, bool *valid_position) { - try{ - return getNode(p.X, p.Y, p.Z); - }catch(InvalidPositionException &e){ - return MapNode(CONTENT_IGNORE); - } + return getNode(p.X, p.Y, p.Z, valid_position); } - - void setNode(s16 x, s16 y, s16 z, MapNode & n) + + inline MapNode getNodeNoEx(v3s16 p) { - if(data == NULL) + bool is_valid; + return getNode(p.X, p.Y, p.Z, &is_valid); + } + + inline void setNode(s16 x, s16 y, s16 z, MapNode & n) + { + if (!isValidPosition(x, y, z)) throw InvalidPositionException(); - if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException(); - if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException(); - if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException(); - data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n; - raiseModified(MOD_STATE_WRITE_NEEDED, "setNode"); + + data[z * zstride + y * ystride + x] = n; + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE); } - - void setNode(v3s16 p, MapNode & n) + + inline void setNode(v3s16 p, MapNode & n) { setNode(p.X, p.Y, p.Z, n); } - /* - Non-checking variants of the above - */ + //// + //// Non-checking variants of the above + //// - MapNode getNodeNoCheck(s16 x, s16 y, s16 z) + inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z, bool *valid_position) { - if(data == NULL) - throw InvalidPositionException(); - return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x]; + *valid_position = data != NULL; + if (!valid_position) + return MapNode(CONTENT_IGNORE); + + return data[z * zstride + y * ystride + x]; + } + + inline MapNode getNodeNoCheck(v3s16 p, bool *valid_position) + { + return getNodeNoCheck(p.X, p.Y, p.Z, valid_position); + } + + //// + //// Non-checking, unsafe variants of the above + //// MapBlock must be loaded by another function in the same scope/function + //// Caller must ensure that this is not a dummy block (by calling isDummy()) + //// + + inline const MapNode &getNodeUnsafe(s16 x, s16 y, s16 z) + { + return data[z * zstride + y * ystride + x]; } - - MapNode getNodeNoCheck(v3s16 p) + + inline const MapNode &getNodeUnsafe(v3s16 &p) { - return getNodeNoCheck(p.X, p.Y, p.Z); + return getNodeUnsafe(p.X, p.Y, p.Z); } - - void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n) + + inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n) { - if(data == NULL) + if (data == NULL) throw InvalidPositionException(); - data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n; - raiseModified(MOD_STATE_WRITE_NEEDED, "setNodeNoCheck"); + + data[z * zstride + y * ystride + x] = n; + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE_NO_CHECK); } - - void setNodeNoCheck(v3s16 p, MapNode & n) + + inline void setNodeNoCheck(v3s16 p, MapNode & n) { setNodeNoCheck(p.X, p.Y, p.Z, n); } - /* - These functions consult the parent container if the position - is not valid on this MapBlock. - */ + // These functions consult the parent container if the position + // is not valid on this MapBlock. bool isValidPositionParent(v3s16 p); - MapNode getNodeParent(v3s16 p); + MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL); void setNodeParent(v3s16 p, MapNode & n); - MapNode getNodeParentNoEx(v3s16 p); - void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node) + inline void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node) { - for(u16 z=0; z & light_sources, - bool remove_light=false, bool *black_air_left=NULL); - + bool propagateSunlight(std::set &light_sources, + bool remove_light=false, bool *black_air_left=NULL); + // Copies data to VoxelManipulator to getPosRelative() void copyTo(VoxelManipulator &dst); + // Copies data from VoxelManipulator getPosRelative() void copyFrom(VoxelManipulator &dst); - /* - Update day-night lighting difference flag. - Sets m_day_night_differs to appropriate value. - These methods don't care about neighboring blocks. - */ + // Update day-night lighting difference flag. + // Sets m_day_night_differs to appropriate value. + // These methods don't care about neighboring blocks. void actuallyUpdateDayNightDiff(); - /* - Call this to schedule what the previous function does to be done - when the value is actually needed. - */ + + // Call this to schedule what the previous function does to be done + // when the value is actually needed. void expireDayNightDiff(); - bool getDayNightDiff() + inline bool getDayNightDiff() { - if(m_day_night_differs_expired) + if (m_day_night_differs_expired) actuallyUpdateDayNightDiff(); return m_day_night_differs; } - /* - Miscellaneous stuff - */ - + //// + //// Miscellaneous stuff + //// + /* Tries to measure ground level. Return value: @@ -393,91 +441,109 @@ class MapBlock /*: public NodeContainer*/ */ s16 getGroundLevel(v2s16 p2d); - /* - Timestamp (see m_timestamp) - NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. - */ - void setTimestamp(u32 time) + //// + //// Timestamp (see m_timestamp) + //// + + // NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. + + inline void setTimestamp(u32 time) { m_timestamp = time; - raiseModified(MOD_STATE_WRITE_AT_UNLOAD, "setTimestamp"); + raiseModified(MOD_STATE_WRITE_AT_UNLOAD, MOD_REASON_SET_TIMESTAMP); } - void setTimestampNoChangedFlag(u32 time) + + inline void setTimestampNoChangedFlag(u32 time) { m_timestamp = time; } - u32 getTimestamp() + + inline u32 getTimestamp() { return m_timestamp; } - u32 getDiskTimestamp() + + inline u32 getDiskTimestamp() { return m_disk_timestamp; } - - /* - See m_usage_timer - */ - void resetUsageTimer() + + //// + //// Usage timer (see m_usage_timer) + //// + + inline void resetUsageTimer() { m_usage_timer = 0; } - void incrementUsageTimer(float dtime) + + inline void incrementUsageTimer(float dtime) { m_usage_timer += dtime; } - u32 getUsageTimer() + + inline float getUsageTimer() { return m_usage_timer; } - /* - See m_refcount - */ - void refGrab() + //// + //// Reference counting (see m_refcount) + //// + + inline void refGrab() { m_refcount++; } - void refDrop() + + inline void refDrop() { m_refcount--; } - int refGet() + + inline int refGet() { return m_refcount; } - - /* - Node Timers - */ - // Get timer - NodeTimer getNodeTimer(v3s16 p){ + + //// + //// Node Timers + //// + + inline NodeTimer getNodeTimer(v3s16 p) + { return m_node_timers.get(p); } - // Deletes timer - void removeNodeTimer(v3s16 p){ + + inline void removeNodeTimer(v3s16 p) + { m_node_timers.remove(p); } - // Deletes old timer and sets a new one - void setNodeTimer(v3s16 p, NodeTimer t){ - m_node_timers.set(p,t); + + inline void setNodeTimer(const NodeTimer &t) + { + m_node_timers.set(t); } - // Deletes all timers - void clearNodeTimers(){ + + inline void clearNodeTimers() + { m_node_timers.clear(); } - /* - Serialization - */ - + //// + //// Serialization + /// + // These don't write or read version by itself // Set disk to true for on-disk format, false for over-the-network format + // Precondition: version >= SER_FMT_VER_LOWEST_WRITE void serialize(std::ostream &os, u8 version, bool disk); // If disk == true: In addition to doing other things, will add // unknown blocks from id-name mapping to wndef void deSerialize(std::istream &is, u8 version, bool disk); + void serializeNetworkSpecific(std::ostream &os); + void deSerializeNetworkSpecific(std::istream &is); private: /* Private methods @@ -489,16 +555,15 @@ class MapBlock /*: public NodeContainer*/ Used only internally, because changes can't be tracked */ - MapNode & getNodeRef(s16 x, s16 y, s16 z) + inline MapNode &getNodeRef(s16 x, s16 y, s16 z) { - if(data == NULL) + if (!isValidPosition(x, y, z)) throw InvalidPositionException(); - if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException(); - if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException(); - if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException(); - return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x]; + + return data[z * zstride + y * ystride + x]; } - MapNode & getNodeRef(v3s16 &p) + + inline MapNode &getNodeRef(v3s16 &p) { return getNodeRef(p.X, p.Y, p.Z); } @@ -510,13 +575,17 @@ class MapBlock /*: public NodeContainer*/ #ifndef SERVER // Only on client MapBlockMesh *mesh; - //JMutex mesh_mutex; #endif - + NodeMetadataList m_node_metadata; NodeTimerList m_node_timers; StaticObjectList m_static_objects; - + + static const u32 ystride = MAP_BLOCKSIZE; + static const u32 zstride = MAP_BLOCKSIZE * MAP_BLOCKSIZE; + + static const u32 nodecount = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE; + private: /* Private member variables @@ -527,13 +596,21 @@ class MapBlock /*: public NodeContainer*/ // Position in blocks on parent v3s16 m_pos; + /* This is the precalculated m_pos_relative value + * This caches the value, improving performance by removing 3 s16 multiplications + * at runtime on each getPosRelative call + * For a 5 minutes runtime with valgrind this removes 3 * 19M s16 multiplications + * The gain can be estimated in Release Build to 3 * 100M multiply operations for 5 mins + */ + v3s16 m_pos_relative; + IGameDef *m_gamedef; - + /* If NULL, block is a dummy block. Dummy blocks are used for caching not-found-on-disk blocks. */ - MapNode * data; + MapNode *data; /* - On the server, this is used for telling whether the @@ -541,8 +618,7 @@ class MapBlock /*: public NodeContainer*/ - On the client, this is used for nothing. */ u32 m_modified; - std::string m_modified_reason; - bool m_modified_reason_too_long; + u32 m_modified_reason; /* When propagating sunlight and the above block doesn't exist, @@ -554,21 +630,21 @@ class MapBlock /*: public NodeContainer*/ */ bool is_underground; - /* - Set to true if changes has been made that make the old lighting - values wrong but the lighting hasn't been actually updated. - - If this is false, lighting is exactly right. - If this is true, lighting might be wrong or right. + /*! + * Each bit indicates if light spreading was finished + * in a direction. (Because the neighbor could also be unloaded.) + * Bits: day X+, day Y+, day Z+, day Z-, day Y-, day X-, + * night X+, night Y+, night Z+, night Z-, night Y-, night X-, + * nothing, nothing, nothing, nothing. */ - bool m_lighting_expired; - + u16 m_lighting_complete; + // Whether day and night lighting differs bool m_day_night_differs; bool m_day_night_differs_expired; bool m_generated; - + /* When block is removed from active blocks, this is set to gametime. Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. @@ -590,15 +666,28 @@ class MapBlock /*: public NodeContainer*/ int m_refcount; }; -inline bool blockpos_over_limit(v3s16 p) +typedef std::vector MapBlockVect; + +inline bool objectpos_over_limit(v3f p) +{ + const float max_limit_bs = MAX_MAP_GENERATION_LIMIT * BS; + return p.X < -max_limit_bs || + p.X > max_limit_bs || + p.Y < -max_limit_bs || + p.Y > max_limit_bs || + p.Z < -max_limit_bs || + p.Z > max_limit_bs; +} + +inline bool blockpos_over_max_limit(v3s16 p) { - return - (p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE); + const s16 max_limit_bp = MAX_MAP_GENERATION_LIMIT / MAP_BLOCKSIZE; + return p.X < -max_limit_bp || + p.X > max_limit_bp || + p.Y < -max_limit_bp || + p.Y > max_limit_bp || + p.Z < -max_limit_bp || + p.Z > max_limit_bp; } /* @@ -619,10 +708,19 @@ inline s16 getNodeBlockY(s16 y) return getContainerPos(y, MAP_BLOCKSIZE); } +inline void getNodeBlockPosWithOffset(const v3s16 &p, v3s16 &block, v3s16 &offset) +{ + getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset); +} + +inline void getNodeSectorPosWithOffset(const v2s16 &p, v2s16 &block, v2s16 &offset) +{ + getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset); +} + /* Get a quick string to describe what a block actually contains */ std::string analyze_block(MapBlock *block); #endif -