src/mapnode.h

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 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 Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser 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 MAPNODE_HEADER
  21 #define MAPNODE_HEADER
  22
  23 #include "irrlichttypes.h"
  24 #include "irr_v3d.h"
  25 #include "irr_aabb3d.h"
  26 #include "light.h"
  27 #include <string>
  28 #include <vector>
  29
  30 class INodeDefManager;
  31
  32 /*
  33         Naming scheme:
  34         - Material = irrlicht's Material class
  35         - Content = (content_t) content of a node
  36         - Tile = TileSpec at some side of a node of some content type
  37 */
  38 typedef u16 content_t;
  39
  40 /*
  41         The maximum node ID that can be registered by mods. This must
  42         be significantly lower than the maximum content_t value, so that
  43         there is enough room for dummy node IDs, which are created when
  44         a MapBlock containing unknown node names is loaded from disk.
  45 */
  46 #define MAX_REGISTERED_CONTENT 0x7fffU
  47
  48 /*
  49         A solid walkable node with the texture unknown_node.png.
  50
  51         For example, used on the client to display unregistered node IDs
  52         (instead of expanding the vector of node definitions each time
  53         such a node is received).
  54 */
  55 #define CONTENT_UNKNOWN 125
  56
  57 /*
  58         The common material through which the player can walk and which
  59         is transparent to light
  60 */
  61 #define CONTENT_AIR 126
  62
  63 /*
  64         Ignored node.
  65
  66         Unloaded chunks are considered to consist of this. Several other
  67         methods return this when an error occurs. Also, during
  68         map generation this means the node has not been set yet.
  69
  70         Doesn't create faces with anything and is considered being
  71         out-of-map in the game map.
  72 */
  73 #define CONTENT_IGNORE 127
  74
  75 enum LightBank
  76 {
  77         LIGHTBANK_DAY,
  78         LIGHTBANK_NIGHT
  79 };
  80
  81 /*
  82         Simple rotation enum.
  83 */
  84 enum Rotation {
  85         ROTATE_0,
  86         ROTATE_90,
  87         ROTATE_180,
  88         ROTATE_270,
  89         ROTATE_RAND,
  90 };
  91
  92 /*
  93         Masks for MapNode.param2 of flowing liquids
  94  */
  95 #define LIQUID_LEVEL_MASK 0x07
  96 #define LIQUID_FLOW_DOWN_MASK 0x08
  97
  98 //#define LIQUID_LEVEL_MASK 0x3f // better finite water
  99 //#define LIQUID_FLOW_DOWN_MASK 0x40 // not used when finite water
 100
 101 /* maximum amount of liquid in a block */
 102 #define LIQUID_LEVEL_MAX LIQUID_LEVEL_MASK
 103 #define LIQUID_LEVEL_SOURCE (LIQUID_LEVEL_MAX+1)
 104
 105 #define LIQUID_INFINITY_MASK 0x80 //0b10000000
 106
 107 // mask for param2, now as for liquid
 108 #define LEVELED_MASK 0x3F
 109 #define LEVELED_MAX LEVELED_MASK
 110
 111
 112 struct ContentFeatures;
 113
 114 /*
 115         This is the stuff what the whole world consists of.
 116 */
 117
 118
 119 struct MapNode
 120 {
 121         /*
 122                 Main content
 123         */
 124         u16 param0;
 125
 126         /*
 127                 Misc parameter. Initialized to 0.
 128                 - For light_propagates() blocks, this is light intensity,
 129                   stored logarithmically from 0 to LIGHT_MAX.
 130                   Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
 131                   - Contains 2 values, day- and night lighting. Each takes 4 bits.
 132                 - Uhh... well, most blocks have light or nothing in here.
 133         */
 134         u8 param1;
 135
 136         /*
 137                 The second parameter. Initialized to 0.
 138                 E.g. direction for torches and flowing water.
 139         */
 140         u8 param2;
 141
 142         MapNode()
 143         { }
 144
 145         MapNode(const MapNode & n)
 146         {
 147                 *this = n;
 148         }
 149
 150         MapNode(content_t content, u8 a_param1=0, u8 a_param2=0)
 151                 : param0(content),
 152                   param1(a_param1),
 153                   param2(a_param2)
 154         { }
 155
 156         // Create directly from a nodename
 157         // If name is unknown, sets CONTENT_IGNORE
 158         MapNode(INodeDefManager *ndef, const std::string &name,
 159                         u8 a_param1=0, u8 a_param2=0);
 160
 161         bool operator==(const MapNode &other)
 162         {
 163                 return (param0 == other.param0
 164                                 && param1 == other.param1
 165                                 && param2 == other.param2);
 166         }
 167
 168         // To be used everywhere
 169         content_t getContent() const
 170         {
 171                 return param0;
 172         }
 173         void setContent(content_t c)
 174         {
 175                 param0 = c;
 176         }
 177         u8 getParam1() const
 178         {
 179                 return param1;
 180         }
 181         void setParam1(u8 p)
 182         {
 183                 param1 = p;
 184         }
 185         u8 getParam2() const
 186         {
 187                 return param2;
 188         }
 189         void setParam2(u8 p)
 190         {
 191                 param2 = p;
 192         }
 193
 194         void setLight(enum LightBank bank, u8 a_light, const ContentFeatures &f);
 195
 196         void setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr);
 197
 198         /**
 199          * Check if the light value for night differs from the light value for day.
 200          *
 201          * @return If the light values are equal, returns true; otherwise false
 202          */
 203         bool isLightDayNightEq(INodeDefManager *nodemgr) const;
 204
 205         u8 getLight(enum LightBank bank, INodeDefManager *nodemgr) const;
 206
 207         /*!
 208          * Returns the node's light level from param1.
 209          * If the node emits light, it is ignored.
 210          * \param f the ContentFeatures of this node.
 211          */
 212         u8 getLightRaw(enum LightBank bank, const ContentFeatures &f) const;
 213
 214         /**
 215          * This function differs from getLight(enum LightBank bank, INodeDefManager *nodemgr)
 216          * in that the ContentFeatures of the node in question are not retrieved by
 217          * the function itself.  Thus, if you have already called nodemgr->get() to
 218          * get the ContentFeatures you pass it to this function instead of the
 219          * function getting ContentFeatures itself.  Since INodeDefManager::get()
 220          * is relatively expensive this can lead to significant performance
 221          * improvements in some situations.  Call this function if (and only if)
 222          * you have already retrieved the ContentFeatures by calling
 223          * INodeDefManager::get() for the node you're working with and the
 224          * pre-conditions listed are true.
 225          *
 226          * @pre f != NULL
 227          * @pre f->param_type == CPT_LIGHT
 228          */
 229         u8 getLightNoChecks(LightBank bank, const ContentFeatures *f) const;
 230
 231         bool getLightBanks(u8 &lightday, u8 &lightnight, INodeDefManager *nodemgr) const;
 232
 233         // 0 <= daylight_factor <= 1000
 234         // 0 <= return value <= LIGHT_SUN
 235         u8 getLightBlend(u32 daylight_factor, INodeDefManager *nodemgr) const
 236         {
 237                 u8 lightday = 0;
 238                 u8 lightnight = 0;
 239                 getLightBanks(lightday, lightnight, nodemgr);
 240                 return blend_light(daylight_factor, lightday, lightnight);
 241         }
 242
 243         u8 getFaceDir(INodeDefManager *nodemgr) const;
 244         u8 getWallMounted(INodeDefManager *nodemgr) const;
 245         v3s16 getWallMountedDir(INodeDefManager *nodemgr) const;
 246
 247         void rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot);
 248
 249         /*
 250                 Gets list of node boxes (used for rendering (NDT_NODEBOX))
 251         */
 252         void getNodeBoxes(INodeDefManager *nodemgr, std::vector<aabb3f> *boxes, u8 neighbors = 0);
 253
 254         /*
 255                 Gets list of selection boxes
 256         */
 257         void getSelectionBoxes(INodeDefManager *nodemg, std::vector<aabb3f> *boxes, u8 neighbors = 0);
 258
 259         /*
 260                 Gets list of collision boxes
 261         */
 262         void getCollisionBoxes(INodeDefManager *nodemgr, std::vector<aabb3f> *boxes, u8 neighbors = 0);
 263
 264         /*
 265                 Liquid helpers
 266         */
 267         u8 getMaxLevel(INodeDefManager *nodemgr) const;
 268         u8 getLevel(INodeDefManager *nodemgr) const;
 269         u8 setLevel(INodeDefManager *nodemgr, s8 level = 1);
 270         u8 addLevel(INodeDefManager *nodemgr, s8 add = 1);
 271
 272         /*
 273                 Serialization functions
 274         */
 275
 276         static u32 serializedLength(u8 version);
 277         void serialize(u8 *dest, u8 version);
 278         void deSerialize(u8 *source, u8 version);
 279
 280         // Serializes or deserializes a list of nodes in bulk format (first the
 281         // content of all nodes, then the param1 of all nodes, then the param2
 282         // of all nodes).
 283         //   version = serialization version. Must be >= 22
 284         //   content_width = the number of bytes of content per node
 285         //   params_width = the number of bytes of params per node
 286         //   compressed = true to zlib-compress output
 287         static void serializeBulk(std::ostream &os, int version,
 288                         const MapNode *nodes, u32 nodecount,
 289                         u8 content_width, u8 params_width, bool compressed);
 290         static void deSerializeBulk(std::istream &is, int version,
 291                         MapNode *nodes, u32 nodecount,
 292                         u8 content_width, u8 params_width, bool compressed);
 293
 294 private:
 295         // Deprecated serialization methods
 296         void deSerialize_pre22(u8 *source, u8 version);
 297 };
 298
 299 #endif
 300