X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.h;h=b817be5961cb188dcfa562359251ad99e29585ae;hb=d82d18bfb1a51e0f2f0a89999474e98890addf7e;hp=d46b7b8801eaafbecd51d64eef3dfafb9028d26e;hpb=ddcf8422a229c4965233177f6315847a6773a20c;p=minetest.git diff --git a/src/mapblock.h b/src/mapblock.h index d46b7b880..b817be596 100644 --- a/src/mapblock.h +++ b/src/mapblock.h @@ -17,11 +17,9 @@ with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef MAPBLOCK_HEADER -#define MAPBLOCK_HEADER +#pragma once #include -#include "debug.h" #include "irr_v3d.h" #include "mapnode.h" #include "exceptions.h" @@ -32,6 +30,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "modifiedstate.h" #include "util/numeric.h" // getContainerPos #include "settings.h" +#include "mapgen/mapgen.h" class Map; class NodeMetadataList; @@ -41,63 +40,6 @@ class VoxelManipulator; #define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff -/*// Named by looking towards z+ -enum{ - FACE_BACK=0, - FACE_TOP, - FACE_RIGHT, - FACE_FRONT, - FACE_BOTTOM, - FACE_LEFT -};*/ - -// NOTE: If this is enabled, set MapBlock to be initialized with -// CONTENT_IGNORE. -/*enum BlockGenerationStatus -{ - // Completely non-generated (filled with CONTENT_IGNORE). - BLOCKGEN_UNTOUCHED=0, - // Trees or similar might have been blitted from other blocks to here. - // Otherwise, the block contains CONTENT_IGNORE - BLOCKGEN_FROM_NEIGHBORS=2, - // Has been generated, but some neighbors might put some stuff in here - // when they are generated. - // Does not contain any CONTENT_IGNORE - BLOCKGEN_SELF_GENERATED=4, - // The block and all its neighbors have been generated - BLOCKGEN_FULLY_GENERATED=6 -};*/ - -#if 0 -enum -{ - NODECONTAINER_ID_MAPBLOCK, - NODECONTAINER_ID_MAPSECTOR, - NODECONTAINER_ID_MAP, - NODECONTAINER_ID_MAPBLOCKCACHE, - NODECONTAINER_ID_VOXELMANIPULATOR, -}; - -class NodeContainer -{ -public: - virtual bool isValidPosition(v3s16 p) = 0; - virtual MapNode getNode(v3s16 p) = 0; - virtual void setNode(v3s16 p, MapNode & n) = 0; - virtual u16 nodeContainerId() const = 0; - - MapNode getNodeNoEx(v3s16 p) - { - try{ - return getNode(p); - } - catch(InvalidPositionException &e){ - return MapNode(CONTENT_IGNORE); - } - } -}; -#endif - //// //// MapBlock modified reason flags //// @@ -105,7 +47,7 @@ class NodeContainer #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_EXPIRED (1 << 3) +#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) @@ -121,16 +63,17 @@ class NodeContainer #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) +#define MOD_REASON_VMANIP (1 << 19) +#define MOD_REASON_UNKNOWN (1 << 20) //// //// MapBlock itself //// -class MapBlock /*: public NodeContainer*/ +class MapBlock { public: - MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false); + MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef); ~MapBlock(); /*virtual u16 nodeContainerId() const @@ -145,14 +88,16 @@ class MapBlock /*: public NodeContainer*/ void reallocate() { - delete[] data; - data = new MapNode[nodecount]; for (u32 i = 0; i < nodecount; i++) data[i] = MapNode(CONTENT_IGNORE); - raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE); } + MapNode* getData() + { + return data; + } + //// //// Modification tracking methods //// @@ -166,6 +111,8 @@ class MapBlock /*: public NodeContainer*/ } else if (mod == m_modified) { m_modified_reason |= reason; } + if (mod == MOD_STATE_WRITE_NEEDED) + contents_cached = false; } inline u32 getModified() @@ -190,17 +137,6 @@ class MapBlock /*: public NodeContainer*/ //// Flags //// - inline bool isDummy() - { - return (data == NULL); - } - - inline void unDummify() - { - assert(isDummy()); // Pre-condition - reallocate(); - } - // is_underground getter/setter inline bool getIsUnderground() { @@ -213,17 +149,42 @@ class MapBlock /*: public NodeContainer*/ raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND); } - inline void setLightingExpired(bool expired) + inline void setLightingComplete(u16 newflags) + { + if (newflags != m_lighting_complete) { + m_lighting_complete = newflags; + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_COMPLETE); + } + } + + inline u16 getLightingComplete() { - if (expired != m_lighting_expired){ - m_lighting_expired = expired; - raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_EXPIRED); + return m_lighting_complete; + } + + inline void setLightingComplete(LightBank bank, u8 direction, + bool is_complete) + { + 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); } - inline bool getLightingExpired() + inline bool isLightingComplete(LightBank bank, u8 direction) { - return m_lighting_expired; + assert(direction >= 0 && direction <= 5); + if (bank == LIGHTBANK_NIGHT) { + direction += 6; + } + return (m_lighting_complete & (1 << direction)) != 0; } inline bool isGenerated() @@ -239,15 +200,6 @@ class MapBlock /*: public NodeContainer*/ } } - inline bool isValid() - { - if (m_lighting_expired) - return false; - if (data == NULL) - return false; - return true; - } - //// //// Position stuff //// @@ -276,8 +228,7 @@ class MapBlock /*: public NodeContainer*/ inline bool isValidPosition(s16 x, s16 y, s16 z) { - return data != NULL - && x >= 0 && x < MAP_BLOCKSIZE + return x >= 0 && x < MAP_BLOCKSIZE && y >= 0 && y < MAP_BLOCKSIZE && z >= 0 && z < MAP_BLOCKSIZE; } @@ -292,7 +243,7 @@ class MapBlock /*: public NodeContainer*/ *valid_position = isValidPosition(x, y, z); if (!*valid_position) - return MapNode(CONTENT_IGNORE); + return {CONTENT_IGNORE}; return data[z * zstride + y * ystride + x]; } @@ -308,7 +259,7 @@ class MapBlock /*: public NodeContainer*/ return getNode(p.X, p.Y, p.Z, &is_valid); } - inline void setNode(s16 x, s16 y, s16 z, MapNode & n) + inline void setNode(s16 x, s16 y, s16 z, MapNode n) { if (!isValidPosition(x, y, z)) throw InvalidPositionException(); @@ -317,7 +268,7 @@ class MapBlock /*: public NodeContainer*/ raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE); } - inline void setNode(v3s16 p, MapNode & n) + inline void setNode(v3s16 p, MapNode n) { setNode(p.X, p.Y, p.Z, n); } @@ -326,46 +277,23 @@ class MapBlock /*: public NodeContainer*/ //// Non-checking variants of the above //// - inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z, bool *valid_position) + inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z) { - *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) + inline MapNode getNodeNoCheck(v3s16 p) { - return getNodeNoCheck(p.X, p.Y, p.Z, valid_position); + return getNodeNoCheck(p.X, p.Y, p.Z); } - //// - //// 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]; - } - - inline const MapNode &getNodeUnsafe(v3s16 &p) + inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode n) { - return getNodeUnsafe(p.X, p.Y, p.Z); - } - - inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n) - { - if (data == NULL) - throw InvalidPositionException(); - data[z * zstride + y * ystride + x] = n; raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE_NO_CHECK); } - inline void setNodeNoCheck(v3s16 p, MapNode & n) + inline void setNodeNoCheck(v3s16 p, MapNode n) { setNodeNoCheck(p.X, p.Y, p.Z, n); } @@ -374,19 +302,6 @@ class MapBlock /*: public NodeContainer*/ // is not valid on this MapBlock. bool isValidPositionParent(v3s16 p); MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL); - void setNodeParent(v3s16 p, MapNode & n); - - inline void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node) - { - for (u16 z = 0; z < d; z++) - for (u16 y = 0; y < h; y++) - for (u16 x = 0; x < w; x++) - setNode(x0 + x, y0 + y, z0 + z, node); - } - - // See comments in mapblock.cpp - 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); @@ -410,19 +325,10 @@ class MapBlock /*: public NodeContainer*/ return m_day_night_differs; } - //// - //// Miscellaneous stuff - //// + bool onObjectsActivation(); + bool saveStaticObject(u16 id, const StaticObject &obj, u32 reason); - /* - Tries to measure ground level. - Return value: - -1 = only air - -2 = only ground - -3 = random fail - 0...MAP_BLOCKSIZE-1 = ground level - */ - s16 getGroundLevel(v2s16 p2d); + void step(float dtime, const std::function &on_timer_cb); //// //// Timestamp (see m_timestamp) @@ -520,13 +426,18 @@ class MapBlock /*: public NodeContainer*/ // 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); + void serialize(std::ostream &result, u8 version, bool disk, int compression_level); // 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, u16 net_proto_version); + void serializeNetworkSpecific(std::ostream &os); void deSerializeNetworkSpecific(std::istream &is); + + bool storeActiveObject(u16 id); + // clearObject and return removed objects count + u32 clearObjects(); + private: /* Private methods @@ -534,34 +445,16 @@ class MapBlock /*: public NodeContainer*/ void deSerialize_pre22(std::istream &is, u8 version, bool disk); - /* - Used only internally, because changes can't be tracked - */ - - inline MapNode &getNodeRef(s16 x, s16 y, s16 z) - { - if (!isValidPosition(x, y, z)) - throw InvalidPositionException(); - - return data[z * zstride + y * ystride + x]; - } - - inline MapNode &getNodeRef(v3s16 &p) - { - return getNodeRef(p.X, p.Y, p.Z); - } - public: /* Public member variables */ #ifndef SERVER // Only on client - MapBlockMesh *mesh; + MapBlockMesh *mesh = nullptr; #endif NodeMetadataList m_node_metadata; - NodeTimerList m_node_timers; StaticObjectList m_static_objects; static const u32 ystride = MAP_BLOCKSIZE; @@ -569,6 +462,16 @@ class MapBlock /*: public NodeContainer*/ static const u32 nodecount = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE; + //// ABM optimizations //// + // Cache of content types + std::unordered_set contents; + // True if content types are cached + bool contents_cached = false; + // True if we never want to cache content types for this block + bool do_not_cache_contents = false; + // marks the sides which are opaque: 00+Z-Z+Y-Y+X-X + u8 solid_sides {0}; + private: /* Private member variables @@ -589,19 +492,13 @@ class MapBlock /*: public NodeContainer*/ IGameDef *m_gamedef; - /* - If NULL, block is a dummy block. - Dummy blocks are used for caching not-found-on-disk blocks. - */ - MapNode *data; - /* - On the server, this is used for telling whether the block has been modified from the one on disk. - On the client, this is used for nothing. */ - u32 m_modified; - u32 m_modified_reason; + u32 m_modified = MOD_STATE_WRITE_NEEDED; + u32 m_modified_reason = MOD_REASON_INITIAL; /* When propagating sunlight and the above block doesn't exist, @@ -611,79 +508,70 @@ class MapBlock /*: public NodeContainer*/ undeground with nothing visible above the ground except caves. */ - 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. + bool is_underground = false; + + /*! + * Each bit indicates if light spreading was finished + * in a direction. (Because the neighbor could also be unloaded.) + * Bits (most significant first): + * nothing, nothing, nothing, nothing, + * night X-, night Y-, night Z-, night Z+, night Y+, night X+, + * day X-, day Y-, day Z-, day Z+, day Y+, day X+. */ - bool m_lighting_expired; + u16 m_lighting_complete = 0xFFFF; // Whether day and night lighting differs - bool m_day_night_differs; - bool m_day_night_differs_expired; + bool m_day_night_differs = false; + bool m_day_night_differs_expired = true; - bool m_generated; + bool m_generated = false; /* When block is removed from active blocks, this is set to gametime. Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. */ - u32 m_timestamp; + u32 m_timestamp = BLOCK_TIMESTAMP_UNDEFINED; // The on-disk (or to-be on-disk) timestamp value - u32 m_disk_timestamp; + u32 m_disk_timestamp = BLOCK_TIMESTAMP_UNDEFINED; /* When the block is accessed, this is set to 0. Map will unload the block when this reaches a timeout. */ - float m_usage_timer; + float m_usage_timer = 0; /* Reference count; currently used for determining if this block is in the list of blocks to be drawn. */ - int m_refcount; + int m_refcount = 0; + + MapNode data[nodecount]; + NodeTimerList m_node_timers; }; typedef std::vector MapBlockVect; inline bool objectpos_over_limit(v3f p) { - const static float map_gen_limit_bs = MYMIN(MAX_MAP_GENERATION_LIMIT, - g_settings->getU16("map_generation_limit")) * BS; - return (p.X < -map_gen_limit_bs - || p.X > map_gen_limit_bs - || p.Y < -map_gen_limit_bs - || p.Y > map_gen_limit_bs - || p.Z < -map_gen_limit_bs - || p.Z > map_gen_limit_bs); + const float max_limit_bs = (MAX_MAP_GENERATION_LIMIT + 0.5f) * 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; } -/* - We are checking for any node of the mapblock being beyond the limit. - - At the negative limit we are checking for - block minimum nodepos < -mapgenlimit. - At the positive limit we are checking for - block maximum nodepos > mapgenlimit. - - Block minimum nodepos = blockpos * mapblocksize. - Block maximum nodepos = (blockpos + 1) * mapblocksize - 1. -*/ -inline bool blockpos_over_limit(v3s16 p) +inline bool blockpos_over_max_limit(v3s16 p) { - const static u16 map_gen_limit = MYMIN(MAX_MAP_GENERATION_LIMIT, - g_settings->getU16("map_generation_limit")); - return (p.X * MAP_BLOCKSIZE < -map_gen_limit - || (p.X + 1) * MAP_BLOCKSIZE - 1 > map_gen_limit - || p.Y * MAP_BLOCKSIZE < -map_gen_limit - || (p.Y + 1) * MAP_BLOCKSIZE - 1 > map_gen_limit - || p.Z * MAP_BLOCKSIZE < -map_gen_limit - || (p.Z + 1) * MAP_BLOCKSIZE - 1 > map_gen_limit); + 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; } /* @@ -694,22 +582,7 @@ inline v3s16 getNodeBlockPos(v3s16 p) return getContainerPos(p, MAP_BLOCKSIZE); } -inline v2s16 getNodeSectorPos(v2s16 p) -{ - return getContainerPos(p, MAP_BLOCKSIZE); -} - -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) +inline void getNodeBlockPosWithOffset(v3s16 p, v3s16 &block, v3s16 &offset) { getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset); } @@ -718,5 +591,3 @@ inline void getNodeSectorPosWithOffset(const v2s16 &p, v2s16 &block, v2s16 &offs Get a quick string to describe what a block actually contains */ std::string analyze_block(MapBlock *block); - -#endif