X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmapblock.h;h=bec3b6f5657f2bc8cc6a5b4b0f4cd28ceadb1dba;hb=3955f512538ca7c6f2d2187f22d5a696da8e84d3;hp=1eb97353cc74129e600904fbabced36a53640c5b;hpb=7cfb71385d00d1cbbbfd9c76f6c01adafa9e648a;p=oweals%2Fminetest.git diff --git a/src/mapblock.h b/src/mapblock.h index 1eb97353c..bec3b6f56 100644 --- a/src/mapblock.h +++ b/src/mapblock.h @@ -1,18 +1,18 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 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,23 +20,28 @@ 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 "common_irrlicht.h" +#include "irr_v3d.h" #include "mapnode.h" #include "exceptions.h" -#include "serialization.h" #include "constants.h" -#include "mapblockobject.h" -#include "voxel.h" -#include "nodemetadata.h" #include "staticobject.h" +#include "nodemetadata.h" +#include "nodetimer.h" +#include "modifiedstate.h" +#include "util/numeric.h" // getContainerPos +#include "settings.h" + +class Map; +class NodeMetadataList; +class IGameDef; +class MapBlockMesh; +class VoxelManipulator; #define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff -// Named by looking towards z+ +/*// Named by looking towards z+ enum{ FACE_BACK=0, FACE_TOP, @@ -44,104 +49,26 @@ enum{ FACE_FRONT, FACE_BOTTOM, FACE_LEFT -}; - -struct FastFace -{ - TileSpec tile; - video::S3DVertex vertices[4]; // Precalculated vertices -}; - -enum NodeModType -{ - NODEMOD_NONE, - NODEMOD_CHANGECONTENT, //param is content id - NODEMOD_CRACK // param is crack progression -}; - -struct NodeMod -{ - NodeMod(enum NodeModType a_type=NODEMOD_NONE, u16 a_param=0) - { - type = a_type; - param = a_param; - } - bool operator==(const NodeMod &other) - { - return (type == other.type && param == other.param); - } - enum NodeModType type; - u16 param; -}; +};*/ -class NodeModMap +// NOTE: If this is enabled, set MapBlock to be initialized with +// CONTENT_IGNORE. +/*enum BlockGenerationStatus { -public: - /* - returns true if the mod was different last time - */ - bool set(v3s16 p, const NodeMod &mod) - { - // See if old is different, cancel if it is not different. - core::map::Node *n = m_mods.find(p); - if(n) - { - NodeMod old = n->getValue(); - if(old == mod) - return false; - - n->setValue(mod); - } - else - { - m_mods.insert(p, mod); - } - - return true; - } - // Returns true if there was one - bool get(v3s16 p, NodeMod *mod) - { - core::map::Node *n; - n = m_mods.find(p); - if(n == NULL) - return false; - if(mod) - *mod = n->getValue(); - return true; - } - bool clear(v3s16 p) - { - if(m_mods.find(p)) - { - m_mods.remove(p); - return true; - } - return false; - } - bool clear() - { - if(m_mods.size() == 0) - return false; - m_mods.clear(); - return true; - } - void copy(NodeModMap &dest) - { - dest.m_mods.clear(); - - for(core::map::Iterator - i = m_mods.getIterator(); - i.atEnd() == false; i++) - { - dest.m_mods.insert(i.getNode()->getKey(), i.getNode()->getValue()); - } - } - -private: - core::map m_mods; -}; - + // 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, @@ -169,166 +96,189 @@ public: } } }; - -/* - Mesh making stuff -*/ - -class MapBlock; - -#ifndef SERVER - -struct MeshMakeData -{ - u32 m_daynight_ratio; - NodeModMap m_temp_mods; - VoxelManipulator m_vmanip; - v3s16 m_blockpos; - - /* - Copy central data directly from block, and other data from - parent of block. - */ - void fill(u32 daynight_ratio, MapBlock *block); -}; - -scene::SMesh* makeMapBlockMesh(MeshMakeData *data); - #endif -u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2, - v3s16 face_dir); - -/* - MapBlock itself -*/ - -class MapBlock : public NodeContainer +//// +//// 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(NodeContainer *parent, v3s16 pos, bool dummy=false); + MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false); ~MapBlock(); - - virtual u16 nodeContainerId() const + + /*virtual u16 nodeContainerId() const { return NODECONTAINER_ID_MAPBLOCK; - } - - NodeContainer * getParent() + }*/ + + Map * getParent() { return m_parent; } 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) { + m_modified = mod; + m_modified_reason = reason; + if (m_modified >= MOD_STATE_WRITE_AT_UNLOAD) + m_disk_timestamp = m_timestamp; + } else if (mod == m_modified) { + m_modified_reason |= reason; + } + } - bool isDummy() + inline u32 getModified() { - return (data == NULL); + return m_modified; } - void unDummify() + + inline u32 getModifiedReason() { - assert(isDummy()); - reallocate(); + return m_modified_reason; } - - /* - This is called internally or externally after the block is - modified, so that the block is saved and possibly not deleted from - memory. - */ - void setChangedFlag() + + std::string getModifiedReasonString(); + + inline void resetModified() { - changed = true; + m_modified = MOD_STATE_CLEAN; + m_modified_reason = 0; } - void resetChangedFlag() + + //// + //// Flags + //// + + inline bool isDummy() { - changed = false; + return (data == NULL); } - bool getChangedFlag() + + inline void unDummify() { - return changed; + assert(isDummy()); // Pre-condition + reallocate(); } - bool getIsUnderground() + // is_underground getter/setter + inline bool getIsUnderground() { return is_underground; } - void setIsUnderground(bool a_is_underground) + + inline void setIsUnderground(bool a_is_underground) { is_underground = a_is_underground; - setChangedFlag(); + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND); } -#ifndef SERVER - void setMeshExpired(bool expired) + inline void setLightingComplete(u16 newflags) { - m_mesh_expired = expired; + if (newflags != m_lighting_complete) { + m_lighting_complete = newflags; + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_COMPLETE); + } } - - bool getMeshExpired() + + inline u16 getLightingComplete() { - return m_mesh_expired; + return m_lighting_complete; } -#endif - void setLightingExpired(bool expired) + inline void setLightingComplete(LightBank bank, u8 direction, + bool is_complete) { - m_lighting_expired = expired; - setChangedFlag(); + 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); } - 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; } - /*bool isFullyGenerated() + inline bool isGenerated() { - return !m_not_fully_generated; + return m_generated; } - void setFullyGenerated(bool b) - { - setChangedFlag(); - m_not_fully_generated = !b; - }*/ - bool isValid() + inline void setGenerated(bool b) { - if(m_lighting_expired) - return false; - if(data == NULL) - return false; - return true; + if (b != m_generated) { + raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_GENERATED); + m_generated = b; + } } - /* - Position stuff - */ + //// + //// 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() @@ -336,333 +286,283 @@ public: - 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) + { + 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(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(); - data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n; - setChangedFlag(); + + 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]; } - - MapNode getNodeNoCheck(v3s16 p) + + inline MapNode getNodeNoCheck(v3s16 p, bool *valid_position) { - return getNodeNoCheck(p.X, p.Y, p.Z); + return getNodeNoCheck(p.X, p.Y, p.Z, valid_position); } - - void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n) + + //// + //// 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) { - if(data == NULL) + return data[z * zstride + y * ystride + x]; + } + + inline const MapNode &getNodeUnsafe(v3s16 &p) + { + 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*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n; - setChangedFlag(); + + 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) - { - for(u16 z=0; z & light_sources, - bool remove_light=false, bool *black_air_left=NULL, - bool grow_grass=false); - + 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); - /* - MapBlockObject stuff - DEPRECATED - */ - - void serializeObjects(std::ostream &os, u8 version) + // 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. + void expireDayNightDiff(); + + inline bool getDayNightDiff() { - m_objects.serialize(os, version); + if (m_day_night_differs_expired) + actuallyUpdateDayNightDiff(); + return m_day_night_differs; } - // If smgr!=NULL, new objects are added to the scene - void updateObjects(std::istream &is, u8 version, - scene::ISceneManager *smgr, u32 daynight_ratio) - { - m_objects.update(is, version, smgr, daynight_ratio); - setChangedFlag(); - } - void clearObjects() - { - m_objects.clear(); + //// + //// Miscellaneous stuff + //// - setChangedFlag(); - } - void addObject(MapBlockObject *object) - throw(ContainerFullException, AlreadyExistsException) - { - m_objects.add(object); + /* + 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); - setChangedFlag(); - } - void removeObject(s16 id) - { - m_objects.remove(id); + //// + //// Timestamp (see m_timestamp) + //// - setChangedFlag(); - } - MapBlockObject * getObject(s16 id) + // NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. + + inline void setTimestamp(u32 time) { - return m_objects.get(id); + m_timestamp = time; + raiseModified(MOD_STATE_WRITE_AT_UNLOAD, MOD_REASON_SET_TIMESTAMP); } - JMutexAutoLock * getObjectLock() + + inline void setTimestampNoChangedFlag(u32 time) { - return m_objects.getLock(); + m_timestamp = time; } - /* - Moves objects, deletes objects and spawns new objects - */ - void stepObjects(float dtime, bool server, u32 daynight_ratio); - - // origin is relative to block - void getObjects(v3f origin, f32 max_d, - core::array &dest) + inline u32 getTimestamp() { - m_objects.getObjects(origin, max_d, dest); + return m_timestamp; } - s32 getObjectCount() + inline u32 getDiskTimestamp() { - return m_objects.getCount(); + return m_disk_timestamp; } -#ifndef SERVER // Only on client - /* - Methods for setting temporary modifications to nodes for - drawing + //// + //// Usage timer (see m_usage_timer) + //// - returns true if the mod was different last time - */ - bool setTempMod(v3s16 p, const NodeMod &mod) + inline void resetUsageTimer() { - /*dstream<<"setTempMod called on block" - <<" ("< object_limit + || p.Y < -object_limit + || p.Y > object_limit + || p.Z < -object_limit + || p.Z > object_limit); +} + +/* + 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) { - 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 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); } /* @@ -778,5 +724,19 @@ inline s16 getNodeBlockY(s16 y) return getContainerPos(y, MAP_BLOCKSIZE); } -#endif +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