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