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 <iostream>
  24 #include "common_irrlicht.h"
  25 #include "light.h"
  26 #include "utility.h"
  27 #include "exceptions.h"
  28 #include "serialization.h"
  29 #include "tile.h"
  30 #include "materials.h"
  31
  32 /*
  33         Naming scheme:
  34         - Material = irrlicht's Material class
  35         - Content = (content_t) content of a node
  36         - Tile = TileSpec at some side of a node of some content type
  37
  38         Content ranges:
  39                 0x000...0x07f: param2 is fully usable
  40                 0x800...0xfff: param2 lower 4 bytes are free
  41 */
  42 typedef u16 content_t;
  43 #define MAX_CONTENT 0xfff
  44
  45 /*
  46         Initializes all kind of stuff in here.
  47         Many things depend on this.
  48
  49         This accesses g_texturesource; if it is non-NULL, textures are set.
  50
  51         Client first calls this with g_texturesource=NULL to run some
  52         unit tests and stuff, then it runs this again with g_texturesource
  53         defined to get the textures.
  54
  55         Server only calls this once with g_texturesource=NULL.
  56 */
  57 void init_mapnode();
  58
  59 /*
  60         Ignored node.
  61
  62         Anything that stores MapNodes doesn't have to preserve parameters
  63         associated with this material.
  64
  65         Doesn't create faces with anything and is considered being
  66         out-of-map in the game map.
  67 */
  68 //#define CONTENT_IGNORE 255
  69 #define CONTENT_IGNORE 127
  70 #define CONTENT_IGNORE_DEFAULT_PARAM 0
  71
  72 /*
  73         The common material through which the player can walk and which
  74         is transparent to light
  75 */
  76 //#define CONTENT_AIR 254
  77 #define CONTENT_AIR 126
  78
  79 /*
  80         Content feature list
  81 */
  82
  83 enum ContentParamType
  84 {
  85         CPT_NONE,
  86         CPT_LIGHT,
  87         CPT_MINERAL,
  88         // Direction for chests and furnaces and such
  89         CPT_FACEDIR_SIMPLE
  90 };
  91
  92 enum LiquidType
  93 {
  94         LIQUID_NONE,
  95         LIQUID_FLOWING,
  96         LIQUID_SOURCE
  97 };
  98
  99 class MapNode;
 100 class NodeMetadata;
 101
 102 struct ContentFeatures
 103 {
 104         // Type of MapNode::param1
 105         ContentParamType param_type;
 106
 107         /*
 108                 0: up
 109                 1: down
 110                 2: right
 111                 3: left
 112                 4: back
 113                 5: front
 114         */
 115         TileSpec tiles[6];
 116
 117         video::ITexture *inventory_texture;
 118
 119         // True for all ground-like things like stone and mud, false for eg. trees
 120         bool is_ground_content;
 121         bool light_propagates;
 122         bool sunlight_propagates;
 123         u8 solidness; // Used when choosing which face is drawn
 124         // This is used for collision detection.
 125         // Also for general solidness queries.
 126         bool walkable;
 127         // Player can point to these
 128         bool pointable;
 129         // Player can dig these
 130         bool diggable;
 131         // Player can build on these
 132         bool buildable_to;
 133         // Whether the node has no liquid, source liquid or flowing liquid
 134         enum LiquidType liquid_type;
 135         // If true, param2 is set to direction when placed. Used for torches.
 136         // NOTE: the direction format is quite inefficient and should be changed
 137         bool wall_mounted;
 138         // If true, node is equivalent to air. Torches are, air is. Water is not.
 139         // Is used for example to check whether a mud block can have grass on.
 140         bool air_equivalent;
 141
 142         // Inventory item string as which the node appears in inventory when dug.
 143         // Mineral overrides this.
 144         std::string dug_item;
 145
 146         // Initial metadata is cloned from this
 147         NodeMetadata *initial_metadata;
 148
 149         // If the content is liquid, this is the flowing version of the liquid.
 150         // If content is liquid, this is the same content.
 151         content_t liquid_alternative_flowing;
 152         // If the content is liquid, this is the source version of the liquid.
 153         content_t liquid_alternative_source;
 154
 155         // Amount of light the node emits
 156         u8 light_source;
 157
 158         // Digging properties for different tools
 159         DiggingPropertiesList digging_properties;
 160
 161         // NOTE: Move relevant properties to here from elsewhere
 162
 163         void reset()
 164         {
 165                 param_type = CPT_NONE;
 166                 inventory_texture = NULL;
 167                 is_ground_content = false;
 168                 light_propagates = false;
 169                 sunlight_propagates = false;
 170                 solidness = 2;
 171                 walkable = true;
 172                 pointable = true;
 173                 diggable = true;
 174                 buildable_to = false;
 175                 liquid_type = LIQUID_NONE;
 176                 wall_mounted = false;
 177                 air_equivalent = false;
 178                 dug_item = "";
 179                 initial_metadata = NULL;
 180                 liquid_alternative_flowing = CONTENT_IGNORE;
 181                 light_source = 0;
 182                 digging_properties.clear();
 183         }
 184
 185         ContentFeatures()
 186         {
 187                 reset();
 188         }
 189
 190         ~ContentFeatures();
 191
 192         /*
 193                 Quickhands for simple materials
 194         */
 195
 196         void setTexture(u16 i, std::string name, u8 alpha=255);
 197
 198         void setAllTextures(std::string name, u8 alpha=255)
 199         {
 200                 for(u16 i=0; i<6; i++)
 201                 {
 202                         setTexture(i, name, alpha);
 203                 }
 204                 // Force inventory texture too
 205                 setInventoryTexture(name);
 206         }
 207
 208         void setTile(u16 i, const TileSpec &tile)
 209         {
 210                 tiles[i] = tile;
 211         }
 212         void setAllTiles(const TileSpec &tile)
 213         {
 214                 for(u16 i=0; i<6; i++)
 215                 {
 216                         setTile(i, tile);
 217                 }
 218         }
 219
 220         void setInventoryTexture(std::string imgname);
 221
 222         void setInventoryTextureCube(std::string top,
 223                         std::string left, std::string right);
 224 };
 225
 226 /*
 227         Call this to access the ContentFeature list
 228 */
 229 ContentFeatures & content_features(content_t i);
 230 ContentFeatures & content_features(MapNode &n);
 231
 232 /*
 233         Here is a bunch of DEPRECATED functions.
 234 */
 235
 236 /*
 237         If true, the material allows light propagation and brightness is stored
 238         in param.
 239         NOTE: Don't use, use "content_features(m).whatever" instead
 240 */
 241 inline bool light_propagates_content(content_t m)
 242 {
 243         return content_features(m).light_propagates;
 244 }
 245 /*
 246         If true, the material allows lossless sunlight propagation.
 247         NOTE: It doesn't seem to go through torches regardlessly of this
 248         NOTE: Don't use, use "content_features(m).whatever" instead
 249 */
 250 inline bool sunlight_propagates_content(content_t m)
 251 {
 252         return content_features(m).sunlight_propagates;
 253 }
 254 /*
 255         On a node-node surface, the material of the node with higher solidness
 256         is used for drawing.
 257         0: Invisible
 258         1: Transparent
 259         2: Opaque
 260         NOTE: Don't use, use "content_features(m).whatever" instead
 261 */
 262 inline u8 content_solidness(content_t m)
 263 {
 264         return content_features(m).solidness;
 265 }
 266 // Objects collide with walkable contents
 267 // NOTE: Don't use, use "content_features(m).whatever" instead
 268 inline bool content_walkable(content_t m)
 269 {
 270         return content_features(m).walkable;
 271 }
 272 // NOTE: Don't use, use "content_features(m).whatever" instead
 273 inline bool content_liquid(content_t m)
 274 {
 275         return content_features(m).liquid_type != LIQUID_NONE;
 276 }
 277 // NOTE: Don't use, use "content_features(m).whatever" instead
 278 inline bool content_flowing_liquid(content_t m)
 279 {
 280         return content_features(m).liquid_type == LIQUID_FLOWING;
 281 }
 282 // NOTE: Don't use, use "content_features(m).whatever" instead
 283 inline bool content_liquid_source(content_t m)
 284 {
 285         return content_features(m).liquid_type == LIQUID_SOURCE;
 286 }
 287 // CONTENT_WATER || CONTENT_WATERSOURCE -> CONTENT_WATER
 288 // CONTENT_LAVA || CONTENT_LAVASOURCE -> CONTENT_LAVA
 289 // NOTE: Don't use, use "content_features(m).whatever" instead
 290 inline content_t make_liquid_flowing(content_t m)
 291 {
 292         u8 c = content_features(m).liquid_alternative_flowing;
 293         assert(c != CONTENT_IGNORE);
 294         return c;
 295 }
 296 // Pointable contents can be pointed to in the map
 297 // NOTE: Don't use, use "content_features(m).whatever" instead
 298 inline bool content_pointable(content_t m)
 299 {
 300         return content_features(m).pointable;
 301 }
 302 // NOTE: Don't use, use "content_features(m).whatever" instead
 303 inline bool content_diggable(content_t m)
 304 {
 305         return content_features(m).diggable;
 306 }
 307 // NOTE: Don't use, use "content_features(m).whatever" instead
 308 inline bool content_buildable_to(content_t m)
 309 {
 310         return content_features(m).buildable_to;
 311 }
 312
 313 /*
 314         Nodes make a face if contents differ and solidness differs.
 315         Return value:
 316                 0: No face
 317                 1: Face uses m1's content
 318                 2: Face uses m2's content
 319 */
 320 inline u8 face_contents(content_t m1, content_t m2)
 321 {
 322         if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE)
 323                 return 0;
 324
 325         bool contents_differ = (m1 != m2);
 326
 327         // Contents don't differ for different forms of same liquid
 328         if(content_liquid(m1) && content_liquid(m2)
 329                         && make_liquid_flowing(m1) == make_liquid_flowing(m2))
 330                 contents_differ = false;
 331
 332         bool solidness_differs = (content_solidness(m1) != content_solidness(m2));
 333         bool makes_face = contents_differ && solidness_differs;
 334
 335         if(makes_face == false)
 336                 return 0;
 337
 338         if(content_solidness(m1) > content_solidness(m2))
 339                 return 1;
 340         else
 341                 return 2;
 342 }
 343
 344 /*
 345         Packs directions like (1,0,0), (1,-1,0)
 346 */
 347 inline u8 packDir(v3s16 dir)
 348 {
 349         u8 b = 0;
 350
 351         if(dir.X > 0)
 352                 b |= (1<<0);
 353         else if(dir.X < 0)
 354                 b |= (1<<1);
 355
 356         if(dir.Y > 0)
 357                 b |= (1<<2);
 358         else if(dir.Y < 0)
 359                 b |= (1<<3);
 360
 361         if(dir.Z > 0)
 362                 b |= (1<<4);
 363         else if(dir.Z < 0)
 364                 b |= (1<<5);
 365
 366         return b;
 367 }
 368 inline v3s16 unpackDir(u8 b)
 369 {
 370         v3s16 d(0,0,0);
 371
 372         if(b & (1<<0))
 373                 d.X = 1;
 374         else if(b & (1<<1))
 375                 d.X = -1;
 376
 377         if(b & (1<<2))
 378                 d.Y = 1;
 379         else if(b & (1<<3))
 380                 d.Y = -1;
 381
 382         if(b & (1<<4))
 383                 d.Z = 1;
 384         else if(b & (1<<5))
 385                 d.Z = -1;
 386
 387         return d;
 388 }
 389
 390 /*
 391         facedir: CPT_FACEDIR_SIMPLE param1 value
 392         dir: The face for which stuff is wanted
 393         return value: The face from which the stuff is actually found
 394
 395         NOTE: Currently this uses 2 bits for Z-,X-,Z+,X+, should there be Y+
 396               and Y- too?
 397 */
 398 v3s16 facedir_rotate(u8 facedir, v3s16 dir);
 399
 400 enum LightBank
 401 {
 402         LIGHTBANK_DAY,
 403         LIGHTBANK_NIGHT
 404 };
 405
 406 /*
 407         This is the stuff what the whole world consists of.
 408 */
 409
 410 struct MapNode
 411 {
 412         /*
 413                 Main content
 414                 0x00-0x7f: Short content type
 415                 0x80-0xff: Long content type (param2>>4 makes up low bytes)
 416         */
 417         union
 418         {
 419                 u8 param0;
 420                 //u8 d;
 421         };
 422
 423         /*
 424                 Misc parameter. Initialized to 0.
 425                 - For light_propagates() blocks, this is light intensity,
 426                   stored logarithmically from 0 to LIGHT_MAX.
 427                   Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
 428                   - Contains 2 values, day- and night lighting. Each takes 4 bits.
 429                 - Mineral content (should be removed from here)
 430                 - Uhh... well, most blocks have light or nothing in here.
 431         */
 432         union
 433         {
 434                 u8 param1;
 435                 //s8 param;
 436         };
 437
 438         /*
 439                 The second parameter. Initialized to 0.
 440                 E.g. direction for torches and flowing water.
 441                 If param0 >= 0x80, bits 0xf0 of this is extended content type data
 442         */
 443         union
 444         {
 445                 u8 param2;
 446                 //u8 dir;
 447         };
 448
 449         MapNode(const MapNode & n)
 450         {
 451                 *this = n;
 452         }
 453
 454         MapNode(content_t content=CONTENT_AIR, u8 a_param1=0, u8 a_param2=0)
 455         {
 456                 //param0 = a_param0;
 457                 param1 = a_param1;
 458                 param2 = a_param2;
 459                 // Set after other params because this needs to override part of param2
 460                 setContent(content);
 461         }
 462
 463         bool operator==(const MapNode &other)
 464         {
 465                 return (param0 == other.param0
 466                                 && param1 == other.param1
 467                                 && param2 == other.param2);
 468         }
 469
 470         // To be used everywhere
 471         content_t getContent()
 472         {
 473                 if(param0 < 0x80)
 474                         return param0;
 475                 else
 476                         return (param0<<4) + (param2>>4);
 477         }
 478         void setContent(content_t c)
 479         {
 480                 if(c < 0x80)
 481                 {
 482                         if(param0 >= 0x80)
 483                                 param2 &= ~(0xf0);
 484                         param0 = c;
 485                 }
 486                 else
 487                 {
 488                         param0 = c>>4;
 489                         param2 &= ~(0xf0);
 490                         param2 |= (c&0x0f)<<4;
 491                 }
 492         }
 493
 494         /*
 495                 These four are DEPRECATED I guess. -c55
 496         */
 497         bool light_propagates()
 498         {
 499                 return light_propagates_content(getContent());
 500         }
 501         bool sunlight_propagates()
 502         {
 503                 return sunlight_propagates_content(getContent());
 504         }
 505         u8 solidness()
 506         {
 507                 return content_solidness(getContent());
 508         }
 509         u8 light_source()
 510         {
 511                 return content_features(*this).light_source;
 512         }
 513
 514         u8 getLightBanksWithSource()
 515         {
 516                 // Select the brightest of [light source, propagated light]
 517                 u8 lightday = 0;
 518                 u8 lightnight = 0;
 519                 if(content_features(*this).param_type == CPT_LIGHT)
 520                 {
 521                         lightday = param1 & 0x0f;
 522                         lightnight = (param1>>4)&0x0f;
 523                 }
 524                 if(light_source() > lightday)
 525                         lightday = light_source();
 526                 if(light_source() > lightnight)
 527                         lightnight = light_source();
 528                 return (lightday&0x0f) | ((lightnight<<4)&0xf0);
 529         }
 530
 531         u8 getLight(enum LightBank bank)
 532         {
 533                 // Select the brightest of [light source, propagated light]
 534                 u8 light = 0;
 535                 if(content_features(*this).param_type == CPT_LIGHT)
 536                 {
 537                         if(bank == LIGHTBANK_DAY)
 538                                 light = param1 & 0x0f;
 539                         else if(bank == LIGHTBANK_NIGHT)
 540                                 light = (param1>>4)&0x0f;
 541                         else
 542                                 assert(0);
 543                 }
 544                 if(light_source() > light)
 545                         light = light_source();
 546                 return light;
 547         }
 548
 549         // 0 <= daylight_factor <= 1000
 550         // 0 <= return value <= LIGHT_SUN
 551         u8 getLightBlend(u32 daylight_factor)
 552         {
 553                 u8 l = ((daylight_factor * getLight(LIGHTBANK_DAY)
 554                         + (1000-daylight_factor) * getLight(LIGHTBANK_NIGHT))
 555                         )/1000;
 556                 u8 max = LIGHT_MAX;
 557                 if(getLight(LIGHTBANK_DAY) == LIGHT_SUN)
 558                         max = LIGHT_SUN;
 559                 if(l > max)
 560                         l = max;
 561                 return l;
 562         }
 563         /*// 0 <= daylight_factor <= 1000
 564         // 0 <= return value <= 255
 565         u8 getLightBlend(u32 daylight_factor)
 566         {
 567                 u8 daylight = decode_light(getLight(LIGHTBANK_DAY));
 568                 u8 nightlight = decode_light(getLight(LIGHTBANK_NIGHT));
 569                 u8 mix = ((daylight_factor * daylight
 570                         + (1000-daylight_factor) * nightlight)
 571                         )/1000;
 572                 return mix;
 573         }*/
 574
 575         void setLight(enum LightBank bank, u8 a_light)
 576         {
 577                 // If node doesn't contain light data, ignore this
 578                 if(content_features(*this).param_type != CPT_LIGHT)
 579                         return;
 580                 if(bank == LIGHTBANK_DAY)
 581                 {
 582                         param1 &= 0xf0;
 583                         param1 |= a_light & 0x0f;
 584                 }
 585                 else if(bank == LIGHTBANK_NIGHT)
 586                 {
 587                         param1 &= 0x0f;
 588                         param1 |= (a_light & 0x0f)<<4;
 589                 }
 590                 else
 591                         assert(0);
 592         }
 593
 594         // In mapnode.cpp
 595         /*
 596                 Get tile of a face of the node.
 597                 dir: direction of face
 598                 Returns: TileSpec. Can contain miscellaneous texture coordinates,
 599                          which must be obeyed so that the texture atlas can be used.
 600         */
 601         TileSpec getTile(v3s16 dir);
 602
 603         /*
 604                 Gets mineral content of node, if there is any.
 605                 MINERAL_NONE if doesn't contain or isn't able to contain mineral.
 606         */
 607         u8 getMineral();
 608
 609         /*
 610                 Serialization functions
 611         */
 612
 613         static u32 serializedLength(u8 version);
 614         void serialize(u8 *dest, u8 version);
 615         void deSerialize(u8 *source, u8 version);
 616
 617 };
 618
 619 /*
 620         Gets lighting value at face of node
 621
 622         Parameters must consist of air and !air.
 623         Order doesn't matter.
 624
 625         If either of the nodes doesn't exist, light is 0.
 626
 627         parameters:
 628                 daynight_ratio: 0...1000
 629                 n: getNodeParent(p)
 630                 n2: getNodeParent(p + face_dir)
 631                 face_dir: axis oriented unit vector from p to p2
 632
 633         returns encoded light value.
 634 */
 635 u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
 636                 v3s16 face_dir);
 637
 638 #endif
 639