src/mapnode.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 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 General Public License as published by
   7 the Free Software Foundation; either version 2 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 General Public License for more details.
  14
  15 You should have received a copy of the GNU 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 "light.h"
  25
  26 class INodeDefManager;
  27
  28 /*
  29         Naming scheme:
  30         - Material = irrlicht's Material class
  31         - Content = (content_t) content of a node
  32         - Tile = TileSpec at some side of a node of some content type
  33
  34         Content ranges:
  35                 0x000...0x07f: param2 is fully usable
  36                 0x800...0xfff: param2 lower 4 bytes are free
  37 */
  38 typedef u16 content_t;
  39 #define MAX_CONTENT 0xfff
  40
  41 /*
  42         Ignored node.
  43
  44         Anything that stores MapNodes doesn't have to preserve parameters
  45         associated with this material.
  46
  47         Doesn't create faces with anything and is considered being
  48         out-of-map in the game map.
  49 */
  50 #define CONTENT_IGNORE 127
  51 #define CONTENT_IGNORE_DEFAULT_PARAM 0
  52
  53 /*
  54         The common material through which the player can walk and which
  55         is transparent to light
  56 */
  57 #define CONTENT_AIR 126
  58
  59 #ifndef SERVER
  60 /*
  61         Nodes make a face if contents differ and solidness differs.
  62         Return value:
  63                 0: No face
  64                 1: Face uses m1's content
  65                 2: Face uses m2's content
  66         equivalent: Whether the blocks share the same face (eg. water and glass)
  67 */
  68 u8 face_contents(content_t m1, content_t m2, bool *equivalent,
  69                 INodeDefManager *nodemgr);
  70 #endif
  71
  72 /*
  73         Packs directions like (1,0,0), (1,-1,0) in six bits.
  74         NOTE: This wastes way too much space for most purposes.
  75 */
  76 u8 packDir(v3s16 dir);
  77 v3s16 unpackDir(u8 b);
  78
  79 /*
  80         facedir: CPT_FACEDIR_SIMPLE param1 value
  81         dir: The face for which stuff is wanted
  82         return value: The face from which the stuff is actually found
  83
  84         NOTE: Currently this uses 2 bits for Z-,X-,Z+,X+, should there be Y+
  85               and Y- too?
  86 */
  87 v3s16 facedir_rotate(u8 facedir, v3s16 dir);
  88
  89 enum LightBank
  90 {
  91         LIGHTBANK_DAY,
  92         LIGHTBANK_NIGHT
  93 };
  94
  95 /*
  96         Masks for MapNode.param2 of flowing liquids
  97  */
  98 #define LIQUID_LEVEL_MASK 0x07
  99 #define LIQUID_FLOW_DOWN_MASK 0x08
 100
 101 /* maximum amount of liquid in a block */
 102 #define LIQUID_LEVEL_MAX LIQUID_LEVEL_MASK
 103 #define LIQUID_LEVEL_SOURCE (LIQUID_LEVEL_MAX+1)
 104
 105 /*
 106         This is the stuff what the whole world consists of.
 107 */
 108
 109
 110 struct MapNode
 111 {
 112         /*
 113                 Main content
 114                 0x00-0x7f: Short content type
 115                 0x80-0xff: Long content type (param2>>4 makes up low bytes)
 116         */
 117         u8 param0;
 118
 119         /*
 120                 Misc parameter. Initialized to 0.
 121                 - For light_propagates() blocks, this is light intensity,
 122                   stored logarithmically from 0 to LIGHT_MAX.
 123                   Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
 124                   - Contains 2 values, day- and night lighting. Each takes 4 bits.
 125                 - Mineral content (should be removed from here)
 126                 - Uhh... well, most blocks have light or nothing in here.
 127         */
 128         u8 param1;
 129
 130         /*
 131                 The second parameter. Initialized to 0.
 132                 E.g. direction for torches and flowing water.
 133                 If param0 >= 0x80, bits 0xf0 of this is extended content type data
 134         */
 135         u8 param2;
 136
 137         MapNode(const MapNode & n)
 138         {
 139                 *this = n;
 140         }
 141
 142         MapNode(content_t content=CONTENT_AIR, u8 a_param1=0, u8 a_param2=0)
 143         {
 144                 param1 = a_param1;
 145                 param2 = a_param2;
 146                 // Set content (param0 and (param2&0xf0)) after other params
 147                 // because this needs to override part of param2
 148                 setContent(content);
 149         }
 150
 151         bool operator==(const MapNode &other)
 152         {
 153                 return (param0 == other.param0
 154                                 && param1 == other.param1
 155                                 && param2 == other.param2);
 156         }
 157
 158         // To be used everywhere
 159         content_t getContent() const
 160         {
 161                 if(param0 < 0x80)
 162                         return param0;
 163                 else
 164                         return (param0<<4) + (param2>>4);
 165         }
 166         void setContent(content_t c)
 167         {
 168                 if(c < 0x80)
 169                 {
 170                         if(param0 >= 0x80)
 171                                 param2 &= ~(0xf0);
 172                         param0 = c;
 173                 }
 174                 else
 175                 {
 176                         param0 = c>>4;
 177                         param2 &= ~(0xf0);
 178                         param2 |= (c&0x0f)<<4;
 179                 }
 180         }
 181
 182         void setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr);
 183         u8 getLight(enum LightBank bank, INodeDefManager *nodemgr) const;
 184         u8 getLightBanksWithSource(INodeDefManager *nodemgr) const;
 185
 186         // 0 <= daylight_factor <= 1000
 187         // 0 <= return value <= LIGHT_SUN
 188         u8 getLightBlend(u32 daylight_factor, INodeDefManager *nodemgr) const
 189         {
 190                 u8 l = ((daylight_factor * getLight(LIGHTBANK_DAY, nodemgr)
 191                         + (1000-daylight_factor) * getLight(LIGHTBANK_NIGHT, nodemgr))
 192                         )/1000;
 193                 u8 max = LIGHT_MAX;
 194                 if(getLight(LIGHTBANK_DAY, nodemgr) == LIGHT_SUN)
 195                         max = LIGHT_SUN;
 196                 if(l > max)
 197                         l = max;
 198                 return l;
 199         }
 200         /*// 0 <= daylight_factor <= 1000
 201         // 0 <= return value <= 255
 202         u8 getLightBlend(u32 daylight_factor, INodeDefManager *nodemgr)
 203         {
 204                 u8 daylight = decode_light(getLight(LIGHTBANK_DAY, nodemgr));
 205                 u8 nightlight = decode_light(getLight(LIGHTBANK_NIGHT, nodemgr));
 206                 u8 mix = ((daylight_factor * daylight
 207                         + (1000-daylight_factor) * nightlight)
 208                         )/1000;
 209                 return mix;
 210         }*/
 211
 212         /*
 213                 Gets mineral content of node, if there is any.
 214                 MINERAL_NONE if doesn't contain or isn't able to contain mineral.
 215         */
 216         u8 getMineral(INodeDefManager *nodemgr) const;
 217
 218         /*
 219                 Serialization functions
 220         */
 221
 222         static u32 serializedLength(u8 version);
 223         void serialize(u8 *dest, u8 version);
 224         void deSerialize(u8 *source, u8 version);
 225
 226 };
 227
 228 /*
 229         Gets lighting value at face of node
 230
 231         Parameters must consist of air and !air.
 232         Order doesn't matter.
 233
 234         If either of the nodes doesn't exist, light is 0.
 235
 236         parameters:
 237                 daynight_ratio: 0...1000
 238                 n: getNode(p) (uses only the lighting value)
 239                 n2: getNode(p + face_dir) (uses only the lighting value)
 240                 face_dir: axis oriented unit vector from p to p2
 241
 242         returns encoded light value.
 243 */
 244 u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
 245                 v3s16 face_dir, INodeDefManager *nodemgr);
 246
 247 #endif
 248