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