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