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 #define MAX_CONTENT 0xfff
  39
  40 /*
  41         Ignored node.
  42
  43         Anything that stores MapNodes doesn't have to preserve parameters
  44         associated with this material.
  45
  46         Doesn't create faces with anything and is considered being
  47         out-of-map in the game map.
  48 */
  49 #define CONTENT_IGNORE 127
  50 #define CONTENT_IGNORE_DEFAULT_PARAM 0
  51
  52 /*
  53         The common material through which the player can walk and which
  54         is transparent to light
  55 */
  56 #define CONTENT_AIR 126
  57
  58 enum LightBank
  59 {
  60         LIGHTBANK_DAY,
  61         LIGHTBANK_NIGHT
  62 };
  63
  64 /*
  65         Masks for MapNode.param2 of flowing liquids
  66  */
  67 #define LIQUID_LEVEL_MASK 0x07
  68 #define LIQUID_FLOW_DOWN_MASK 0x08
  69
  70 //#define LIQUID_LEVEL_MASK 0x3f // better finite water
  71 //#define LIQUID_FLOW_DOWN_MASK 0x40 // not used when finite water
  72
  73 /* maximum amount of liquid in a block */
  74 #define LIQUID_LEVEL_MAX LIQUID_LEVEL_MASK
  75 #define LIQUID_LEVEL_SOURCE (LIQUID_LEVEL_MAX+1)
  76
  77 #define LIQUID_INFINITY_MASK 0x80 //0b10000000
  78
  79 /*
  80         This is the stuff what the whole world consists of.
  81 */
  82
  83
  84 struct MapNode
  85 {
  86         /*
  87                 Main content
  88         */
  89         u16 param0;
  90
  91         /*
  92                 Misc parameter. Initialized to 0.
  93                 - For light_propagates() blocks, this is light intensity,
  94                   stored logarithmically from 0 to LIGHT_MAX.
  95                   Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
  96                   - Contains 2 values, day- and night lighting. Each takes 4 bits.
  97                 - Uhh... well, most blocks have light or nothing in here.
  98         */
  99         u8 param1;
 100
 101         /*
 102                 The second parameter. Initialized to 0.
 103                 E.g. direction for torches and flowing water.
 104         */
 105         u8 param2;
 106
 107         MapNode(const MapNode & n)
 108         {
 109                 *this = n;
 110         }
 111
 112         MapNode(content_t content=CONTENT_AIR, u8 a_param1=0, u8 a_param2=0)
 113         {
 114                 param0 = content;
 115                 param1 = a_param1;
 116                 param2 = a_param2;
 117         }
 118
 119         // Create directly from a nodename
 120         // If name is unknown, sets CONTENT_IGNORE
 121         MapNode(INodeDefManager *ndef, const std::string &name,
 122                         u8 a_param1=0, u8 a_param2=0);
 123
 124         bool operator==(const MapNode &other)
 125         {
 126                 return (param0 == other.param0
 127                                 && param1 == other.param1
 128                                 && param2 == other.param2);
 129         }
 130
 131         // To be used everywhere
 132         content_t getContent() const
 133         {
 134                 return param0;
 135         }
 136         void setContent(content_t c)
 137         {
 138                 param0 = c;
 139         }
 140         u8 getParam1() const
 141         {
 142                 return param1;
 143         }
 144         void setParam1(u8 p)
 145         {
 146                 param1 = p;
 147         }
 148         u8 getParam2() const
 149         {
 150                 return param2;
 151         }
 152         void setParam2(u8 p)
 153         {
 154                 param2 = p;
 155         }
 156
 157         void setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr);
 158         u8 getLight(enum LightBank bank, INodeDefManager *nodemgr) const;
 159         bool getLightBanks(u8 &lightday, u8 &lightnight, INodeDefManager *nodemgr) const;
 160
 161         // 0 <= daylight_factor <= 1000
 162         // 0 <= return value <= LIGHT_SUN
 163         u8 getLightBlend(u32 daylight_factor, INodeDefManager *nodemgr) const
 164         {
 165                 u8 lightday = 0;
 166                 u8 lightnight = 0;
 167                 getLightBanks(lightday, lightnight, nodemgr);
 168                 return blend_light(daylight_factor, lightday, lightnight);
 169         }
 170
 171         // 0.0 <= daylight_factor <= 1.0
 172         // 0 <= return value <= LIGHT_SUN
 173         u8 getLightBlendF1(float daylight_factor, INodeDefManager *nodemgr) const
 174         {
 175                 u8 lightday = 0;
 176                 u8 lightnight = 0;
 177                 getLightBanks(lightday, lightnight, nodemgr);
 178                 return blend_light_f1(daylight_factor, lightday, lightnight);
 179         }
 180
 181         u8 getFaceDir(INodeDefManager *nodemgr) const;
 182         u8 getWallMounted(INodeDefManager *nodemgr) const;
 183         v3s16 getWallMountedDir(INodeDefManager *nodemgr) const;
 184
 185         /*
 186                 Gets list of node boxes (used for rendering (NDT_NODEBOX)
 187                 and collision)
 188         */
 189         std::vector<aabb3f> getNodeBoxes(INodeDefManager *nodemgr) const;
 190
 191         /*
 192                 Gets list of selection boxes
 193         */
 194         std::vector<aabb3f> getSelectionBoxes(INodeDefManager *nodemgr) const;
 195
 196         /*
 197                 Serialization functions
 198         */
 199
 200         static u32 serializedLength(u8 version);
 201         void serialize(u8 *dest, u8 version);
 202         void deSerialize(u8 *source, u8 version);
 203
 204         // Serializes or deserializes a list of nodes in bulk format (first the
 205         // content of all nodes, then the param1 of all nodes, then the param2
 206         // of all nodes).
 207         //   version = serialization version. Must be >= 22
 208         //   content_width = the number of bytes of content per node
 209         //   params_width = the number of bytes of params per node
 210         //   compressed = true to zlib-compress output
 211         static void serializeBulk(std::ostream &os, int version,
 212                         const MapNode *nodes, u32 nodecount,
 213                         u8 content_width, u8 params_width, bool compressed);
 214         static void deSerializeBulk(std::istream &is, int version,
 215                         MapNode *nodes, u32 nodecount,
 216                         u8 content_width, u8 params_width, bool compressed);
 217
 218 private:
 219         // Deprecated serialization methods
 220         void deSerialize_pre22(u8 *source, u8 version);
 221 };
 222
 223 #endif
 224