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 v3s16 facedir_rotate(u8 facedir, v3s16 dir);
 396
 397 enum LightBank
 398 {
 399         LIGHTBANK_DAY,
 400         LIGHTBANK_NIGHT
 401 };
 402
 403 /*
 404         Masks for MapNode.param2 of flowing liquids
 405  */
 406 #define LIQUID_LEVEL_MASK 0x07
 407 #define LIQUID_FLOW_DOWN_MASK 0x08
 408
 409 /*
 410         This is the stuff what the whole world consists of.
 411 */
 412
 413
 414 struct MapNode
 415 {
 416         /*
 417                 Main content
 418                 0x00-0x7f: Short content type
 419                 0x80-0xff: Long content type (param2>>4 makes up low bytes)
 420         */
 421         union
 422         {
 423                 u8 param0;
 424                 //u8 d;
 425         };
 426
 427         /*
 428                 Misc parameter. Initialized to 0.
 429                 - For light_propagates() blocks, this is light intensity,
 430                   stored logarithmically from 0 to LIGHT_MAX.
 431                   Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
 432                   - Contains 2 values, day- and night lighting. Each takes 4 bits.
 433                 - Mineral content (should be removed from here)
 434                 - Uhh... well, most blocks have light or nothing in here.
 435         */
 436         union
 437         {
 438                 u8 param1;
 439                 //s8 param;
 440         };
 441
 442         /*
 443                 The second parameter. Initialized to 0.
 444                 E.g. direction for torches and flowing water.
 445                 If param0 >= 0x80, bits 0xf0 of this is extended content type data
 446         */
 447         union
 448         {
 449                 u8 param2;
 450                 //u8 dir;
 451         };
 452
 453         MapNode(const MapNode & n)
 454         {
 455                 *this = n;
 456         }
 457
 458         MapNode(content_t content=CONTENT_AIR, u8 a_param1=0, u8 a_param2=0)
 459         {
 460                 //param0 = a_param0;
 461                 param1 = a_param1;
 462                 param2 = a_param2;
 463                 // Set after other params because this needs to override part of param2
 464                 setContent(content);
 465         }
 466
 467         bool operator==(const MapNode &other)
 468         {
 469                 return (param0 == other.param0
 470                                 && param1 == other.param1
 471                                 && param2 == other.param2);
 472         }
 473
 474         // To be used everywhere
 475         content_t getContent()
 476         {
 477                 if(param0 < 0x80)
 478                         return param0;
 479                 else
 480                         return (param0<<4) + (param2>>4);
 481         }
 482         void setContent(content_t c)
 483         {
 484                 if(c < 0x80)
 485                 {
 486                         if(param0 >= 0x80)
 487                                 param2 &= ~(0xf0);
 488                         param0 = c;
 489                 }
 490                 else
 491                 {
 492                         param0 = c>>4;
 493                         param2 &= ~(0xf0);
 494                         param2 |= (c&0x0f)<<4;
 495                 }
 496         }
 497
 498         /*
 499                 These four are DEPRECATED I guess. -c55
 500         */
 501         bool light_propagates()
 502         {
 503                 return light_propagates_content(getContent());
 504         }
 505         bool sunlight_propagates()
 506         {
 507                 return sunlight_propagates_content(getContent());
 508         }
 509         u8 solidness()
 510         {
 511                 return content_solidness(getContent());
 512         }
 513         u8 light_source()
 514         {
 515                 return content_features(*this).light_source;
 516         }
 517
 518         u8 getLightBanksWithSource()
 519         {
 520                 // Select the brightest of [light source, propagated light]
 521                 u8 lightday = 0;
 522                 u8 lightnight = 0;
 523                 if(content_features(*this).param_type == CPT_LIGHT)
 524                 {
 525                         lightday = param1 & 0x0f;
 526                         lightnight = (param1>>4)&0x0f;
 527                 }
 528                 if(light_source() > lightday)
 529                         lightday = light_source();
 530                 if(light_source() > lightnight)
 531                         lightnight = light_source();
 532                 return (lightday&0x0f) | ((lightnight<<4)&0xf0);
 533         }
 534
 535         u8 getLight(enum LightBank bank)
 536         {
 537                 // Select the brightest of [light source, propagated light]
 538                 u8 light = 0;
 539                 if(content_features(*this).param_type == CPT_LIGHT)
 540                 {
 541                         if(bank == LIGHTBANK_DAY)
 542                                 light = param1 & 0x0f;
 543                         else if(bank == LIGHTBANK_NIGHT)
 544                                 light = (param1>>4)&0x0f;
 545                         else
 546                                 assert(0);
 547                 }
 548                 if(light_source() > light)
 549                         light = light_source();
 550                 return light;
 551         }
 552
 553         // 0 <= daylight_factor <= 1000
 554         // 0 <= return value <= LIGHT_SUN
 555         u8 getLightBlend(u32 daylight_factor)
 556         {
 557                 u8 l = ((daylight_factor * getLight(LIGHTBANK_DAY)
 558                         + (1000-daylight_factor) * getLight(LIGHTBANK_NIGHT))
 559                         )/1000;
 560                 u8 max = LIGHT_MAX;
 561                 if(getLight(LIGHTBANK_DAY) == LIGHT_SUN)
 562                         max = LIGHT_SUN;
 563                 if(l > max)
 564                         l = max;
 565                 return l;
 566         }
 567         /*// 0 <= daylight_factor <= 1000
 568         // 0 <= return value <= 255
 569         u8 getLightBlend(u32 daylight_factor)
 570         {
 571                 u8 daylight = decode_light(getLight(LIGHTBANK_DAY));
 572                 u8 nightlight = decode_light(getLight(LIGHTBANK_NIGHT));
 573                 u8 mix = ((daylight_factor * daylight
 574                         + (1000-daylight_factor) * nightlight)
 575                         )/1000;
 576                 return mix;
 577         }*/
 578
 579         void setLight(enum LightBank bank, u8 a_light)
 580         {
 581                 // If node doesn't contain light data, ignore this
 582                 if(content_features(*this).param_type != CPT_LIGHT)
 583                         return;
 584                 if(bank == LIGHTBANK_DAY)
 585                 {
 586                         param1 &= 0xf0;
 587                         param1 |= a_light & 0x0f;
 588                 }
 589                 else if(bank == LIGHTBANK_NIGHT)
 590                 {
 591                         param1 &= 0x0f;
 592                         param1 |= (a_light & 0x0f)<<4;
 593                 }
 594                 else
 595                         assert(0);
 596         }
 597
 598         // In mapnode.cpp
 599         /*
 600                 Get tile of a face of the node.
 601                 dir: direction of face
 602                 Returns: TileSpec. Can contain miscellaneous texture coordinates,
 603                          which must be obeyed so that the texture atlas can be used.
 604         */
 605         TileSpec getTile(v3s16 dir);
 606
 607         /*
 608                 Gets mineral content of node, if there is any.
 609                 MINERAL_NONE if doesn't contain or isn't able to contain mineral.
 610         */
 611         u8 getMineral();
 612
 613         /*
 614                 Serialization functions
 615         */
 616
 617         static u32 serializedLength(u8 version);
 618         void serialize(u8 *dest, u8 version);
 619         void deSerialize(u8 *source, u8 version);
 620
 621 };
 622
 623 /*
 624         Gets lighting value at face of node
 625
 626         Parameters must consist of air and !air.
 627         Order doesn't matter.
 628
 629         If either of the nodes doesn't exist, light is 0.
 630
 631         parameters:
 632                 daynight_ratio: 0...1000
 633                 n: getNodeParent(p)
 634                 n2: getNodeParent(p + face_dir)
 635                 face_dir: axis oriented unit vector from p to p2
 636
 637         returns encoded light value.
 638 */
 639 u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
 640                 v3s16 face_dir);
 641
 642 #endif
 643