2010-12-13 18:59:56 -05:00
|
|
|
/*
|
|
|
|
Minetest-c55
|
|
|
|
Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2011-02-09 19:13:03 -05:00
|
|
|
#include "common_irrlicht.h"
|
2010-12-13 18:59:56 -05:00
|
|
|
#include "mapnode.h"
|
|
|
|
#include "tile.h"
|
2011-01-07 12:39:27 -05:00
|
|
|
#include "porting.h"
|
|
|
|
#include <string>
|
2011-01-25 17:41:06 -05:00
|
|
|
#include "mineral.h"
|
2011-02-03 18:48:52 -05:00
|
|
|
// For g_settings
|
|
|
|
#include "main.h"
|
2011-06-17 15:20:15 -04:00
|
|
|
#include "content_mapnode.h"
|
2011-04-04 19:56:29 -04:00
|
|
|
#include "nodemetadata.h"
|
2010-12-13 18:59:56 -05:00
|
|
|
|
2011-01-25 17:41:06 -05:00
|
|
|
ContentFeatures::~ContentFeatures()
|
2010-12-13 18:59:56 -05:00
|
|
|
{
|
2011-05-21 07:28:13 -04:00
|
|
|
if(initial_metadata)
|
|
|
|
delete initial_metadata;
|
2011-01-25 17:41:06 -05:00
|
|
|
}
|
2010-12-13 18:59:56 -05:00
|
|
|
|
2011-02-09 19:13:03 -05:00
|
|
|
void ContentFeatures::setTexture(u16 i, std::string name, u8 alpha)
|
|
|
|
{
|
|
|
|
if(g_texturesource)
|
|
|
|
{
|
|
|
|
tiles[i].texture = g_texturesource->getTexture(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(alpha != 255)
|
|
|
|
{
|
|
|
|
tiles[i].alpha = alpha;
|
|
|
|
tiles[i].material_type = MATERIAL_ALPHA_VERTEX;
|
|
|
|
}
|
2011-02-11 09:43:26 -05:00
|
|
|
|
|
|
|
if(inventory_texture == NULL)
|
|
|
|
setInventoryTexture(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ContentFeatures::setInventoryTexture(std::string imgname)
|
|
|
|
{
|
|
|
|
if(g_texturesource == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
imgname += "^[forcesingle";
|
|
|
|
|
|
|
|
inventory_texture = g_texturesource->getTextureRaw(imgname);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ContentFeatures::setInventoryTextureCube(std::string top,
|
|
|
|
std::string left, std::string right)
|
|
|
|
{
|
|
|
|
if(g_texturesource == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
str_replace_char(top, '^', '&');
|
|
|
|
str_replace_char(left, '^', '&');
|
|
|
|
str_replace_char(right, '^', '&');
|
|
|
|
|
|
|
|
std::string imgname_full;
|
|
|
|
imgname_full += "[inventorycube{";
|
|
|
|
imgname_full += top;
|
|
|
|
imgname_full += "{";
|
|
|
|
imgname_full += left;
|
|
|
|
imgname_full += "{";
|
|
|
|
imgname_full += right;
|
|
|
|
inventory_texture = g_texturesource->getTextureRaw(imgname_full);
|
2011-02-09 19:13:03 -05:00
|
|
|
}
|
|
|
|
|
2011-07-23 09:55:26 -04:00
|
|
|
struct ContentFeatures g_content_features[MAX_CONTENT+1];
|
2011-01-25 17:41:06 -05:00
|
|
|
|
2011-07-23 09:55:26 -04:00
|
|
|
ContentFeatures & content_features(content_t i)
|
2011-01-27 18:38:16 -05:00
|
|
|
{
|
|
|
|
return g_content_features[i];
|
|
|
|
}
|
2011-07-23 09:55:26 -04:00
|
|
|
ContentFeatures & content_features(MapNode &n)
|
|
|
|
{
|
|
|
|
return content_features(n.getContent());
|
|
|
|
}
|
2011-01-27 18:38:16 -05:00
|
|
|
|
2011-02-11 09:43:26 -05:00
|
|
|
/*
|
|
|
|
See mapnode.h for description.
|
|
|
|
*/
|
|
|
|
void init_mapnode()
|
2011-01-25 17:41:06 -05:00
|
|
|
{
|
2011-02-11 09:43:26 -05:00
|
|
|
if(g_texturesource == NULL)
|
|
|
|
{
|
|
|
|
dstream<<"INFO: Initial run of init_mapnode with "
|
|
|
|
"g_texturesource=NULL. If this segfaults, "
|
|
|
|
"there is a bug with something not checking for "
|
|
|
|
"the NULL value."<<std::endl;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dstream<<"INFO: Full run of init_mapnode with "
|
|
|
|
"g_texturesource!=NULL"<<std::endl;
|
|
|
|
}
|
|
|
|
|
2011-06-17 15:20:15 -04:00
|
|
|
/*// Read some settings
|
2011-02-07 18:12:55 -05:00
|
|
|
bool new_style_water = g_settings.getBool("new_style_water");
|
2011-06-17 15:20:15 -04:00
|
|
|
bool new_style_leaves = g_settings.getBool("new_style_leaves");*/
|
2011-02-09 19:13:03 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
Initialize content feature table
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
Set initial material type to same in all tiles, so that the
|
|
|
|
same material can be used in more stuff.
|
|
|
|
This is set according to the leaves because they are the only
|
|
|
|
differing material to which all materials can be changed to
|
|
|
|
get this optimization.
|
|
|
|
*/
|
|
|
|
u8 initial_material_type = MATERIAL_ALPHA_SIMPLE;
|
|
|
|
/*if(new_style_leaves)
|
|
|
|
initial_material_type = MATERIAL_ALPHA_SIMPLE;
|
|
|
|
else
|
|
|
|
initial_material_type = MATERIAL_ALPHA_NONE;*/
|
2011-07-23 09:55:26 -04:00
|
|
|
for(u16 i=0; i<MAX_CONTENT+1; i++)
|
2011-02-09 19:13:03 -05:00
|
|
|
{
|
|
|
|
ContentFeatures *f = &g_content_features[i];
|
2011-04-24 08:37:41 -04:00
|
|
|
// Re-initialize
|
2011-06-17 15:20:15 -04:00
|
|
|
f->reset();
|
2011-04-24 08:37:41 -04:00
|
|
|
|
2011-02-09 19:13:03 -05:00
|
|
|
for(u16 j=0; j<6; j++)
|
|
|
|
f->tiles[j].material_type = initial_material_type;
|
|
|
|
}
|
|
|
|
|
2011-06-27 00:30:02 -04:00
|
|
|
/*
|
|
|
|
Initially set every block to be shown as an unknown block.
|
|
|
|
Don't touch CONTENT_IGNORE or CONTENT_AIR.
|
|
|
|
*/
|
2011-07-23 09:55:26 -04:00
|
|
|
for(u16 i=0; i<MAX_CONTENT+1; i++)
|
2011-06-27 00:30:02 -04:00
|
|
|
{
|
2011-07-21 18:37:21 -04:00
|
|
|
if(i == CONTENT_IGNORE || i == CONTENT_AIR)
|
|
|
|
continue;
|
2011-06-27 00:30:02 -04:00
|
|
|
ContentFeatures *f = &g_content_features[i];
|
|
|
|
f->setAllTextures("unknown_block.png");
|
2011-07-30 19:20:40 -04:00
|
|
|
f->dug_item = std::string("MaterialItem2 ")+itos(i)+" 1";
|
2011-06-27 00:30:02 -04:00
|
|
|
}
|
|
|
|
|
2011-06-17 15:20:15 -04:00
|
|
|
/*
|
|
|
|
Initialize mapnode content
|
|
|
|
*/
|
|
|
|
content_mapnode_init();
|
2011-04-05 11:23:30 -04:00
|
|
|
|
2011-04-04 04:18:14 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
v3s16 facedir_rotate(u8 facedir, v3s16 dir)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
Face 2 (normally Z-) direction:
|
|
|
|
facedir=0: Z-
|
|
|
|
facedir=1: X-
|
|
|
|
facedir=2: Z+
|
|
|
|
facedir=3: X+
|
|
|
|
*/
|
|
|
|
v3s16 newdir;
|
|
|
|
if(facedir==0) // Same
|
|
|
|
newdir = v3s16(dir.X, dir.Y, dir.Z);
|
|
|
|
else if(facedir == 1) // Face is taken from rotXZccv(-90)
|
|
|
|
newdir = v3s16(-dir.Z, dir.Y, dir.X);
|
|
|
|
else if(facedir == 2) // Face is taken from rotXZccv(180)
|
|
|
|
newdir = v3s16(-dir.X, dir.Y, -dir.Z);
|
|
|
|
else if(facedir == 3) // Face is taken from rotXZccv(90)
|
|
|
|
newdir = v3s16(dir.Z, dir.Y, -dir.X);
|
|
|
|
else
|
|
|
|
newdir = dir;
|
|
|
|
return newdir;
|
2011-01-25 17:41:06 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TileSpec MapNode::getTile(v3s16 dir)
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
if(content_features(*this).param_type == CPT_FACEDIR_SIMPLE)
|
2011-04-04 04:18:14 -04:00
|
|
|
dir = facedir_rotate(param1, dir);
|
|
|
|
|
2011-01-25 17:41:06 -05:00
|
|
|
TileSpec spec;
|
|
|
|
|
|
|
|
s32 dir_i = -1;
|
|
|
|
|
2011-01-26 10:13:19 -05:00
|
|
|
if(dir == v3s16(0,0,0))
|
|
|
|
dir_i = -1;
|
|
|
|
else if(dir == v3s16(0,1,0))
|
2011-01-25 17:41:06 -05:00
|
|
|
dir_i = 0;
|
|
|
|
else if(dir == v3s16(0,-1,0))
|
|
|
|
dir_i = 1;
|
|
|
|
else if(dir == v3s16(1,0,0))
|
|
|
|
dir_i = 2;
|
|
|
|
else if(dir == v3s16(-1,0,0))
|
|
|
|
dir_i = 3;
|
|
|
|
else if(dir == v3s16(0,0,1))
|
|
|
|
dir_i = 4;
|
|
|
|
else if(dir == v3s16(0,0,-1))
|
|
|
|
dir_i = 5;
|
|
|
|
|
|
|
|
if(dir_i == -1)
|
|
|
|
// Non-directional
|
2011-07-23 09:55:26 -04:00
|
|
|
spec = content_features(*this).tiles[0];
|
2011-01-25 17:41:06 -05:00
|
|
|
else
|
2011-07-23 09:55:26 -04:00
|
|
|
spec = content_features(*this).tiles[dir_i];
|
2011-01-25 17:41:06 -05:00
|
|
|
|
2011-02-09 19:13:03 -05:00
|
|
|
/*
|
|
|
|
If it contains some mineral, change texture id
|
|
|
|
*/
|
2011-07-23 09:55:26 -04:00
|
|
|
if(content_features(*this).param_type == CPT_MINERAL && g_texturesource)
|
2011-01-25 17:41:06 -05:00
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
u8 mineral = getMineral();
|
2011-02-09 19:13:03 -05:00
|
|
|
std::string mineral_texture_name = mineral_block_texture(mineral);
|
|
|
|
if(mineral_texture_name != "")
|
|
|
|
{
|
|
|
|
u32 orig_id = spec.texture.id;
|
|
|
|
std::string texture_name = g_texturesource->getTextureName(orig_id);
|
|
|
|
//texture_name += "^blit:";
|
|
|
|
texture_name += "^";
|
|
|
|
texture_name += mineral_texture_name;
|
|
|
|
u32 new_id = g_texturesource->getTextureId(texture_name);
|
|
|
|
spec.texture = g_texturesource->getTexture(new_id);
|
|
|
|
}
|
2011-01-25 17:41:06 -05:00
|
|
|
}
|
2011-01-07 12:39:27 -05:00
|
|
|
|
2011-01-25 17:41:06 -05:00
|
|
|
return spec;
|
|
|
|
}
|
|
|
|
|
|
|
|
u8 MapNode::getMineral()
|
2010-12-13 18:59:56 -05:00
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
if(content_features(*this).param_type == CPT_MINERAL)
|
2011-01-25 17:41:06 -05:00
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
return param1 & 0x0f;
|
2011-01-25 17:41:06 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return MINERAL_NONE;
|
|
|
|
}
|
|
|
|
|
2011-07-01 18:07:54 -04:00
|
|
|
u32 MapNode::serializedLength(u8 version)
|
|
|
|
{
|
|
|
|
if(!ser_ver_supported(version))
|
|
|
|
throw VersionMismatchException("ERROR: MapNode format not supported");
|
|
|
|
|
|
|
|
if(version == 0)
|
|
|
|
return 1;
|
|
|
|
else if(version <= 9)
|
|
|
|
return 2;
|
|
|
|
else
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
void MapNode::serialize(u8 *dest, u8 version)
|
|
|
|
{
|
|
|
|
if(!ser_ver_supported(version))
|
|
|
|
throw VersionMismatchException("ERROR: MapNode format not supported");
|
|
|
|
|
2011-07-23 09:55:26 -04:00
|
|
|
// Translate to wanted version
|
|
|
|
MapNode n_foreign = mapnode_translate_from_internal(*this, version);
|
2011-07-01 18:07:54 -04:00
|
|
|
|
2011-07-23 09:55:26 -04:00
|
|
|
u8 actual_param0 = n_foreign.param0;
|
|
|
|
|
|
|
|
// Convert special values from new version to old
|
2011-07-01 18:07:54 -04:00
|
|
|
if(version <= 18)
|
|
|
|
{
|
|
|
|
// In these versions, CONTENT_IGNORE and CONTENT_AIR
|
|
|
|
// are 255 and 254
|
2011-07-23 09:55:26 -04:00
|
|
|
if(actual_param0 == CONTENT_IGNORE)
|
|
|
|
actual_param0 = 255;
|
|
|
|
else if(actual_param0 == CONTENT_AIR)
|
|
|
|
actual_param0 = 254;
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if(version == 0)
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
dest[0] = actual_param0;
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
|
|
|
else if(version <= 9)
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
dest[0] = actual_param0;
|
|
|
|
dest[1] = n_foreign.param1;
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
dest[0] = actual_param0;
|
|
|
|
dest[1] = n_foreign.param1;
|
|
|
|
dest[2] = n_foreign.param2;
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
void MapNode::deSerialize(u8 *source, u8 version)
|
|
|
|
{
|
|
|
|
if(!ser_ver_supported(version))
|
|
|
|
throw VersionMismatchException("ERROR: MapNode format not supported");
|
|
|
|
|
|
|
|
if(version == 0)
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
param0 = source[0];
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
|
|
|
else if(version == 1)
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
param0 = source[0];
|
2011-07-01 18:07:54 -04:00
|
|
|
// This version doesn't support saved lighting
|
|
|
|
if(light_propagates() || light_source() > 0)
|
2011-07-23 09:55:26 -04:00
|
|
|
param1 = 0;
|
2011-07-01 18:07:54 -04:00
|
|
|
else
|
2011-07-23 09:55:26 -04:00
|
|
|
param1 = source[1];
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
|
|
|
else if(version <= 9)
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
param0 = source[0];
|
|
|
|
param1 = source[1];
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
param0 = source[0];
|
|
|
|
param1 = source[1];
|
2011-07-01 18:07:54 -04:00
|
|
|
param2 = source[2];
|
2011-07-22 11:51:49 -04:00
|
|
|
}
|
|
|
|
|
2011-07-23 09:55:26 -04:00
|
|
|
// Convert special values from old version to new
|
2011-07-22 11:51:49 -04:00
|
|
|
if(version <= 18)
|
|
|
|
{
|
|
|
|
// In these versions, CONTENT_IGNORE and CONTENT_AIR
|
|
|
|
// are 255 and 254
|
2011-07-23 09:55:26 -04:00
|
|
|
if(param0 == 255)
|
|
|
|
param0 = CONTENT_IGNORE;
|
|
|
|
else if(param0 == 254)
|
|
|
|
param0 = CONTENT_AIR;
|
2011-07-22 11:51:49 -04:00
|
|
|
}
|
|
|
|
// version 19 is fucked up with sometimes the old values and sometimes not
|
|
|
|
if(version == 19)
|
|
|
|
{
|
2011-07-23 09:55:26 -04:00
|
|
|
if(param0 == 255)
|
|
|
|
param0 = CONTENT_IGNORE;
|
|
|
|
else if(param0 == 254)
|
|
|
|
param0 = CONTENT_AIR;
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
2011-07-23 09:55:26 -04:00
|
|
|
|
|
|
|
// Translate to our known version
|
|
|
|
*this = mapnode_translate_to_internal(*this, version);
|
2011-07-01 18:07:54 -04:00
|
|
|
}
|
|
|
|
|
2011-06-17 16:20:31 -04:00
|
|
|
/*
|
|
|
|
Gets lighting value at face of node
|
|
|
|
|
|
|
|
Parameters must consist of air and !air.
|
|
|
|
Order doesn't matter.
|
|
|
|
|
|
|
|
If either of the nodes doesn't exist, light is 0.
|
|
|
|
|
|
|
|
parameters:
|
|
|
|
daynight_ratio: 0...1000
|
|
|
|
n: getNodeParent(p)
|
|
|
|
n2: getNodeParent(p + face_dir)
|
|
|
|
face_dir: axis oriented unit vector from p to p2
|
|
|
|
|
|
|
|
returns encoded light value.
|
|
|
|
*/
|
|
|
|
u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
|
|
|
|
v3s16 face_dir)
|
|
|
|
{
|
|
|
|
try{
|
|
|
|
u8 light;
|
|
|
|
u8 l1 = n.getLightBlend(daynight_ratio);
|
|
|
|
u8 l2 = n2.getLightBlend(daynight_ratio);
|
|
|
|
if(l1 > l2)
|
|
|
|
light = l1;
|
|
|
|
else
|
|
|
|
light = l2;
|
|
|
|
|
|
|
|
// Make some nice difference to different sides
|
|
|
|
|
|
|
|
// This makes light come from a corner
|
|
|
|
/*if(face_dir.X == 1 || face_dir.Z == 1 || face_dir.Y == -1)
|
|
|
|
light = diminish_light(diminish_light(light));
|
|
|
|
else if(face_dir.X == -1 || face_dir.Z == -1)
|
|
|
|
light = diminish_light(light);*/
|
|
|
|
|
|
|
|
// All neighboring faces have different shade (like in minecraft)
|
|
|
|
if(face_dir.X == 1 || face_dir.X == -1 || face_dir.Y == -1)
|
|
|
|
light = diminish_light(diminish_light(light));
|
|
|
|
else if(face_dir.Z == 1 || face_dir.Z == -1)
|
|
|
|
light = diminish_light(light);
|
|
|
|
|
|
|
|
return light;
|
|
|
|
}
|
|
|
|
catch(InvalidPositionException &e)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-07 12:39:27 -05:00
|
|
|
|