#include "common_irrlicht.h"
#include "mapnode.h"
-#include "tile.h"
#include "porting.h"
#include <string>
-#include "mineral.h"
-// For g_settings
-#include "main.h"
+#include "main.h" // For g_settings
+#include "nodedef.h"
+#include "content_mapnode.h" // For mapnode_translate_*_internal
+#include "serialization.h" // For ser_ver_supported
-ContentFeatures::~ContentFeatures()
+/*
+ MapNode
+*/
+
+// Create directly from a nodename
+// If name is unknown, sets CONTENT_IGNORE
+MapNode::MapNode(INodeDefManager *ndef, const std::string &name,
+ u8 a_param1, u8 a_param2)
{
- if(translate_to)
- delete translate_to;
+ content_t id = CONTENT_IGNORE;
+ ndef->getId(name, id);
+ param1 = a_param1;
+ param2 = a_param2;
+ // Set content (param0 and (param2&0xf0)) after other params
+ // because this needs to override part of param2
+ setContent(id);
}
-void ContentFeatures::setTexture(u16 i, std::string name, u8 alpha)
+void MapNode::setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr)
{
- if(g_texturesource)
+ // If node doesn't contain light data, ignore this
+ if(nodemgr->get(*this).param_type != CPT_LIGHT)
+ return;
+ if(bank == LIGHTBANK_DAY)
{
- tiles[i].texture = g_texturesource->getTexture(name);
+ param1 &= 0xf0;
+ param1 |= a_light & 0x0f;
}
-
- if(alpha != 255)
+ else if(bank == LIGHTBANK_NIGHT)
{
- tiles[i].alpha = alpha;
- tiles[i].material_type = MATERIAL_ALPHA_VERTEX;
+ param1 &= 0x0f;
+ param1 |= (a_light & 0x0f)<<4;
}
+ else
+ assert(0);
}
-struct ContentFeatures g_content_features[256];
+u8 MapNode::getLight(enum LightBank bank, INodeDefManager *nodemgr) const
+{
+ // Select the brightest of [light source, propagated light]
+ const ContentFeatures &f = nodemgr->get(*this);
+ u8 light = 0;
+ if(f.param_type == CPT_LIGHT)
+ {
+ if(bank == LIGHTBANK_DAY)
+ light = param1 & 0x0f;
+ else if(bank == LIGHTBANK_NIGHT)
+ light = (param1>>4)&0x0f;
+ else
+ assert(0);
+ }
+ if(f.light_source > light)
+ light = f.light_source;
+ return light;
+}
-ContentFeatures & content_features(u8 i)
+bool MapNode::getLightBanks(u8 &lightday, u8 &lightnight, INodeDefManager *nodemgr) const
{
- return g_content_features[i];
+ // Select the brightest of [light source, propagated light]
+ const ContentFeatures &f = nodemgr->get(*this);
+ if(f.param_type == CPT_LIGHT)
+ {
+ lightday = param1 & 0x0f;
+ lightnight = (param1>>4)&0x0f;
+ }
+ else
+ {
+ lightday = 0;
+ lightnight = 0;
+ }
+ if(f.light_source > lightday)
+ lightday = f.light_source;
+ if(f.light_source > lightnight)
+ lightnight = f.light_source;
+ return f.param_type == CPT_LIGHT || f.light_source != 0;
}
-void init_mapnode(IIrrlichtWrapper *irrlicht)
+u8 MapNode::getFaceDir(INodeDefManager *nodemgr) const
{
- // Read some settings
- bool new_style_water = g_settings.getBool("new_style_water");
- bool new_style_leaves = g_settings.getBool("new_style_leaves");
+ const ContentFeatures &f = nodemgr->get(*this);
+ if(f.param_type_2 == CPT2_FACEDIR)
+ return getParam2() & 0x03;
+ return 0;
+}
+
+u8 MapNode::getWallMounted(INodeDefManager *nodemgr) const
+{
+ const ContentFeatures &f = nodemgr->get(*this);
+ if(f.param_type_2 == CPT2_WALLMOUNTED)
+ return getParam2() & 0x07;
+ return 0;
+}
+
+v3s16 MapNode::getWallMountedDir(INodeDefManager *nodemgr) const
+{
+ switch(getWallMounted(nodemgr))
+ {
+ case 0: default: return v3s16(0,1,0);
+ case 1: return v3s16(0,-1,0);
+ case 2: return v3s16(1,0,0);
+ case 3: return v3s16(-1,0,0);
+ case 4: return v3s16(0,0,1);
+ case 5: return v3s16(0,0,-1);
+ }
+}
+
+
+
+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");
+
+ if(version <= 21)
+ {
+ serialize_pre22(dest, version);
+ return;
+ }
+
+ writeU8(dest+0, param0);
+ writeU8(dest+1, param1);
+ writeU8(dest+2, param2);
+}
+void MapNode::deSerialize(u8 *source, u8 version)
+{
+ if(!ser_ver_supported(version))
+ throw VersionMismatchException("ERROR: MapNode format not supported");
+
+ if(version <= 21)
+ {
+ deSerialize_pre22(source, version);
+ return;
+ }
+
+ param0 = readU8(source+0);
+ param1 = readU8(source+1);
+ param2 = readU8(source+2);
+}
+void MapNode::serializeBulk(std::ostream &os, int version,
+ const MapNode *nodes, u32 nodecount,
+ u8 content_width, u8 params_width, bool compressed)
+{
+ if(!ser_ver_supported(version))
+ throw VersionMismatchException("ERROR: MapNode format not supported");
+
+ assert(version >= 22);
+ assert(content_width == 1);
+ assert(params_width == 2);
+
+ SharedBuffer<u8> databuf(nodecount * (content_width + params_width));
+
+ // Serialize content
+ if(content_width == 1)
+ {
+ for(u32 i=0; i<nodecount; i++)
+ writeU8(&databuf[i], nodes[i].param0);
+ }
+ /* If param0 is extended to two bytes, use something like this: */
+ /*else if(content_width == 2)
+ {
+ for(u32 i=0; i<nodecount; i++)
+ writeU16(&databuf[i*2], nodes[i].param0);
+ }*/
+
+ // Serialize param1
+ u32 start1 = content_width * nodecount;
+ for(u32 i=0; i<nodecount; i++)
+ writeU8(&databuf[start1 + i], nodes[i].param1);
+
+ // Serialize param2
+ u32 start2 = (content_width + 1) * nodecount;
+ for(u32 i=0; i<nodecount; i++)
+ writeU8(&databuf[start2 + i], nodes[i].param2);
/*
- 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.
+ Compress data to output stream
*/
- u8 initial_material_type = MATERIAL_ALPHA_SIMPLE;
- /*if(new_style_leaves)
- initial_material_type = MATERIAL_ALPHA_SIMPLE;
+
+ if(compressed)
+ {
+ compressZlib(databuf, os);
+ }
else
- initial_material_type = MATERIAL_ALPHA_NONE;*/
- for(u16 i=0; i<256; i++)
{
- ContentFeatures *f = &g_content_features[i];
- for(u16 j=0; j<6; j++)
- f->tiles[j].material_type = initial_material_type;
+ os.write((const char*) &databuf[0], databuf.getSize());
}
-
- u8 i;
- ContentFeatures *f = NULL;
-
- i = CONTENT_STONE;
- f = &g_content_features[i];
- f->setAllTextures("stone.png");
- f->param_type = CPT_MINERAL;
- f->is_ground_content = true;
-
- i = CONTENT_GRASS;
- f = &g_content_features[i];
- f->setAllTextures("mud.png^grass_side.png");
- f->setTexture(0, "grass.png");
- f->setTexture(1, "mud.png");
- //f->setInventoryTexture(irrlicht->getTextureId("grass.png"));
- f->param_type = CPT_MINERAL;
- f->is_ground_content = true;
-
- i = CONTENT_GRASS_FOOTSTEPS;
- f = &g_content_features[i];
- //f->setInventoryTexture(irrlicht->getTextureId("grass_footsteps.png"));
- f->param_type = CPT_MINERAL;
- f->is_ground_content = true;
-
- i = CONTENT_MUD;
- f = &g_content_features[i];
- f->setAllTextures("mud.png");
- f->param_type = CPT_MINERAL;
- f->is_ground_content = true;
-
- i = CONTENT_SAND;
- f = &g_content_features[i];
- f->setAllTextures("sand.png");
- f->param_type = CPT_MINERAL;
- f->is_ground_content = true;
-
- i = CONTENT_TREE;
- f = &g_content_features[i];
- f->setAllTextures("tree.png");
- f->setTexture(0, "tree_top.png");
- f->setTexture(1, "tree_top.png");
- //f->setInventoryTexture(irrlicht->getTextureId("tree_top.png"));
- f->param_type = CPT_MINERAL;
- f->is_ground_content = true;
-
- i = CONTENT_LEAVES;
- f = &g_content_features[i];
- f->light_propagates = true;
- //f->param_type = CPT_MINERAL;
- f->param_type = CPT_LIGHT;
- f->is_ground_content = true;
- if(new_style_leaves)
+}
+
+// Deserialize bulk node data
+void MapNode::deSerializeBulk(std::istream &is, int version,
+ MapNode *nodes, u32 nodecount,
+ u8 content_width, u8 params_width, bool compressed)
+{
+ if(!ser_ver_supported(version))
+ throw VersionMismatchException("ERROR: MapNode format not supported");
+
+ assert(version >= 22);
+ assert(content_width == 1);
+ assert(params_width == 2);
+
+ // Uncompress or read data
+ u32 len = nodecount * (content_width + params_width);
+ SharedBuffer<u8> databuf(len);
+ if(compressed)
{
- f->solidness = 0; // drawn separately, makes no faces
+ std::ostringstream os(std::ios_base::binary);
+ decompressZlib(is, os);
+ std::string s = os.str();
+ if(s.size() != len)
+ throw SerializationError("deSerializeBulkNodes: "
+ "decompress resulted in invalid size");
+ memcpy(&databuf[0], s.c_str(), len);
}
else
{
- f->setAllTextures("[noalpha:leaves.png");
+ is.read((char*) &databuf[0], len);
+ if(is.eof() || is.fail())
+ throw SerializationError("deSerializeBulkNodes: "
+ "failed to read bulk node data");
}
-
- i = CONTENT_COALSTONE;
- f = &g_content_features[i];
- //f->translate_to = new MapNode(CONTENT_STONE, MINERAL_COAL);
- /*f->setAllTextures(TextureSpec(irrlicht->getTextureId("coal.png"),
- irrlicht->getTextureId("mineral_coal.png")));*/
- f->setAllTextures("stone.png^mineral_coal.png");
- f->is_ground_content = true;
-
- i = CONTENT_WOOD;
- f = &g_content_features[i];
- //f->setAllTextures(irrlicht->getTextureId("wood.png"));
- f->setAllTextures("wood.png");
- f->is_ground_content = true;
-
- i = CONTENT_MESE;
- f = &g_content_features[i];
- //f->setAllTextures(irrlicht->getTextureId("mese.png"));
- f->setAllTextures("mese.png");
- f->is_ground_content = true;
-
- i = CONTENT_CLOUD;
- f = &g_content_features[i];
- //f->setAllTextures(irrlicht->getTextureId("cloud.png"));
- f->setAllTextures("cloud.png");
- f->is_ground_content = true;
-
- i = CONTENT_AIR;
- f = &g_content_features[i];
- f->param_type = CPT_LIGHT;
- f->light_propagates = true;
- f->sunlight_propagates = true;
- f->solidness = 0;
- f->walkable = false;
- f->pointable = false;
- f->diggable = false;
- f->buildable_to = true;
-
- i = CONTENT_WATER;
- f = &g_content_features[i];
- //f->setInventoryTexture(irrlicht->getTextureId("water.png"));
- f->param_type = CPT_LIGHT;
- f->light_propagates = true;
- f->solidness = 0; // Drawn separately, makes no faces
- f->walkable = false;
- f->pointable = false;
- f->diggable = false;
- f->buildable_to = true;
- f->liquid_type = LIQUID_FLOWING;
-
- i = CONTENT_WATERSOURCE;
- f = &g_content_features[i];
- //f->setInventoryTexture(irrlicht->getTextureId("water.png"));
- if(new_style_water)
+
+ // Deserialize content
+ if(content_width == 1)
{
- f->solidness = 0; // drawn separately, makes no faces
+ for(u32 i=0; i<nodecount; i++)
+ nodes[i].param0 = readU8(&databuf[i]);
}
- else // old style
+ /* If param0 is extended to two bytes, use something like this: */
+ /*else if(content_width == 2)
{
- f->solidness = 1;
+ for(u32 i=0; i<nodecount; i++)
+ nodes[i].param0 = readU16(&databuf[i*2]);
+ }*/
- TileSpec t;
- if(g_texturesource)
- t.texture = g_texturesource->getTexture("water.png");
-
- t.alpha = WATER_ALPHA;
- t.material_type = MATERIAL_ALPHA_VERTEX;
- t.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
- f->setAllTiles(t);
+ // Deserialize param1
+ u32 start1 = content_width * nodecount;
+ for(u32 i=0; i<nodecount; i++)
+ nodes[i].param1 = readU8(&databuf[start1 + i]);
+
+ // Deserialize param2
+ u32 start2 = (content_width + 1) * nodecount;
+ for(u32 i=0; i<nodecount; i++)
+ nodes[i].param2 = readU8(&databuf[start2 + i]);
+}
+
+/*
+ Legacy serialization
+*/
+void MapNode::serialize_pre22(u8 *dest, u8 version)
+{
+ // Translate to wanted version
+ MapNode n_foreign = mapnode_translate_from_internal(*this, version);
+
+ u8 actual_param0 = n_foreign.param0;
+
+ // Convert special values from new version to old
+ if(version <= 18)
+ {
+ // In these versions, CONTENT_IGNORE and CONTENT_AIR
+ // are 255 and 254
+ if(actual_param0 == CONTENT_IGNORE)
+ actual_param0 = 255;
+ else if(actual_param0 == CONTENT_AIR)
+ actual_param0 = 254;
+ }
+
+ if(version == 0)
+ {
+ dest[0] = actual_param0;
+ }
+ else if(version <= 9)
+ {
+ dest[0] = actual_param0;
+ dest[1] = n_foreign.param1;
+ }
+ else
+ {
+ dest[0] = actual_param0;
+ dest[1] = n_foreign.param1;
+ dest[2] = n_foreign.param2;
+ }
+}
+void MapNode::deSerialize_pre22(u8 *source, u8 version)
+{
+ if(version <= 1)
+ {
+ param0 = source[0];
+ }
+ else if(version <= 9)
+ {
+ param0 = source[0];
+ param1 = source[1];
+ }
+ else
+ {
+ param0 = source[0];
+ param1 = source[1];
+ param2 = source[2];
}
- f->param_type = CPT_LIGHT;
- f->light_propagates = true;
- f->walkable = false;
- f->pointable = false;
- f->diggable = false;
- f->buildable_to = true;
- f->liquid_type = LIQUID_SOURCE;
-
- i = CONTENT_TORCH;
- f = &g_content_features[i];
- f->param_type = CPT_LIGHT;
- f->light_propagates = true;
- f->solidness = 0; // drawn separately, makes no faces
- f->walkable = false;
- f->wall_mounted = true;
+ // Convert special values from old version to new
+ if(version <= 19)
+ {
+ // In these versions, CONTENT_IGNORE and CONTENT_AIR
+ // are 255 and 254
+ // Version 19 is fucked up with sometimes the old values and sometimes not
+ if(param0 == 255)
+ param0 = CONTENT_IGNORE;
+ else if(param0 == 254)
+ param0 = CONTENT_AIR;
+ }
+
+ // Translate to our known version
+ *this = mapnode_translate_to_internal(*this, version);
}
-TileSpec MapNode::getTile(v3s16 dir)
+
+#ifndef SERVER
+
+/*
+ Nodes make a face if contents differ and solidness differs.
+ Return value:
+ 0: No face
+ 1: Face uses m1's content
+ 2: Face uses m2's content
+ equivalent: Whether the blocks share the same face (eg. water and glass)
+
+ TODO: Add 3: Both faces drawn with backface culling, remove equivalent
+*/
+u8 face_contents(content_t m1, content_t m2, bool *equivalent,
+ INodeDefManager *nodemgr)
{
- TileSpec spec;
+ *equivalent = false;
+
+ if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE)
+ return 0;
- s32 dir_i = -1;
+ bool contents_differ = (m1 != m2);
- if(dir == v3s16(0,0,0))
- dir_i = -1;
- else if(dir == v3s16(0,1,0))
- 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;
+ const ContentFeatures &f1 = nodemgr->get(m1);
+ const ContentFeatures &f2 = nodemgr->get(m2);
+
+ // Contents don't differ for different forms of same liquid
+ if(f1.sameLiquid(f2))
+ contents_differ = false;
- if(dir_i == -1)
- // Non-directional
- spec = content_features(d).tiles[0];
- else
- spec = content_features(d).tiles[dir_i];
+ u8 c1 = f1.solidness;
+ u8 c2 = f2.solidness;
+
+ bool solidness_differs = (c1 != c2);
+ bool makes_face = contents_differ && solidness_differs;
+
+ if(makes_face == false)
+ return 0;
- /*
- If it contains some mineral, change texture id
- */
- if(content_features(d).param_type == CPT_MINERAL && g_texturesource)
- {
- u8 mineral = param & 0x1f;
- 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);
- }
+ if(c1 == 0)
+ c1 = f1.visual_solidness;
+ if(c2 == 0)
+ c2 = f2.visual_solidness;
+
+ if(c1 == c2){
+ *equivalent = true;
+ // If same solidness, liquid takes precense
+ if(f1.isLiquid())
+ return 1;
+ if(f2.isLiquid())
+ return 2;
}
-
- return spec;
+
+ if(c1 > c2)
+ return 1;
+ else
+ return 2;
}
-u8 MapNode::getMineral()
+/*
+ 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: getNode(p) (uses only the lighting value)
+ n2: getNode(p + face_dir) (uses only the lighting value)
+ 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, INodeDefManager *nodemgr)
{
- if(content_features(d).param_type == CPT_MINERAL)
- {
- return param & 0x1f;
- }
+ try{
+ u8 light;
+ u8 l1 = n.getLightBlend(daynight_ratio, nodemgr);
+ u8 l2 = n2.getLightBlend(daynight_ratio, nodemgr);
+ if(l1 > l2)
+ light = l1;
+ else
+ light = l2;
- return MINERAL_NONE;
-}
+ // Make some nice difference to different sides
-// Pointers to c_str()s g_content_features[i].inventory_image_path
-//const char * g_content_inventory_texture_paths[USEFUL_CONTENT_COUNT] = {0};
+ // 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);
-void init_content_inventory_texture_paths()
-{
- dstream<<"DEPRECATED "<<__FUNCTION_NAME<<std::endl;
- /*for(u16 i=0; i<USEFUL_CONTENT_COUNT; i++)
+ return light;
+ }
+ catch(InvalidPositionException &e)
{
- g_content_inventory_texture_paths[i] =
- g_content_features[i].inventory_image_path.c_str();
- }*/
+ return 0;
+ }
}
+#endif
+
projects / minetest.git / blobdiff