src/mapblock.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #ifndef MAPBLOCK_HEADER
  21 #define MAPBLOCK_HEADER
  22
  23 #include <jmutex.h>
  24 #include <jmutexautolock.h>
  25 #include <exception>
  26 #include "debug.h"
  27 #include "common_irrlicht.h"
  28 #include "mapnode.h"
  29 #include "exceptions.h"
  30 #include "serialization.h"
  31 #include "constants.h"
  32 #include "voxel.h"
  33 #include "staticobject.h"
  34 #include "mapblock_nodemod.h"
  35 #ifndef SERVER
  36         #include "mapblock_mesh.h"
  37 #endif
  38
  39 class Map;
  40 class NodeMetadataList;
  41 class IGameDef;
  42
  43 #define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff
  44
  45 /*// Named by looking towards z+
  46 enum{
  47         FACE_BACK=0,
  48         FACE_TOP,
  49         FACE_RIGHT,
  50         FACE_FRONT,
  51         FACE_BOTTOM,
  52         FACE_LEFT
  53 };*/
  54
  55 enum ModifiedState
  56 {
  57         // Has not been modified.
  58         MOD_STATE_CLEAN = 0,
  59         MOD_RESERVED1 = 1,
  60         // Has been modified, and will be saved when being unloaded.
  61         MOD_STATE_WRITE_AT_UNLOAD = 2,
  62         MOD_RESERVED3 = 3,
  63         // Has been modified, and will be saved as soon as possible.
  64         MOD_STATE_WRITE_NEEDED = 4,
  65         MOD_RESERVED5 = 5,
  66 };
  67
  68 // NOTE: If this is enabled, set MapBlock to be initialized with
  69 //       CONTENT_IGNORE.
  70 /*enum BlockGenerationStatus
  71 {
  72         // Completely non-generated (filled with CONTENT_IGNORE).
  73         BLOCKGEN_UNTOUCHED=0,
  74         // Trees or similar might have been blitted from other blocks to here.
  75         // Otherwise, the block contains CONTENT_IGNORE
  76         BLOCKGEN_FROM_NEIGHBORS=2,
  77         // Has been generated, but some neighbors might put some stuff in here
  78         // when they are generated.
  79         // Does not contain any CONTENT_IGNORE
  80         BLOCKGEN_SELF_GENERATED=4,
  81         // The block and all its neighbors have been generated
  82         BLOCKGEN_FULLY_GENERATED=6
  83 };*/
  84
  85 #if 0
  86 enum
  87 {
  88         NODECONTAINER_ID_MAPBLOCK,
  89         NODECONTAINER_ID_MAPSECTOR,
  90         NODECONTAINER_ID_MAP,
  91         NODECONTAINER_ID_MAPBLOCKCACHE,
  92         NODECONTAINER_ID_VOXELMANIPULATOR,
  93 };
  94
  95 class NodeContainer
  96 {
  97 public:
  98         virtual bool isValidPosition(v3s16 p) = 0;
  99         virtual MapNode getNode(v3s16 p) = 0;
 100         virtual void setNode(v3s16 p, MapNode & n) = 0;
 101         virtual u16 nodeContainerId() const = 0;
 102
 103         MapNode getNodeNoEx(v3s16 p)
 104         {
 105                 try{
 106                         return getNode(p);
 107                 }
 108                 catch(InvalidPositionException &e){
 109                         return MapNode(CONTENT_IGNORE);
 110                 }
 111         }
 112 };
 113 #endif
 114
 115 /*
 116         MapBlock itself
 117 */
 118
 119 class MapBlock /*: public NodeContainer*/
 120 {
 121 public:
 122         MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false);
 123         ~MapBlock();
 124
 125         /*virtual u16 nodeContainerId() const
 126         {
 127                 return NODECONTAINER_ID_MAPBLOCK;
 128         }*/
 129
 130         Map * getParent()
 131         {
 132                 return m_parent;
 133         }
 134
 135         void reallocate()
 136         {
 137                 if(data != NULL)
 138                         delete[] data;
 139                 u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
 140                 data = new MapNode[l];
 141                 for(u32 i=0; i<l; i++){
 142                         //data[i] = MapNode();
 143                         data[i] = MapNode(CONTENT_IGNORE);
 144                 }
 145                 raiseModified(MOD_STATE_WRITE_NEEDED);
 146         }
 147
 148         /*
 149                 Flags
 150         */
 151
 152         bool isDummy()
 153         {
 154                 return (data == NULL);
 155         }
 156         void unDummify()
 157         {
 158                 assert(isDummy());
 159                 reallocate();
 160         }
 161
 162         /*
 163                 This is called internally or externally after the block is
 164                 modified, so that the block is saved and possibly not deleted from
 165                 memory.
 166         */
 167         // DEPRECATED, use *Modified()
 168         void setChangedFlag()
 169         {
 170                 //dstream<<"Deprecated setChangedFlag() called"<<std::endl;
 171                 raiseModified(MOD_STATE_WRITE_NEEDED);
 172         }
 173         // DEPRECATED, use *Modified()
 174         void resetChangedFlag()
 175         {
 176                 //dstream<<"Deprecated resetChangedFlag() called"<<std::endl;
 177                 resetModified();
 178         }
 179         // DEPRECATED, use *Modified()
 180         bool getChangedFlag()
 181         {
 182                 //dstream<<"Deprecated getChangedFlag() called"<<std::endl;
 183                 if(getModified() == MOD_STATE_CLEAN)
 184                         return false;
 185                 else
 186                         return true;
 187         }
 188
 189         // m_modified methods
 190         void raiseModified(u32 mod)
 191         {
 192                 m_modified = MYMAX(m_modified, mod);
 193         }
 194         u32 getModified()
 195         {
 196                 return m_modified;
 197         }
 198         void resetModified()
 199         {
 200                 m_modified = MOD_STATE_CLEAN;
 201         }
 202
 203         // is_underground getter/setter
 204         bool getIsUnderground()
 205         {
 206                 return is_underground;
 207         }
 208         void setIsUnderground(bool a_is_underground)
 209         {
 210                 is_underground = a_is_underground;
 211                 raiseModified(MOD_STATE_WRITE_NEEDED);
 212         }
 213
 214 #ifndef SERVER
 215         void setMeshExpired(bool expired)
 216         {
 217                 m_mesh_expired = expired;
 218         }
 219
 220         bool getMeshExpired()
 221         {
 222                 return m_mesh_expired;
 223         }
 224 #endif
 225
 226         void setLightingExpired(bool expired)
 227         {
 228                 if(expired != m_lighting_expired){
 229                         m_lighting_expired = expired;
 230                         raiseModified(MOD_STATE_WRITE_NEEDED);
 231                 }
 232         }
 233         bool getLightingExpired()
 234         {
 235                 return m_lighting_expired;
 236         }
 237
 238         bool isGenerated()
 239         {
 240                 return m_generated;
 241         }
 242         void setGenerated(bool b)
 243         {
 244                 if(b != m_generated){
 245                         raiseModified(MOD_STATE_WRITE_NEEDED);
 246                         m_generated = b;
 247                 }
 248         }
 249
 250         bool isValid()
 251         {
 252                 if(m_lighting_expired)
 253                         return false;
 254                 if(data == NULL)
 255                         return false;
 256                 return true;
 257         }
 258
 259         /*
 260                 Position stuff
 261         */
 262
 263         v3s16 getPos()
 264         {
 265                 return m_pos;
 266         }
 267
 268         v3s16 getPosRelative()
 269         {
 270                 return m_pos * MAP_BLOCKSIZE;
 271         }
 272
 273         core::aabbox3d<s16> getBox()
 274         {
 275                 return core::aabbox3d<s16>(getPosRelative(),
 276                                 getPosRelative()
 277                                 + v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE)
 278                                 - v3s16(1,1,1));
 279         }
 280
 281         /*
 282                 Regular MapNode get-setters
 283         */
 284
 285         bool isValidPosition(v3s16 p)
 286         {
 287                 if(data == NULL)
 288                         return false;
 289                 return (p.X >= 0 && p.X < MAP_BLOCKSIZE
 290                                 && p.Y >= 0 && p.Y < MAP_BLOCKSIZE
 291                                 && p.Z >= 0 && p.Z < MAP_BLOCKSIZE);
 292         }
 293
 294         MapNode getNode(s16 x, s16 y, s16 z)
 295         {
 296                 if(data == NULL)
 297                         throw InvalidPositionException();
 298                 if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 299                 if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 300                 if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 301                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 302         }
 303
 304         MapNode getNode(v3s16 p)
 305         {
 306                 return getNode(p.X, p.Y, p.Z);
 307         }
 308
 309         MapNode getNodeNoEx(v3s16 p)
 310         {
 311                 try{
 312                         return getNode(p.X, p.Y, p.Z);
 313                 }catch(InvalidPositionException &e){
 314                         return MapNode(CONTENT_IGNORE);
 315                 }
 316         }
 317
 318         void setNode(s16 x, s16 y, s16 z, MapNode & n)
 319         {
 320                 if(data == NULL)
 321                         throw InvalidPositionException();
 322                 if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 323                 if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 324                 if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 325                 data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
 326                 raiseModified(MOD_STATE_WRITE_NEEDED);
 327         }
 328
 329         void setNode(v3s16 p, MapNode & n)
 330         {
 331                 setNode(p.X, p.Y, p.Z, n);
 332         }
 333
 334         /*
 335                 Non-checking variants of the above
 336         */
 337
 338         MapNode getNodeNoCheck(s16 x, s16 y, s16 z)
 339         {
 340                 if(data == NULL)
 341                         throw InvalidPositionException();
 342                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 343         }
 344
 345         MapNode getNodeNoCheck(v3s16 p)
 346         {
 347                 return getNodeNoCheck(p.X, p.Y, p.Z);
 348         }
 349
 350         void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
 351         {
 352                 if(data == NULL)
 353                         throw InvalidPositionException();
 354                 data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
 355                 raiseModified(MOD_STATE_WRITE_NEEDED);
 356         }
 357
 358         void setNodeNoCheck(v3s16 p, MapNode & n)
 359         {
 360                 setNodeNoCheck(p.X, p.Y, p.Z, n);
 361         }
 362
 363         /*
 364                 These functions consult the parent container if the position
 365                 is not valid on this MapBlock.
 366         */
 367         bool isValidPositionParent(v3s16 p);
 368         MapNode getNodeParent(v3s16 p);
 369         void setNodeParent(v3s16 p, MapNode & n);
 370         MapNode getNodeParentNoEx(v3s16 p);
 371
 372         void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
 373         {
 374                 for(u16 z=0; z<d; z++)
 375                         for(u16 y=0; y<h; y++)
 376                                 for(u16 x=0; x<w; x++)
 377                                         setNode(x0+x, y0+y, z0+z, node);
 378         }
 379
 380         /*
 381                 Graphics-related methods
 382         */
 383
 384         /*// A quick version with nodes passed as parameters
 385         u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
 386                         v3s16 face_dir);*/
 387         /*// A more convenient version
 388         u8 getFaceLight(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
 389         {
 390                 return getFaceLight(daynight_ratio,
 391                                 getNodeParentNoEx(p),
 392                                 getNodeParentNoEx(p + face_dir),
 393                                 face_dir);
 394         }*/
 395         u8 getFaceLight2(u32 daynight_ratio, v3s16 p, v3s16 face_dir,
 396                         INodeDefManager *nodemgr)
 397         {
 398                 return getFaceLight(daynight_ratio,
 399                                 getNodeParentNoEx(p),
 400                                 getNodeParentNoEx(p + face_dir),
 401                                 face_dir, nodemgr);
 402         }
 403
 404 #ifndef SERVER // Only on client
 405
 406 #if 1
 407         /*
 408                 Thread-safely updates the whole mesh of the mapblock.
 409                 NOTE: Prefer generating the mesh separately and then using
 410                 replaceMesh().
 411         */
 412         void updateMesh(u32 daynight_ratio);
 413 #endif
 414         // Replace the mesh with a new one
 415         void replaceMesh(scene::SMesh *mesh_new);
 416 #endif
 417
 418         // See comments in mapblock.cpp
 419         bool propagateSunlight(core::map<v3s16, bool> & light_sources,
 420                         bool remove_light=false, bool *black_air_left=NULL);
 421
 422         // Copies data to VoxelManipulator to getPosRelative()
 423         void copyTo(VoxelManipulator &dst);
 424         // Copies data from VoxelManipulator getPosRelative()
 425         void copyFrom(VoxelManipulator &dst);
 426
 427 #ifndef SERVER // Only on client
 428         /*
 429                 Methods for setting temporary modifications to nodes for
 430                 drawing
 431
 432                 returns true if the mod was different last time
 433         */
 434         bool setTempMod(v3s16 p, const NodeMod &mod)
 435         {
 436                 /*dstream<<"setTempMod called on block"
 437                                 <<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 438                                 <<", mod.type="<<mod.type
 439                                 <<", mod.param="<<mod.param
 440                                 <<std::endl;*/
 441                 JMutexAutoLock lock(m_temp_mods_mutex);
 442
 443                 return m_temp_mods.set(p, mod);
 444         }
 445         // Returns true if there was one
 446         bool getTempMod(v3s16 p, NodeMod *mod)
 447         {
 448                 JMutexAutoLock lock(m_temp_mods_mutex);
 449
 450                 return m_temp_mods.get(p, mod);
 451         }
 452         bool clearTempMod(v3s16 p)
 453         {
 454                 JMutexAutoLock lock(m_temp_mods_mutex);
 455
 456                 return m_temp_mods.clear(p);
 457         }
 458         bool clearTempMods()
 459         {
 460                 JMutexAutoLock lock(m_temp_mods_mutex);
 461
 462                 return m_temp_mods.clear();
 463         }
 464         void copyTempMods(NodeModMap &dst)
 465         {
 466                 JMutexAutoLock lock(m_temp_mods_mutex);
 467                 m_temp_mods.copy(dst);
 468         }
 469 #endif
 470
 471         /*
 472                 Update day-night lighting difference flag.
 473
 474                 Sets m_day_night_differs to appropriate value.
 475
 476                 These methods don't care about neighboring blocks.
 477                 It means that to know if a block really doesn't need a mesh
 478                 update between day and night, the neighboring blocks have
 479                 to be taken into account. Use Map::dayNightDiffed().
 480         */
 481         void updateDayNightDiff();
 482
 483         bool dayNightDiffed()
 484         {
 485                 return m_day_night_differs;
 486         }
 487
 488         /*
 489                 Miscellaneous stuff
 490         */
 491
 492         /*
 493                 Tries to measure ground level.
 494                 Return value:
 495                         -1 = only air
 496                         -2 = only ground
 497                         -3 = random fail
 498                         0...MAP_BLOCKSIZE-1 = ground level
 499         */
 500         s16 getGroundLevel(v2s16 p2d);
 501
 502         /*
 503                 Timestamp (see m_timestamp)
 504                 NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
 505         */
 506         void setTimestamp(u32 time)
 507         {
 508                 m_timestamp = time;
 509                 raiseModified(MOD_STATE_WRITE_AT_UNLOAD);
 510         }
 511         void setTimestampNoChangedFlag(u32 time)
 512         {
 513                 m_timestamp = time;
 514         }
 515         u32 getTimestamp()
 516         {
 517                 return m_timestamp;
 518         }
 519
 520         /*
 521                 See m_usage_timer
 522         */
 523         void resetUsageTimer()
 524         {
 525                 m_usage_timer = 0;
 526         }
 527         void incrementUsageTimer(float dtime)
 528         {
 529                 m_usage_timer += dtime;
 530         }
 531         u32 getUsageTimer()
 532         {
 533                 return m_usage_timer;
 534         }
 535
 536         /*
 537                 Serialization
 538         */
 539
 540         // These don't write or read version by itself
 541         void serialize(std::ostream &os, u8 version);
 542         void deSerialize(std::istream &is, u8 version);
 543         // Used after the basic ones when writing on disk (serverside)
 544         void serializeDiskExtra(std::ostream &os, u8 version);
 545         void deSerializeDiskExtra(std::istream &is, u8 version);
 546
 547 private:
 548         /*
 549                 Private methods
 550         */
 551
 552         /*
 553                 Used only internally, because changes can't be tracked
 554         */
 555
 556         MapNode & getNodeRef(s16 x, s16 y, s16 z)
 557         {
 558                 if(data == NULL)
 559                         throw InvalidPositionException();
 560                 if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 561                 if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 562                 if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 563                 return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
 564         }
 565         MapNode & getNodeRef(v3s16 &p)
 566         {
 567                 return getNodeRef(p.X, p.Y, p.Z);
 568         }
 569
 570 public:
 571         /*
 572                 Public member variables
 573         */
 574
 575 #ifndef SERVER // Only on client
 576         scene::SMesh *mesh;
 577         JMutex mesh_mutex;
 578 #endif
 579
 580         NodeMetadataList *m_node_metadata;
 581         StaticObjectList m_static_objects;
 582
 583 private:
 584         /*
 585                 Private member variables
 586         */
 587
 588         // NOTE: Lots of things rely on this being the Map
 589         Map *m_parent;
 590         // Position in blocks on parent
 591         v3s16 m_pos;
 592
 593         IGameDef *m_gamedef;
 594
 595         /*
 596                 If NULL, block is a dummy block.
 597                 Dummy blocks are used for caching not-found-on-disk blocks.
 598         */
 599         MapNode * data;
 600
 601         /*
 602                 - On the server, this is used for telling whether the
 603                   block has been modified from the one on disk.
 604                 - On the client, this is used for nothing.
 605         */
 606         u32 m_modified;
 607
 608         /*
 609                 When propagating sunlight and the above block doesn't exist,
 610                 sunlight is assumed if this is false.
 611
 612                 In practice this is set to true if the block is completely
 613                 undeground with nothing visible above the ground except
 614                 caves.
 615         */
 616         bool is_underground;
 617
 618         /*
 619                 Set to true if changes has been made that make the old lighting
 620                 values wrong but the lighting hasn't been actually updated.
 621
 622                 If this is false, lighting is exactly right.
 623                 If this is true, lighting might be wrong or right.
 624         */
 625         bool m_lighting_expired;
 626
 627         // Whether day and night lighting differs
 628         bool m_day_night_differs;
 629
 630         bool m_generated;
 631
 632 #ifndef SERVER // Only on client
 633         /*
 634                 Set to true if the mesh has been ordered to be updated
 635                 sometime in the background.
 636                 In practice this is set when the day/night lighting switches.
 637         */
 638         bool m_mesh_expired;
 639
 640         // Temporary modifications to nodes
 641         // These are only used when drawing
 642         NodeModMap m_temp_mods;
 643         JMutex m_temp_mods_mutex;
 644 #endif
 645
 646         /*
 647                 When block is removed from active blocks, this is set to gametime.
 648                 Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
 649         */
 650         u32 m_timestamp;
 651
 652         /*
 653                 When the block is accessed, this is set to 0.
 654                 Map will unload the block when this reaches a timeout.
 655         */
 656         float m_usage_timer;
 657 };
 658
 659 inline bool blockpos_over_limit(v3s16 p)
 660 {
 661         return
 662           (p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 663         || p.X >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 664         || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 665         || p.Y >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 666         || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 667         || p.Z >  MAP_GENERATION_LIMIT / MAP_BLOCKSIZE);
 668 }
 669
 670 /*
 671         Returns the position of the block where the node is located
 672 */
 673 inline v3s16 getNodeBlockPos(v3s16 p)
 674 {
 675         return getContainerPos(p, MAP_BLOCKSIZE);
 676 }
 677
 678 inline v2s16 getNodeSectorPos(v2s16 p)
 679 {
 680         return getContainerPos(p, MAP_BLOCKSIZE);
 681 }
 682
 683 inline s16 getNodeBlockY(s16 y)
 684 {
 685         return getContainerPos(y, MAP_BLOCKSIZE);
 686 }
 687
 688 /*
 689         Get a quick string to describe what a block actually contains
 690 */
 691 std::string analyze_block(MapBlock *block);
 692
 693 #endif
 694