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