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 "util/pointer.h"
  25 #include <string>
  26 #include <vector>
  27
  28 class NodeDefManager;
  29 class Map;
  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 0x7fffU
  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 leveled nodebox param2
 107 #define LEVELED_MASK 0x7F
 108 #define LEVELED_MAX LEVELED_MASK
 109
 110
 111 struct ContentFeatures;
 112
 113 /*
 114         This is the stuff what the whole world consists of.
 115 */
 116
 117
 118 struct MapNode
 119 {
 120         /*
 121                 Main content
 122         */
 123         u16 param0;
 124
 125         /*
 126                 Misc parameter. Initialized to 0.
 127                 - For light_propagates() blocks, this is light intensity,
 128                   stored logarithmically from 0 to LIGHT_MAX.
 129                   Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
 130                   - Contains 2 values, day- and night lighting. Each takes 4 bits.
 131                 - Uhh... well, most blocks have light or nothing in here.
 132         */
 133         u8 param1;
 134
 135         /*
 136                 The second parameter. Initialized to 0.
 137                 E.g. direction for torches and flowing water.
 138         */
 139         u8 param2;
 140
 141         MapNode() = default;
 142
 143         MapNode(content_t content, u8 a_param1=0, u8 a_param2=0) noexcept
 144                 : param0(content),
 145                   param1(a_param1),
 146                   param2(a_param2)
 147         { }
 148
 149         bool operator==(const MapNode &other) const noexcept
 150         {
 151                 return (param0 == other.param0
 152                                 && param1 == other.param1
 153                                 && param2 == other.param2);
 154         }
 155
 156         // To be used everywhere
 157         content_t getContent() const noexcept
 158         {
 159                 return param0;
 160         }
 161         void setContent(content_t c) noexcept
 162         {
 163                 param0 = c;
 164         }
 165         u8 getParam1() const noexcept
 166         {
 167                 return param1;
 168         }
 169         void setParam1(u8 p) noexcept
 170         {
 171                 param1 = p;
 172         }
 173         u8 getParam2() const noexcept
 174         {
 175                 return param2;
 176         }
 177         void setParam2(u8 p) noexcept
 178         {
 179                 param2 = p;
 180         }
 181
 182         /*!
 183          * Returns the color of the node.
 184          *
 185          * \param f content features of this node
 186          * \param color output, contains the node's color.
 187          */
 188         void getColor(const ContentFeatures &f, video::SColor *color) const;
 189
 190         void setLight(LightBank bank, u8 a_light, const ContentFeatures &f) noexcept;
 191
 192         void setLight(LightBank bank, u8 a_light, const NodeDefManager *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(const NodeDefManager *nodemgr) const;
 200
 201         u8 getLight(LightBank bank, const NodeDefManager *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(LightBank bank, const ContentFeatures &f) const noexcept;
 209
 210         /**
 211          * This function differs from getLight(LightBank bank, NodeDefManager *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 NodeDefManager::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          * NodeDefManager::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 noexcept;
 226
 227         bool getLightBanks(u8 &lightday, u8 &lightnight,
 228                 const NodeDefManager *nodemgr) const;
 229
 230         // 0 <= daylight_factor <= 1000
 231         // 0 <= return value <= LIGHT_SUN
 232         u8 getLightBlend(u32 daylight_factor, const NodeDefManager *nodemgr) const
 233         {
 234                 u8 lightday = 0;
 235                 u8 lightnight = 0;
 236                 getLightBanks(lightday, lightnight, nodemgr);
 237                 return blend_light(daylight_factor, lightday, lightnight);
 238         }
 239
 240         u8 getFaceDir(const NodeDefManager *nodemgr, bool allow_wallmounted = false) const;
 241         u8 getWallMounted(const NodeDefManager *nodemgr) const;
 242         v3s16 getWallMountedDir(const NodeDefManager *nodemgr) const;
 243
 244         /// @returns Rotation in range 0–239 (in 1.5° steps)
 245         u8 getDegRotate(const NodeDefManager *nodemgr) const;
 246
 247         void rotateAlongYAxis(const NodeDefManager *nodemgr, Rotation rot);
 248
 249         /*!
 250          * Checks which neighbors does this node connect to.
 251          *
 252          * \param p coordinates of the node
 253          */
 254         u8 getNeighbors(v3s16 p, Map *map) const;
 255
 256         /*
 257                 Gets list of node boxes (used for rendering (NDT_NODEBOX))
 258         */
 259         void getNodeBoxes(const NodeDefManager *nodemgr, std::vector<aabb3f> *boxes,
 260                 u8 neighbors = 0) const;
 261
 262         /*
 263                 Gets list of selection boxes
 264         */
 265         void getSelectionBoxes(const NodeDefManager *nodemg,
 266                 std::vector<aabb3f> *boxes, u8 neighbors = 0) const;
 267
 268         /*
 269                 Gets list of collision boxes
 270         */
 271         void getCollisionBoxes(const NodeDefManager *nodemgr,
 272                 std::vector<aabb3f> *boxes, u8 neighbors = 0) const;
 273
 274         /*
 275                 Liquid/leveled helpers
 276         */
 277         u8 getMaxLevel(const NodeDefManager *nodemgr) const;
 278         u8 getLevel(const NodeDefManager *nodemgr) const;
 279         s8 setLevel(const NodeDefManager *nodemgr, s16 level = 1);
 280         s8 addLevel(const NodeDefManager *nodemgr, s16 add = 1);
 281
 282         /*
 283                 Serialization functions
 284         */
 285
 286         static u32 serializedLength(u8 version);
 287         void serialize(u8 *dest, u8 version) const;
 288         void deSerialize(u8 *source, u8 version);
 289
 290         // Serializes or deserializes a list of nodes in bulk format (first the
 291         // content of all nodes, then the param1 of all nodes, then the param2
 292         // of all nodes).
 293         //   version = serialization version. Must be >= 22
 294         //   content_width = the number of bytes of content per node
 295         //   params_width = the number of bytes of params per node
 296         //   compressed = true to zlib-compress output
 297         static SharedBuffer<u8> serializeBulk(int version,
 298                         const MapNode *nodes, u32 nodecount,
 299                         u8 content_width, u8 params_width);
 300         static void deSerializeBulk(std::istream &is, int version,
 301                         MapNode *nodes, u32 nodecount,
 302                         u8 content_width, u8 params_width);
 303
 304 private:
 305         // Deprecated serialization methods
 306         void deSerialize_pre22(const u8 *source, u8 version);
 307 };