src/content_mapnode.cpp

   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 // For g_settings
  21 #include "main.h"
  22
  23 #include "content_mapnode.h"
  24 #include "mapnode.h"
  25 #include "content_nodemeta.h"
  26 #include "settings.h"
  27 #include "nodedef.h"
  28
  29 #define WATER_ALPHA 160
  30
  31 #define WATER_VISC 1
  32 #define LAVA_VISC 7
  33
  34 void setConstantMaterialProperties(MaterialProperties &mprop, float time)
  35 {
  36         mprop.diggability = DIGGABLE_CONSTANT;
  37         mprop.constant_time = time;
  38 }
  39
  40 void setStoneLikeMaterialProperties(MaterialProperties &mprop, float toughness)
  41 {
  42         mprop.diggability = DIGGABLE_NORMAL;
  43         mprop.weight = 5.0 * toughness;
  44         mprop.crackiness = 1.0;
  45         mprop.crumbliness = -0.1;
  46         mprop.cuttability = -0.2;
  47 }
  48
  49 void setDirtLikeMaterialProperties(MaterialProperties &mprop, float toughness)
  50 {
  51         mprop.diggability = DIGGABLE_NORMAL;
  52         mprop.weight = toughness * 1.2;
  53         mprop.crackiness = 0;
  54         mprop.crumbliness = 1.2;
  55         mprop.cuttability = -0.4;
  56 }
  57
  58 void setGravelLikeMaterialProperties(MaterialProperties &mprop, float toughness)
  59 {
  60         mprop.diggability = DIGGABLE_NORMAL;
  61         mprop.weight = toughness * 2.0;
  62         mprop.crackiness = 0.2;
  63         mprop.crumbliness = 1.5;
  64         mprop.cuttability = -1.0;
  65 }
  66
  67 void setWoodLikeMaterialProperties(MaterialProperties &mprop, float toughness)
  68 {
  69         mprop.diggability = DIGGABLE_NORMAL;
  70         mprop.weight = toughness * 1.0;
  71         mprop.crackiness = 0.75;
  72         mprop.crumbliness = -1.0;
  73         mprop.cuttability = 1.5;
  74 }
  75
  76 void setLeavesLikeMaterialProperties(MaterialProperties &mprop, float toughness)
  77 {
  78         mprop.diggability = DIGGABLE_NORMAL;
  79         mprop.weight = -0.5 * toughness;
  80         mprop.crackiness = 0;
  81         mprop.crumbliness = 0;
  82         mprop.cuttability = 2.0;
  83 }
  84
  85 void setGlassLikeMaterialProperties(MaterialProperties &mprop, float toughness)
  86 {
  87         mprop.diggability = DIGGABLE_NORMAL;
  88         mprop.weight = 0.1 * toughness;
  89         mprop.crackiness = 2.0;
  90         mprop.crumbliness = -1.0;
  91         mprop.cuttability = -1.0;
  92 }
  93
  94 /*
  95         A conversion table for backwards compatibility.
  96         Maps <=v19 content types to current ones.
  97         Should never be touched.
  98 */
  99 content_t trans_table_19[21][2] = {
 100         {CONTENT_GRASS, 1},
 101         {CONTENT_TREE, 4},
 102         {CONTENT_LEAVES, 5},
 103         {CONTENT_GRASS_FOOTSTEPS, 6},
 104         {CONTENT_MESE, 7},
 105         {CONTENT_MUD, 8},
 106         {CONTENT_CLOUD, 10},
 107         {CONTENT_COALSTONE, 11},
 108         {CONTENT_WOOD, 12},
 109         {CONTENT_SAND, 13},
 110         {CONTENT_COBBLE, 18},
 111         {CONTENT_STEEL, 19},
 112         {CONTENT_GLASS, 20},
 113         {CONTENT_MOSSYCOBBLE, 22},
 114         {CONTENT_GRAVEL, 23},
 115         {CONTENT_SANDSTONE, 24},
 116         {CONTENT_CACTUS, 25},
 117         {CONTENT_BRICK, 26},
 118         {CONTENT_CLAY, 27},
 119         {CONTENT_PAPYRUS, 28},
 120         {CONTENT_BOOKSHELF, 29},
 121 };
 122
 123 MapNode mapnode_translate_from_internal(MapNode n_from, u8 version)
 124 {
 125         MapNode result = n_from;
 126         if(version <= 19)
 127         {
 128                 content_t c_from = n_from.getContent();
 129                 for(u32 i=0; i<sizeof(trans_table_19)/sizeof(trans_table_19[0]); i++)
 130                 {
 131                         if(trans_table_19[i][0] == c_from)
 132                         {
 133                                 result.setContent(trans_table_19[i][1]);
 134                                 break;
 135                         }
 136                 }
 137         }
 138         return result;
 139 }
 140 MapNode mapnode_translate_to_internal(MapNode n_from, u8 version)
 141 {
 142         MapNode result = n_from;
 143         if(version <= 19)
 144         {
 145                 content_t c_from = n_from.getContent();
 146                 for(u32 i=0; i<sizeof(trans_table_19)/sizeof(trans_table_19[0]); i++)
 147                 {
 148                         if(trans_table_19[i][1] == c_from)
 149                         {
 150                                 result.setContent(trans_table_19[i][0]);
 151                                 break;
 152                         }
 153                 }
 154         }
 155         return result;
 156 }
 157
 158 // See header for description
 159 void content_mapnode_init(ITextureSource *tsrc, IWritableNodeDefManager *nodemgr)
 160 {
 161         if(tsrc == NULL)
 162                 dstream<<"INFO: Initial run of content_mapnode_init with "
 163                                 "tsrc=NULL. If this segfaults, "
 164                                 "there is a bug with something not checking for "
 165                                 "the NULL value."<<std::endl;
 166         else
 167                 dstream<<"INFO: Full run of content_mapnode_init with "
 168                                 "tsrc!=NULL"<<std::endl;
 169
 170         // Read some settings
 171         bool new_style_water = g_settings->getBool("new_style_water");
 172         bool new_style_leaves = g_settings->getBool("new_style_leaves");
 173         bool invisible_stone = g_settings->getBool("invisible_stone");
 174         bool opaque_water = g_settings->getBool("opaque_water");
 175
 176         content_t i;
 177         ContentFeatures *f = NULL;
 178
 179         i = CONTENT_STONE;
 180         f = nodemgr->getModifiable(i);
 181         f->setAllTextures("stone.png");
 182         f->setInventoryTextureCube("stone.png", "stone.png", "stone.png");
 183         f->param_type = CPT_MINERAL;
 184         f->is_ground_content = true;
 185         f->often_contains_mineral = true;
 186         f->dug_item = std::string("MaterialItem2 ")+itos(CONTENT_COBBLE)+" 1";
 187         setStoneLikeMaterialProperties(f->material, 1.0);
 188         if(invisible_stone)
 189                 f->solidness = 0; // For debugging, hides regular stone
 190
 191         i = CONTENT_GRASS;
 192         f = nodemgr->getModifiable(i);
 193         f->setAllTextures("mud.png^grass_side.png");
 194         f->setTexture(0, "grass.png");
 195         f->setTexture(1, "mud.png");
 196         f->param_type = CPT_MINERAL;
 197         f->is_ground_content = true;
 198         f->dug_item = std::string("MaterialItem2 ")+itos(CONTENT_MUD)+" 1";
 199         setDirtLikeMaterialProperties(f->material, 1.0);
 200
 201         i = CONTENT_GRASS_FOOTSTEPS;
 202         f = nodemgr->getModifiable(i);
 203         f->setAllTextures("mud.png^grass_side.png");
 204         f->setTexture(0, "grass_footsteps.png");
 205         f->setTexture(1, "mud.png");
 206         f->param_type = CPT_MINERAL;
 207         f->is_ground_content = true;
 208         f->dug_item = std::string("MaterialItem2 ")+itos(CONTENT_MUD)+" 1";
 209         setDirtLikeMaterialProperties(f->material, 1.0);
 210
 211         i = CONTENT_MUD;
 212         f = nodemgr->getModifiable(i);
 213         f->setAllTextures("mud.png");
 214         f->setInventoryTextureCube("mud.png", "mud.png", "mud.png");
 215         f->param_type = CPT_MINERAL;
 216         f->is_ground_content = true;
 217         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 218         setDirtLikeMaterialProperties(f->material, 1.0);
 219
 220         i = CONTENT_SAND;
 221         f = nodemgr->getModifiable(i);
 222         f->setAllTextures("sand.png");
 223         f->setInventoryTextureCube("sand.png", "sand.png", "sand.png");
 224         f->param_type = CPT_MINERAL;
 225         f->is_ground_content = true;
 226         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 227         setDirtLikeMaterialProperties(f->material, 1.0);
 228
 229         i = CONTENT_GRAVEL;
 230         f = nodemgr->getModifiable(i);
 231         f->setAllTextures("gravel.png");
 232         f->setInventoryTextureCube("gravel.png", "gravel.png", "gravel.png");
 233         f->param_type = CPT_MINERAL;
 234         f->is_ground_content = true;
 235         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 236         setGravelLikeMaterialProperties(f->material, 1.0);
 237
 238         i = CONTENT_SANDSTONE;
 239         f = nodemgr->getModifiable(i);
 240         f->setAllTextures("sandstone.png");
 241         f->setInventoryTextureCube("sandstone.png", "sandstone.png", "sandstone.png");
 242         f->param_type = CPT_MINERAL;
 243         f->is_ground_content = true;
 244         f->dug_item = std::string("MaterialItem2 ")+itos(CONTENT_SAND)+" 1";
 245         setDirtLikeMaterialProperties(f->material, 1.0);
 246
 247         i = CONTENT_CLAY;
 248         f = nodemgr->getModifiable(i);
 249         f->setAllTextures("clay.png");
 250         f->setInventoryTextureCube("clay.png", "clay.png", "clay.png");
 251         f->param_type = CPT_MINERAL;
 252         f->is_ground_content = true;
 253         f->dug_item = std::string("CraftItem lump_of_clay 4");
 254         setDirtLikeMaterialProperties(f->material, 1.0);
 255
 256         i = CONTENT_BRICK;
 257         f = nodemgr->getModifiable(i);
 258         f->setAllTextures("brick.png");
 259         f->setInventoryTextureCube("brick.png", "brick.png", "brick.png");
 260         f->param_type = CPT_MINERAL;
 261         f->is_ground_content = true;
 262         f->dug_item = std::string("CraftItem clay_brick 4");
 263         setStoneLikeMaterialProperties(f->material, 1.0);
 264
 265         i = CONTENT_TREE;
 266         f = nodemgr->getModifiable(i);
 267         f->setAllTextures("tree.png");
 268         f->setTexture(0, "tree_top.png");
 269         f->setTexture(1, "tree_top.png");
 270         f->param_type = CPT_MINERAL;
 271         f->is_ground_content = true;
 272         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 273         setWoodLikeMaterialProperties(f->material, 1.0);
 274
 275         i = CONTENT_JUNGLETREE;
 276         f = nodemgr->getModifiable(i);
 277         f->setAllTextures("jungletree.png");
 278         f->setTexture(0, "jungletree_top.png");
 279         f->setTexture(1, "jungletree_top.png");
 280         f->param_type = CPT_MINERAL;
 281         //f->is_ground_content = true;
 282         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 283         setWoodLikeMaterialProperties(f->material, 1.0);
 284
 285         i = CONTENT_JUNGLEGRASS;
 286         f = nodemgr->getModifiable(i);
 287         f->setInventoryTexture("junglegrass.png");
 288         f->used_texturenames.insert("junglegrass.png"); // Add to atlas
 289         f->light_propagates = true;
 290         f->param_type = CPT_LIGHT;
 291         //f->is_ground_content = true;
 292         f->air_equivalent = false; // grass grows underneath
 293         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 294         f->solidness = 0; // drawn separately, makes no faces
 295         f->walkable = false;
 296         setLeavesLikeMaterialProperties(f->material, 1.0);
 297
 298         i = CONTENT_LEAVES;
 299         f = nodemgr->getModifiable(i);
 300         f->light_propagates = true;
 301         //f->param_type = CPT_MINERAL;
 302         f->param_type = CPT_LIGHT;
 303         //f->is_ground_content = true;
 304         if(new_style_leaves)
 305         {
 306                 f->solidness = 0; // drawn separately, makes no faces
 307                 f->visual_solidness = 1;
 308                 f->setAllTextures("leaves.png");
 309                 f->setInventoryTextureCube("leaves.png", "leaves.png", "leaves.png");
 310         }
 311         else
 312         {
 313                 f->setAllTextures("[noalpha:leaves.png");
 314         }
 315         f->extra_dug_item = std::string("MaterialItem2 ")+itos(CONTENT_SAPLING)+" 1";
 316         f->extra_dug_item_rarity = 20;
 317         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 318         setLeavesLikeMaterialProperties(f->material, 1.0);
 319
 320         i = CONTENT_CACTUS;
 321         f = nodemgr->getModifiable(i);
 322         f->setAllTextures("cactus_side.png");
 323         f->setTexture(0, "cactus_top.png");
 324         f->setTexture(1, "cactus_top.png");
 325         f->setInventoryTextureCube("cactus_top.png", "cactus_side.png", "cactus_side.png");
 326         f->param_type = CPT_MINERAL;
 327         f->is_ground_content = true;
 328         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 329         setWoodLikeMaterialProperties(f->material, 0.75);
 330
 331         i = CONTENT_PAPYRUS;
 332         f = nodemgr->getModifiable(i);
 333         f->setInventoryTexture("papyrus.png");
 334         f->used_texturenames.insert("papyrus.png"); // Add to atlas
 335         f->light_propagates = true;
 336         f->param_type = CPT_LIGHT;
 337         f->is_ground_content = true;
 338         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 339         f->solidness = 0; // drawn separately, makes no faces
 340         f->walkable = false;
 341         setLeavesLikeMaterialProperties(f->material, 0.5);
 342
 343         i = CONTENT_BOOKSHELF;
 344         f = nodemgr->getModifiable(i);
 345         f->setAllTextures("bookshelf.png");
 346         f->setTexture(0, "wood.png");
 347         f->setTexture(1, "wood.png");
 348         // FIXME: setInventoryTextureCube() only cares for the first texture
 349         f->setInventoryTextureCube("bookshelf.png", "bookshelf.png", "bookshelf.png");
 350         //f->setInventoryTextureCube("wood.png", "bookshelf.png", "bookshelf.png");
 351         f->param_type = CPT_MINERAL;
 352         f->is_ground_content = true;
 353         setWoodLikeMaterialProperties(f->material, 0.75);
 354
 355         i = CONTENT_GLASS;
 356         f = nodemgr->getModifiable(i);
 357         f->light_propagates = true;
 358         f->sunlight_propagates = true;
 359         f->param_type = CPT_LIGHT;
 360         f->is_ground_content = true;
 361         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 362         f->solidness = 0; // drawn separately, makes no faces
 363         f->visual_solidness = 1;
 364         f->setAllTextures("glass.png");
 365         f->setInventoryTextureCube("glass.png", "glass.png", "glass.png");
 366         setGlassLikeMaterialProperties(f->material, 1.0);
 367
 368         i = CONTENT_FENCE;
 369         f = nodemgr->getModifiable(i);
 370         f->light_propagates = true;
 371         f->param_type = CPT_LIGHT;
 372         f->is_ground_content = true;
 373         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 374         f->solidness = 0; // drawn separately, makes no faces
 375         f->air_equivalent = true; // grass grows underneath
 376         f->setInventoryTexture("fence.png");
 377         f->used_texturenames.insert("fence.png"); // Add to atlas
 378         f->selection_box.type = NODEBOX_FIXED;
 379         f->selection_box.fixed = core::aabbox3d<f32>(
 380                         -BS/7, -BS/2, -BS/7, BS/7, BS/2, BS/7);
 381         setWoodLikeMaterialProperties(f->material, 0.75);
 382
 383         i = CONTENT_RAIL;
 384         f = nodemgr->getModifiable(i);
 385         f->setInventoryTexture("rail.png");
 386         f->used_texturenames.insert("rail.png"); // Add to atlas
 387         f->light_propagates = true;
 388         f->param_type = CPT_LIGHT;
 389         f->is_ground_content = true;
 390         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 391         f->solidness = 0; // drawn separately, makes no faces
 392         f->air_equivalent = true; // grass grows underneath
 393         f->walkable = false;
 394         f->selection_box.type = NODEBOX_FIXED;
 395         setDirtLikeMaterialProperties(f->material, 0.75);
 396
 397         i = CONTENT_LADDER;
 398         f = nodemgr->getModifiable(i);
 399         f->setInventoryTexture("ladder.png");
 400         f->used_texturenames.insert("ladder.png"); // Add to atlas
 401         f->light_propagates = true;
 402         f->param_type = CPT_LIGHT;
 403         f->is_ground_content = true;
 404         f->dug_item = std::string("MaterialItem ")+itos(i)+" 1";
 405         f->wall_mounted = true;
 406         f->solidness = 0;
 407         f->air_equivalent = true;
 408         f->walkable = false;
 409         f->climbable = true;
 410         f->selection_box.type = NODEBOX_WALLMOUNTED;
 411         setWoodLikeMaterialProperties(f->material, 0.5);
 412
 413         // Deprecated
 414         i = CONTENT_COALSTONE;
 415         f = nodemgr->getModifiable(i);
 416         f->setAllTextures("stone.png^mineral_coal.png");
 417         f->is_ground_content = true;
 418         setStoneLikeMaterialProperties(f->material, 1.5);
 419
 420         i = CONTENT_WOOD;
 421         f = nodemgr->getModifiable(i);
 422         f->setAllTextures("wood.png");
 423         f->setInventoryTextureCube("wood.png", "wood.png", "wood.png");
 424         f->is_ground_content = true;
 425         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 426         setWoodLikeMaterialProperties(f->material, 0.75);
 427
 428         i = CONTENT_MESE;
 429         f = nodemgr->getModifiable(i);
 430         f->setAllTextures("mese.png");
 431         f->setInventoryTextureCube("mese.png", "mese.png", "mese.png");
 432         f->is_ground_content = true;
 433         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 434         setStoneLikeMaterialProperties(f->material, 0.5);
 435
 436         i = CONTENT_CLOUD;
 437         f = nodemgr->getModifiable(i);
 438         f->setAllTextures("cloud.png");
 439         f->setInventoryTextureCube("cloud.png", "cloud.png", "cloud.png");
 440         f->is_ground_content = true;
 441         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 442
 443         i = CONTENT_AIR;
 444         f = nodemgr->getModifiable(i);
 445         f->param_type = CPT_LIGHT;
 446         f->light_propagates = true;
 447         f->sunlight_propagates = true;
 448         f->solidness = 0;
 449         f->walkable = false;
 450         f->pointable = false;
 451         f->diggable = false;
 452         f->buildable_to = true;
 453         f->air_equivalent = true;
 454
 455         i = CONTENT_WATER;
 456         f = nodemgr->getModifiable(i);
 457         f->setInventoryTextureCube("water.png", "water.png", "water.png");
 458         f->param_type = CPT_LIGHT;
 459         f->light_propagates = true;
 460         f->solidness = 0; // Drawn separately, makes no faces
 461         f->visual_solidness = 1;
 462         f->walkable = false;
 463         f->pointable = false;
 464         f->diggable = false;
 465         f->buildable_to = true;
 466         f->liquid_type = LIQUID_FLOWING;
 467         f->liquid_alternative_flowing = CONTENT_WATER;
 468         f->liquid_alternative_source = CONTENT_WATERSOURCE;
 469         f->liquid_viscosity = WATER_VISC;
 470         if(!opaque_water)
 471                 f->alpha = WATER_ALPHA;
 472         f->post_effect_color = video::SColor(64, 100, 100, 200);
 473         // Flowing water material
 474         f->mspec_special[0].tname = "water.png";
 475         f->mspec_special[0].backface_culling = false;
 476         f->mspec_special[1].tname = "water.png";
 477         f->mspec_special[1].backface_culling = true;
 478
 479 /*#ifndef SERVER
 480         if(f->special_material == NULL && tsrc)
 481         {
 482                 f->special_material = new video::SMaterial;
 483                 f->special_material->setFlag(video::EMF_LIGHTING, false);
 484                 f->special_material->setFlag(video::EMF_BACK_FACE_CULLING, false);
 485                 f->special_material->setFlag(video::EMF_BILINEAR_FILTER, false);
 486                 f->special_material->setFlag(video::EMF_FOG_ENABLE, true);
 487                 if(!opaque_water)
 488                         f->special_material->MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
 489                 AtlasPointer *pa_water1 = new AtlasPointer(tsrc->getTexture(
 490                                 tsrc->getTextureId("water.png")));
 491                 f->special_material->setTexture(0, pa_water1->atlas);
 492
 493                 // Flowing water material, backface culled
 494                 f->special_material2 = new video::SMaterial;
 495                 *f->special_material2 = *f->special_material;
 496                 f->special_material2->setFlag(video::EMF_BACK_FACE_CULLING, true);
 497
 498                 f->special_atlas = pa_water1;
 499         }
 500 #endif*/
 501
 502         i = CONTENT_WATERSOURCE;
 503         f = nodemgr->getModifiable(i);
 504         if(new_style_water)
 505         {
 506                 f->solidness = 0; // drawn separately, makes no faces
 507         }
 508         else // old style
 509         {
 510                 f->solidness = 1;
 511                 f->setAllTextures("water.png", WATER_ALPHA);
 512                 f->backface_culling = false;
 513         }
 514         //f->setInventoryTexture("water.png");
 515         f->setInventoryTextureCube("water.png", "water.png", "water.png");
 516         f->param_type = CPT_LIGHT;
 517         f->light_propagates = true;
 518         f->walkable = false;
 519         f->pointable = false;
 520         f->diggable = false;
 521         f->buildable_to = true;
 522         f->liquid_type = LIQUID_SOURCE;
 523         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 524         f->liquid_alternative_flowing = CONTENT_WATER;
 525         f->liquid_alternative_source = CONTENT_WATERSOURCE;
 526         f->liquid_viscosity = WATER_VISC;
 527         if(!opaque_water)
 528                 f->alpha = WATER_ALPHA;
 529         f->post_effect_color = video::SColor(64, 100, 100, 200);
 530         // New-style water source material (mostly unused)
 531         f->mspec_special[0].tname = "water.png";
 532         f->mspec_special[0].backface_culling = false;
 533 /*#ifndef SERVER
 534         if(f->special_material == NULL && tsrc)
 535         {
 536                 f->special_material = new video::SMaterial;
 537                 f->special_material->setFlag(video::EMF_LIGHTING, false);
 538                 f->special_material->setFlag(video::EMF_BACK_FACE_CULLING, false);
 539                 f->special_material->setFlag(video::EMF_BILINEAR_FILTER, false);
 540                 f->special_material->setFlag(video::EMF_FOG_ENABLE, true);
 541                 f->special_material->MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
 542                 AtlasPointer *pa_water1 = new AtlasPointer(tsrc->getTexture(
 543                                 tsrc->getTextureId("water.png")));
 544                 f->special_material->setTexture(0, pa_water1->atlas);
 545                 f->special_atlas = pa_water1;
 546         }
 547 #endif*/
 548
 549         i = CONTENT_LAVA;
 550         f = nodemgr->getModifiable(i);
 551         f->setInventoryTextureCube("lava.png", "lava.png", "lava.png");
 552         f->used_texturenames.insert("lava.png"); // Add to atlas
 553         f->param_type = CPT_LIGHT;
 554         f->light_propagates = false;
 555         f->light_source = LIGHT_MAX-1;
 556         f->solidness = 0; // Drawn separately, makes no faces
 557         f->visual_solidness = 1; // Does not completely cover block boundaries
 558         f->walkable = false;
 559         f->pointable = false;
 560         f->diggable = false;
 561         f->buildable_to = true;
 562         f->liquid_type = LIQUID_FLOWING;
 563         f->liquid_alternative_flowing = CONTENT_LAVA;
 564         f->liquid_alternative_source = CONTENT_LAVASOURCE;
 565         f->liquid_viscosity = LAVA_VISC;
 566         f->damage_per_second = 4*2;
 567         f->post_effect_color = video::SColor(192, 255, 64, 0);
 568         // Flowing lava material
 569         f->mspec_special[0].tname = "lava.png";
 570         f->mspec_special[0].backface_culling = false;
 571         f->mspec_special[1].tname = "lava.png";
 572         f->mspec_special[1].backface_culling = true;
 573 /*#ifndef SERVER
 574         if(f->special_material == NULL && tsrc)
 575         {
 576         }
 577 #endif*/
 578
 579         i = CONTENT_LAVASOURCE;
 580         f = nodemgr->getModifiable(i);
 581         f->used_texturenames.insert("ladder.png"); // Add to atlas
 582         if(new_style_water)
 583         {
 584                 f->solidness = 0; // drawn separately, makes no faces
 585         }
 586         else // old style
 587         {
 588                 f->solidness = 2;
 589                 f->setAllTextures("lava.png");
 590         }
 591         f->setInventoryTextureCube("lava.png", "lava.png", "lava.png");
 592         f->param_type = CPT_LIGHT;
 593         f->light_propagates = false;
 594         f->light_source = LIGHT_MAX-1;
 595         f->walkable = false;
 596         f->pointable = false;
 597         f->diggable = false;
 598         f->buildable_to = true;
 599         f->liquid_type = LIQUID_SOURCE;
 600         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 601         f->liquid_alternative_flowing = CONTENT_LAVA;
 602         f->liquid_alternative_source = CONTENT_LAVASOURCE;
 603         f->liquid_viscosity = LAVA_VISC;
 604         f->damage_per_second = 4*2;
 605         f->post_effect_color = video::SColor(192, 255, 64, 0);
 606         // New-style lava source material (mostly unused)
 607         f->mspec_special[0].tname = "lava.png";
 608         f->mspec_special[0].backface_culling = false;
 609 /*#ifndef SERVER
 610         if(f->special_material == NULL && tsrc)
 611         {
 612         }
 613 #endif*/
 614
 615         i = CONTENT_TORCH;
 616         f = nodemgr->getModifiable(i);
 617         f->setInventoryTexture("torch_on_floor.png");
 618         f->used_texturenames.insert("torch_on_floor.png"); // Add to atlas
 619         f->used_texturenames.insert("torch_on_ceiling.png"); // Add to atlas
 620         f->used_texturenames.insert("torch.png"); // Add to atlas
 621         f->param_type = CPT_LIGHT;
 622         f->light_propagates = true;
 623         f->sunlight_propagates = true;
 624         f->solidness = 0; // drawn separately, makes no faces
 625         f->walkable = false;
 626         f->wall_mounted = true;
 627         f->air_equivalent = true;
 628         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 629         f->light_source = LIGHT_MAX-1;
 630         f->selection_box.type = NODEBOX_WALLMOUNTED;
 631         f->selection_box.wall_top = core::aabbox3d<f32>(
 632                         -BS/10, BS/2-BS/3.333*2, -BS/10, BS/10, BS/2, BS/10);
 633         f->selection_box.wall_bottom = core::aabbox3d<f32>(
 634                         -BS/10, -BS/2, -BS/10, BS/10, -BS/2+BS/3.333*2, BS/10);
 635         f->selection_box.wall_side = core::aabbox3d<f32>(
 636                         -BS/2, -BS/3.333, -BS/10, -BS/2+BS/3.333, BS/3.333, BS/10);
 637         setConstantMaterialProperties(f->material, 0.0);
 638
 639         i = CONTENT_SIGN_WALL;
 640         f = nodemgr->getModifiable(i);
 641         f->setInventoryTexture("sign_wall.png");
 642         f->used_texturenames.insert("sign_wall.png"); // Add to atlas
 643         f->param_type = CPT_LIGHT;
 644         f->light_propagates = true;
 645         f->sunlight_propagates = true;
 646         f->solidness = 0; // drawn separately, makes no faces
 647         f->walkable = false;
 648         f->wall_mounted = true;
 649         f->air_equivalent = true;
 650         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 651         if(f->initial_metadata == NULL)
 652                 f->initial_metadata = new SignNodeMetadata(NULL, "Some sign");
 653         setConstantMaterialProperties(f->material, 0.5);
 654         f->selection_box.type = NODEBOX_WALLMOUNTED;
 655
 656         i = CONTENT_CHEST;
 657         f = nodemgr->getModifiable(i);
 658         f->param_type = CPT_FACEDIR_SIMPLE;
 659         f->setAllTextures("chest_side.png");
 660         f->setTexture(0, "chest_top.png");
 661         f->setTexture(1, "chest_top.png");
 662         f->setTexture(5, "chest_front.png"); // Z-
 663         f->setInventoryTexture("chest_top.png");
 664         //f->setInventoryTextureCube("chest_top.png", "chest_side.png", "chest_side.png");
 665         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 666         if(f->initial_metadata == NULL)
 667                 f->initial_metadata = new ChestNodeMetadata(NULL);
 668         setWoodLikeMaterialProperties(f->material, 1.0);
 669
 670         i = CONTENT_LOCKABLE_CHEST;
 671         f = nodemgr->getModifiable(i);
 672         f->param_type = CPT_FACEDIR_SIMPLE;
 673         f->setAllTextures("chest_side.png");
 674         f->setTexture(0, "chest_top.png");
 675         f->setTexture(1, "chest_top.png");
 676         f->setTexture(5, "chest_lock.png"); // Z-
 677         f->setInventoryTexture("chest_lock.png");
 678         //f->setInventoryTextureCube("chest_top.png", "chest_side.png", "chest_side.png");
 679         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 680         if(f->initial_metadata == NULL)
 681                 f->initial_metadata = new LockingChestNodeMetadata(NULL);
 682         setWoodLikeMaterialProperties(f->material, 1.0);
 683
 684         i = CONTENT_FURNACE;
 685         f = nodemgr->getModifiable(i);
 686         f->param_type = CPT_FACEDIR_SIMPLE;
 687         f->setAllTextures("furnace_side.png");
 688         f->setTexture(5, "furnace_front.png"); // Z-
 689         f->setInventoryTexture("furnace_front.png");
 690         //f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 691         f->dug_item = std::string("MaterialItem2 ")+itos(CONTENT_COBBLE)+" 6";
 692         if(f->initial_metadata == NULL)
 693                 f->initial_metadata = new FurnaceNodeMetadata(NULL);
 694         setStoneLikeMaterialProperties(f->material, 3.0);
 695
 696         i = CONTENT_COBBLE;
 697         f = nodemgr->getModifiable(i);
 698         f->setAllTextures("cobble.png");
 699         f->setInventoryTextureCube("cobble.png", "cobble.png", "cobble.png");
 700         f->param_type = CPT_NONE;
 701         f->is_ground_content = true;
 702         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 703         setStoneLikeMaterialProperties(f->material, 0.9);
 704
 705         i = CONTENT_MOSSYCOBBLE;
 706         f = nodemgr->getModifiable(i);
 707         f->setAllTextures("mossycobble.png");
 708         f->setInventoryTextureCube("mossycobble.png", "mossycobble.png", "mossycobble.png");
 709         f->param_type = CPT_NONE;
 710         f->is_ground_content = true;
 711         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 712         setStoneLikeMaterialProperties(f->material, 0.8);
 713
 714         i = CONTENT_STEEL;
 715         f = nodemgr->getModifiable(i);
 716         f->setAllTextures("steel_block.png");
 717         f->setInventoryTextureCube("steel_block.png", "steel_block.png",
 718                         "steel_block.png");
 719         f->param_type = CPT_NONE;
 720         f->is_ground_content = true;
 721         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 722         setStoneLikeMaterialProperties(f->material, 5.0);
 723
 724         i = CONTENT_NC;
 725         f = nodemgr->getModifiable(i);
 726         f->param_type = CPT_FACEDIR_SIMPLE;
 727         f->setAllTextures("nc_side.png");
 728         f->setTexture(5, "nc_front.png"); // Z-
 729         f->setTexture(4, "nc_back.png"); // Z+
 730         f->setInventoryTexture("nc_front.png");
 731         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 732         setStoneLikeMaterialProperties(f->material, 3.0);
 733
 734         i = CONTENT_NC_RB;
 735         f = nodemgr->getModifiable(i);
 736         f->setAllTextures("nc_rb.png");
 737         f->setInventoryTexture("nc_rb.png");
 738         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 739         setStoneLikeMaterialProperties(f->material, 3.0);
 740
 741         i = CONTENT_SAPLING;
 742         f = nodemgr->getModifiable(i);
 743         f->param_type = CPT_LIGHT;
 744         f->setAllTextures("sapling.png");
 745         f->setInventoryTexture("sapling.png");
 746         f->used_texturenames.insert("sapling.png"); // Add to atlas
 747         f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
 748         f->light_propagates = true;
 749         f->air_equivalent = false;
 750         f->solidness = 0; // drawn separately, makes no faces
 751         f->walkable = false;
 752         setConstantMaterialProperties(f->material, 0.0);
 753
 754         i = CONTENT_APPLE;
 755         f = nodemgr->getModifiable(i);
 756         f->setInventoryTexture("apple.png");
 757         f->used_texturenames.insert("apple.png"); // Add to atlas
 758         f->param_type = CPT_LIGHT;
 759         f->light_propagates = true;
 760         f->sunlight_propagates = true;
 761         f->solidness = 0; // drawn separately, makes no faces
 762         f->walkable = false;
 763         f->air_equivalent = true;
 764         f->dug_item = std::string("CraftItem apple 1");
 765         setConstantMaterialProperties(f->material, 0.0);
 766 }
 767
 768