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