X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.h;h=3879c5b0e5db10cb8e68cf635730fb8085972b8a;hb=9a016a6294f289e1687b9a4655ea3f02f2208201;hp=2c04343de31fd6ab98233a9dbca7bcffd613e9a8;hpb=fc26dcdb19dd4e296d850714019ed7da1de0b021;p=dragonfireclient.git diff --git a/src/mapblock.h b/src/mapblock.h index 2c04343de..3879c5b0e 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,20 +20,27 @@ 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 "staticobject.h" +#include "nodemetadata.h" +#include "nodetimer.h" +#include "modifiedstate.h" +#include "util/numeric.h" // getContainerPos -#define MAP_BLOCKSIZE 16 +class Map; +class NodeMetadataList; +class IGameDef; +class MapBlockMesh; +class VoxelManipulator; -// Named by looking towards z+ +#define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff + +/*// Named by looking towards z+ enum{ FACE_BACK=0, FACE_TOP, @@ -41,14 +48,26 @@ enum{ FACE_FRONT, FACE_BOTTOM, FACE_LEFT -}; +};*/ -struct FastFace +// NOTE: If this is enabled, set MapBlock to be initialized with +// CONTENT_IGNORE. +/*enum BlockGenerationStatus { - u8 material; - video::S3DVertex vertices[4]; // Precalculated vertices -}; - + // 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, @@ -65,118 +84,151 @@ class NodeContainer 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 -class MapBlock : public NodeContainer -{ -private: +/* + MapBlock itself +*/ - NodeContainer *m_parent; - // Position in blocks on parent - v3s16 m_pos; - /* - If NULL, block is a dummy block. - Dummy blocks are used for caching not-found-on-disk blocks. - */ - MapNode * data; - /* - - On the client, this is used for checking whether to - recalculate the face cache. (Is it anymore?) - - On the server, this is used for telling whether the - block has been changed from the one on disk. - */ - bool changed; - /* - Used for some initial lighting stuff. - At least /has been/ used. 8) - */ - bool is_underground; - - MapBlockObjectList m_objects; - +class MapBlock /*: public NodeContainer*/ +{ public: - - /* - This used by Server's block creation stuff for not sending - blocks that are waiting a lighting update. - - If true, the block needs some work by the one who set this - to true. - - While true, nobody else should touch the block. - */ - //bool is_incomplete; + MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false); + ~MapBlock(); - scene::SMesh *mesh; - JMutex mesh_mutex; - - MapBlock(NodeContainer *parent, v3s16 pos, bool dummy=false): - m_parent(parent), - m_pos(pos), - changed(true), - is_underground(false), - m_objects(this) - //is_incomplete(false) - { - data = NULL; - if(dummy == false) - reallocate(); - mesh_mutex.Init(); - mesh = NULL; - } - - ~MapBlock() - { - { - JMutexAutoLock lock(mesh_mutex); - - if(mesh != NULL) - { - mesh->drop(); - mesh = NULL; - } - } - - if(data) - delete[] data; - } - - virtual u16 nodeContainerId() const + /*virtual u16 nodeContainerId() const { return NODECONTAINER_ID_MAPBLOCK; + }*/ + + Map * getParent() + { + return m_parent; } - NodeContainer * getParent() + void reallocate() { - return m_parent; + 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; + m_modified_reason_too_long = false; + + 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; + } + } + } + } + u32 getModified() + { + return m_modified; + } + std::string getModifiedReason() + { + return m_modified_reason; + } + void resetModified() + { + m_modified = MOD_STATE_CLEAN; + m_modified_reason = "none"; + m_modified_reason_too_long = false; + } + + // is_underground getter/setter + bool getIsUnderground() + { + return is_underground; + } + void setIsUnderground(bool a_is_underground) + { + is_underground = a_is_underground; + raiseModified(MOD_STATE_WRITE_NEEDED, "setIsUnderground"); + } + + void setLightingExpired(bool expired) + { + if(expired != m_lighting_expired){ + m_lighting_expired = expired; + raiseModified(MOD_STATE_WRITE_NEEDED, "setLightingExpired"); + } + } + bool getLightingExpired() { - return changed; + return m_lighting_expired; } - void resetChangedFlag() + bool isGenerated() { - changed = false; + return m_generated; + } + void setGenerated(bool b) + { + if(b != m_generated){ + raiseModified(MOD_STATE_WRITE_NEEDED, "setGenerated"); + m_generated = b; + } } - void setChangedFlag() + bool isValid() { - changed = true; + if(m_lighting_expired) + return false; + if(data == NULL) + return false; + return true; } + /* + Position stuff + */ + v3s16 getPos() { return m_pos; @@ -187,17 +239,6 @@ class MapBlock : public NodeContainer return m_pos * MAP_BLOCKSIZE; } - bool getIsUnderground() - { - return is_underground; - } - - void setIsUnderground(bool a_is_underground) - { - is_underground = a_is_underground; - setChangedFlag(); - } - core::aabbox3d getBox() { return core::aabbox3d(getPosRelative(), @@ -205,19 +246,11 @@ class MapBlock : public NodeContainer + v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE) - v3s16(1,1,1)); } - - void reallocate() - { - if(data != NULL) - delete[] data; - u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE; - data = new MapNode[l]; - for(u32 i=0; i= 0 && p.Z < MAP_BLOCKSIZE); } - /* - Regular MapNode get-setters - */ - MapNode getNode(s16 x, s16 y, s16 z) { if(data == NULL) @@ -246,6 +275,15 @@ class MapBlock : public NodeContainer return getNode(p.X, p.Y, p.Z); } + MapNode getNodeNoEx(v3s16 p) + { + try{ + return getNode(p.X, p.Y, p.Z); + }catch(InvalidPositionException &e){ + return MapNode(CONTENT_IGNORE); + } + } + void setNode(s16 x, s16 y, s16 z, MapNode & n) { if(data == NULL) @@ -254,7 +292,7 @@ class MapBlock : public NodeContainer 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(); + raiseModified(MOD_STATE_WRITE_NEEDED, "setNode"); } void setNode(v3s16 p, MapNode & n) @@ -283,7 +321,7 @@ class MapBlock : public NodeContainer if(data == NULL) throw InvalidPositionException(); data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n; - setChangedFlag(); + raiseModified(MOD_STATE_WRITE_NEEDED, "setNodeNoCheck"); } void setNodeNoCheck(v3s16 p, MapNode & n) @@ -298,6 +336,7 @@ class MapBlock : public NodeContainer bool isValidPositionParent(v3s16 p); MapNode getNodeParent(v3s16 p); 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) { @@ -307,103 +346,142 @@ class MapBlock : public NodeContainer setNode(x0+x, y0+y, z0+z, node); } - static FastFace * makeFastFace(u8 material, u8 light, v3f p, - v3f dir, v3f scale, v3f posRelative_f); - - u8 getFaceLight(v3s16 p, v3s16 face_dir); + // 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); + // Copies data from VoxelManipulator getPosRelative() + void copyFrom(VoxelManipulator &dst); + /* - Gets node material from any place relative to block. - Returns MATERIAL_AIR if doesn't exist. + Update day-night lighting difference flag. + Sets m_day_night_differs to appropriate value. + These methods don't care about neighboring blocks. */ - u8 getNodeMaterial(v3s16 p); - + void actuallyUpdateDayNightDiff(); /* - startpos: - translate_dir: unit vector with only one of x, y or z - face_dir: unit vector with only one of x, y or z + Call this to schedule what the previous function does to be done + when the value is actually needed. */ - void updateFastFaceRow(v3s16 startpos, - u16 length, - v3s16 translate_dir, - v3s16 face_dir, - core::list &dest); + void expireDayNightDiff(); - void updateMesh(); + bool getDayNightDiff() + { + if(m_day_night_differs_expired) + actuallyUpdateDayNightDiff(); + return m_day_night_differs; + } - bool propagateSunlight(core::map & light_sources); + /* + Miscellaneous stuff + */ - // Doesn't write version by itself - void serialize(std::ostream &os, u8 version); + /* + 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 deSerialize(std::istream &is, u8 version); - - void serializeObjects(std::ostream &os, u8 version) - { - m_objects.serialize(os, version); - } - // If smgr!=NULL, new objects are added to the scene - void updateObjects(std::istream &is, u8 version, - scene::ISceneManager *smgr) + /* + Timestamp (see m_timestamp) + NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. + */ + void setTimestamp(u32 time) { - m_objects.update(is, version, smgr); - - setChangedFlag(); + m_timestamp = time; + raiseModified(MOD_STATE_WRITE_AT_UNLOAD, "setTimestamp"); } - void clearObjects() + void setTimestampNoChangedFlag(u32 time) { - m_objects.clear(); - - setChangedFlag(); + m_timestamp = time; } - void addObject(MapBlockObject *object) - throw(ContainerFullException, AlreadyExistsException) + u32 getTimestamp() { - m_objects.add(object); - - setChangedFlag(); + return m_timestamp; } - void removeObject(s16 id) + u32 getDiskTimestamp() { - m_objects.remove(id); - - setChangedFlag(); + return m_disk_timestamp; } - MapBlockObject * getObject(s16 id) + + /* + See m_usage_timer + */ + void resetUsageTimer() { - return m_objects.get(id); + m_usage_timer = 0; } - JMutexAutoLock * getObjectLock() + void incrementUsageTimer(float dtime) { - return m_objects.getLock(); + m_usage_timer += dtime; } - void stepObjects(float dtime, bool server) + u32 getUsageTimer() { - m_objects.step(dtime, server); - - setChangedFlag(); + return m_usage_timer; } - /*void wrapObject(MapBlockObject *object) + /* + See m_refcount + */ + void refGrab() { - m_objects.wrapObject(object); - - setChangedFlag(); - }*/ - - // origin is relative to block - void getObjects(v3f origin, f32 max_d, - core::array &dest) + m_refcount++; + } + void refDrop() { - m_objects.getObjects(origin, max_d, dest); + m_refcount--; } - - s32 getObjectCount() + int refGet() { - return m_objects.getCount(); + return m_refcount; + } + + /* + Node Timers + */ + // Get timer + NodeTimer getNodeTimer(v3s16 p){ + return m_node_timers.get(p); + } + // Deletes timer + 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); + } + // Deletes all timers + void clearNodeTimers(){ + m_node_timers.clear(); + } + + /* + Serialization + */ + + // These don't write or read version by itself + // Set disk to true for on-disk format, false for over-the-network format + 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, u16 net_proto_version); + void deSerializeNetworkSpecific(std::istream &is); private: + /* + Private methods + */ + + void deSerialize_pre22(std::istream &is, u8 version, bool disk); /* Used only internally, because changes can't be tracked @@ -411,6 +489,8 @@ class MapBlock : public NodeContainer MapNode & getNodeRef(s16 x, s16 y, s16 z) { + 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(); @@ -420,6 +500,91 @@ class MapBlock : public NodeContainer { return getNodeRef(p.X, p.Y, p.Z); } + +public: + /* + Public member variables + */ + +#ifndef SERVER // Only on client + MapBlockMesh *mesh; +#endif + + NodeMetadataList m_node_metadata; + NodeTimerList m_node_timers; + StaticObjectList m_static_objects; + +private: + /* + Private member variables + */ + + // NOTE: Lots of things rely on this being the Map + Map *m_parent; + // Position in blocks on parent + v3s16 m_pos; + + 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; + std::string m_modified_reason; + bool m_modified_reason_too_long; + + /* + When propagating sunlight and the above block doesn't exist, + sunlight is assumed if this is false. + + In practice this is set to true if the block is completely + 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 m_lighting_expired; + + // 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. + */ + u32 m_timestamp; + // The on-disk (or to-be on-disk) timestamp value + u32 m_disk_timestamp; + + /* + When the block is accessed, this is set to 0. + Map will unload the block when this reaches a timeout. + */ + float m_usage_timer; + + /* + Reference count; currently used for determining if this block is in + the list of blocks to be drawn. + */ + int m_refcount; }; inline bool blockpos_over_limit(v3s16 p) @@ -451,5 +616,10 @@ inline s16 getNodeBlockY(s16 y) return getContainerPos(y, MAP_BLOCKSIZE); } +/* + Get a quick string to describe what a block actually contains +*/ +std::string analyze_block(MapBlock *block); + #endif