X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fnodedef.cpp;h=93751c70e3160e3355e7042ec3f47ee2c3ebea08;hb=86a0f5603b9e936b8527ae22c4aeaf5714c9d279;hp=96dca730bf7785e1463ef43bbb627fbc76aa7b5f;hpb=3aedfac9685c2d9ae8bac5a5b7e72e527f22c08d;p=oweals%2Fminetest.git

diff --git a/src/nodedef.cpp b/src/nodedef.cpp
index 96dca730b..93751c70e 100644
--- a/src/nodedef.cpp
+++ b/src/nodedef.cpp
@@ -46,10 +46,15 @@ void NodeBox::reset()
 	wall_side = aabb3f(-BS/2, -BS/2, -BS/2, -BS/2+BS/16., BS/2, BS/2);
 }
 
-void NodeBox::serialize(std::ostream &os) const
+void NodeBox::serialize(std::ostream &os, u16 protocol_version) const
 {
-	writeU8(os, 1); // version
-	writeU8(os, type);
+	int version = protocol_version >= 21 ? 2 : 1;
+	writeU8(os, version);
+
+	if (version == 1 && type == NODEBOX_LEVELED)
+		writeU8(os, NODEBOX_FIXED);
+	else
+		writeU8(os, type);
 
 	if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED)
 	{
@@ -76,7 +81,7 @@ void NodeBox::serialize(std::ostream &os) const
 void NodeBox::deSerialize(std::istream &is)
 {
 	int version = readU8(is);
-	if(version != 1)
+	if(version < 1 || version > 2)
 		throw SerializationError("unsupported NodeBox version");
 
 	reset();
@@ -112,7 +117,7 @@ void NodeBox::deSerialize(std::istream &is)
 void TileDef::serialize(std::ostream &os, u16 protocol_version) const
 {
 	if(protocol_version >= 17)
-		writeU8(os, 1); 
+		writeU8(os, 1);
 	else
 		writeU8(os, 0);
 	os<<serializeString(name);
@@ -190,9 +195,9 @@ void ContentFeatures::reset()
 	groups["dig_immediate"] = 2;
 	drawtype = NDT_NORMAL;
 	visual_scale = 1.0;
-	for(u32 i=0; i<6; i++)
+	for(u32 i = 0; i < 6; i++)
 		tiledef[i] = TileDef();
-	for(u16 j=0; j<CF_SPECIAL_COUNT; j++)
+	for(u16 j = 0; j < CF_SPECIAL_COUNT; j++)
 		tiledef_special[j] = TileDef();
 	alpha = 255;
 	post_effect_color = video::SColor(0, 0, 0, 0);
@@ -215,11 +220,12 @@ void ContentFeatures::reset()
 	liquid_renewable = true;
 	freezemelt = "";
 	liquid_range = LIQUID_LEVEL_MAX+1;
-	drowning = true;
+	drowning = 0;
 	light_source = 0;
 	damage_per_second = 0;
 	node_box = NodeBox();
 	selection_box = NodeBox();
+	waving = 0;
 	legacy_facedir_simple = false;
 	legacy_wallmounted = false;
 	sound_footstep = SimpleSoundSpec();
@@ -229,12 +235,12 @@ void ContentFeatures::reset()
 
 void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
 {
-	if(protocol_version < 14){
+	if(protocol_version < 24){
 		serializeOld(os, protocol_version);
 		return;
 	}
 
-	writeU8(os, 6); // version
+	writeU8(os, 7); // version
 	os<<serializeString(name);
 	writeU16(os, groups.size());
 	for(ItemGroupList::const_iterator
@@ -245,10 +251,10 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
 	writeU8(os, drawtype);
 	writeF1000(os, visual_scale);
 	writeU8(os, 6);
-	for(u32 i=0; i<6; i++)
+	for(u32 i = 0; i < 6; i++)
 		tiledef[i].serialize(os, protocol_version);
 	writeU8(os, CF_SPECIAL_COUNT);
-	for(u32 i=0; i<CF_SPECIAL_COUNT; i++){
+	for(u32 i = 0; i < CF_SPECIAL_COUNT; i++){
 		tiledef_special[i].serialize(os, protocol_version);
 	}
 	writeU8(os, alpha);
@@ -274,8 +280,8 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
 	writeU8(os, liquid_renewable);
 	writeU8(os, light_source);
 	writeU32(os, damage_per_second);
-	node_box.serialize(os);
-	selection_box.serialize(os);
+	node_box.serialize(os, protocol_version);
+	selection_box.serialize(os, protocol_version);
 	writeU8(os, legacy_facedir_simple);
 	writeU8(os, legacy_wallmounted);
 	serializeSimpleSoundSpec(sound_footstep, os);
@@ -285,6 +291,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
 	writeU8(os, drowning);
 	writeU8(os, leveled);
 	writeU8(os, liquid_range);
+	writeU8(os, waving);
 	// Stuff below should be moved to correct place in a version that otherwise changes
 	// the protocol version
 }
@@ -292,7 +299,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
 void ContentFeatures::deSerialize(std::istream &is)
 {
 	int version = readU8(is);
-	if(version != 6){
+	if(version != 7){
 		deSerializeOld(is, version);
 		return;
 	}
@@ -300,7 +307,7 @@ void ContentFeatures::deSerialize(std::istream &is)
 	name = deSerializeString(is);
 	groups.clear();
 	u32 groups_size = readU16(is);
-	for(u32 i=0; i<groups_size; i++){
+	for(u32 i = 0; i < groups_size; i++){
 		std::string name = deSerializeString(is);
 		int value = readS16(is);
 		groups[name] = value;
@@ -309,11 +316,11 @@ void ContentFeatures::deSerialize(std::istream &is)
 	visual_scale = readF1000(is);
 	if(readU8(is) != 6)
 		throw SerializationError("unsupported tile count");
-	for(u32 i=0; i<6; i++)
+	for(u32 i = 0; i < 6; i++)
 		tiledef[i].deSerialize(is);
 	if(readU8(is) != CF_SPECIAL_COUNT)
 		throw SerializationError("unsupported CF_SPECIAL_COUNT");
-	for(u32 i=0; i<CF_SPECIAL_COUNT; i++)
+	for(u32 i = 0; i < CF_SPECIAL_COUNT; i++)
 		tiledef_special[i].deSerialize(is);
 	alpha = readU8(is);
 	post_effect_color.setAlpha(readU8(is));
@@ -349,6 +356,7 @@ void ContentFeatures::deSerialize(std::istream &is)
 	drowning = readU8(is);
 	leveled = readU8(is);
 	liquid_range = readU8(is);
+	waving = readU8(is);
 	// If you add anything here, insert it primarily inside the try-catch
 	// block to not need to increase the version.
 	try{
@@ -391,15 +399,16 @@ public:
 		// Set CONTENT_AIR
 		{
 			ContentFeatures f;
-			f.name = "air";
-			f.drawtype = NDT_AIRLIKE;
-			f.param_type = CPT_LIGHT;
-			f.light_propagates = true;
+			f.name                = "air";
+			f.drawtype            = NDT_AIRLIKE;
+			f.param_type          = CPT_LIGHT;
+			f.light_propagates    = true;
 			f.sunlight_propagates = true;
-			f.walkable = false;
-			f.pointable = false;
-			f.diggable = false;
-			f.buildable_to = true;
+			f.walkable            = false;
+			f.pointable           = false;
+			f.diggable            = false;
+			f.buildable_to        = true;
+			f.is_ground_content   = true;
 			// Insert directly into containers
 			content_t c = CONTENT_AIR;
 			m_content_features[c] = f;
@@ -409,16 +418,16 @@ public:
 		// Set CONTENT_IGNORE
 		{
 			ContentFeatures f;
-			f.name = "ignore";
-			f.drawtype = NDT_AIRLIKE;
-			f.param_type = CPT_NONE;
-			f.light_propagates = false;
+			f.name                = "ignore";
+			f.drawtype            = NDT_AIRLIKE;
+			f.param_type          = CPT_NONE;
+			f.light_propagates    = false;
 			f.sunlight_propagates = false;
-			f.walkable = false;
-			f.pointable = false;
-			f.diggable = false;
-			// A way to remove accidental CONTENT_IGNOREs
-			f.buildable_to = true;
+			f.walkable            = false;
+			f.pointable           = false;
+			f.diggable            = false;
+			f.buildable_to        = true; // A way to remove accidental CONTENT_IGNOREs
+			f.is_ground_content   = true;
 			// Insert directly into containers
 			content_t c = CONTENT_IGNORE;
 			m_content_features[c] = f;
@@ -551,7 +560,7 @@ public:
 		for (ItemGroupList::const_iterator i = def.groups.begin();
 			i != def.groups.end(); ++i) {
 			std::string group_name = i->first;
-			
+
 			std::map<std::string, GroupItems>::iterator
 				j = m_group_to_items.find(group_name);
 			if (j == m_group_to_items.end()) {
@@ -588,7 +597,8 @@ public:
 			}
 		}
 	}
-	virtual void updateTextures(ITextureSource *tsrc)
+	virtual void updateTextures(ITextureSource *tsrc,
+		IShaderSource *shdsrc)
 	{
 #ifndef SERVER
 		infostream<<"CNodeDefManager::updateTextures(): Updating "
@@ -597,6 +607,9 @@ public:
 		bool new_style_water = g_settings->getBool("new_style_water");
 		bool new_style_leaves = g_settings->getBool("new_style_leaves");
 		bool opaque_water = g_settings->getBool("opaque_water");
+		bool enable_shaders = g_settings->getBool("enable_shaders");
+		bool enable_bumpmapping = g_settings->getBool("enable_bumpmapping");
+		bool enable_parallax_occlusion = g_settings->getBool("enable_parallax_occlusion");
 
 		for(u32 i=0; i<m_content_features.size(); i++)
 		{
@@ -604,7 +617,7 @@ public:
 
 			// Figure out the actual tiles to use
 			TileDef tiledef[6];
-			for(u32 j=0; j<6; j++)
+			for(u32 j = 0; j < 6; j++)
 			{
 				tiledef[j] = f->tiledef[j];
 				if(tiledef[j].name == "")
@@ -612,6 +625,11 @@ public:
 			}
 
 			bool is_liquid = false;
+			bool is_water_surface = false;
+
+			u8 material_type;
+			material_type = (f->alpha == 255) ? TILE_MATERIAL_BASIC : TILE_MATERIAL_ALPHA;
+
 			switch(f->drawtype){
 			default:
 			case NDT_NORMAL:
@@ -663,10 +681,14 @@ public:
 						tiledef[i].name += std::string("^[noalpha");
 					}
 				}
+				if (f->waving == 1)
+					material_type = TILE_MATERIAL_WAVING_LEAVES;
 				break;
 			case NDT_PLANTLIKE:
 				f->solidness = 0;
 				f->backface_culling = false;
+				if (f->waving == 1)
+					material_type = TILE_MATERIAL_WAVING_PLANTS;
 				break;
 			case NDT_TORCHLIKE:
 			case NDT_SIGNLIKE:
@@ -677,18 +699,29 @@ public:
 				break;
 			}
 
-			u8 material_type;
-			if (is_liquid)
+			if (is_liquid){
 				material_type = (f->alpha == 255) ? TILE_MATERIAL_LIQUID_OPAQUE : TILE_MATERIAL_LIQUID_TRANSPARENT;
-			else
-				material_type = (f->alpha == 255) ? TILE_MATERIAL_BASIC : TILE_MATERIAL_ALPHA;
+				if (f->name == "default:water_source")
+					is_water_surface = true;
+			}
+			u32 tile_shader[6];
+			for(u16 j=0; j<6; j++)
+				tile_shader[j] = shdsrc->getShader("nodes_shader",material_type, f->drawtype);
+
+			if (is_water_surface)
+				tile_shader[0] = shdsrc->getShader("water_surface_shader",material_type, f->drawtype);
 
 			// Tiles (fill in f->tiles[])
-			for(u16 j=0; j<6; j++){
+			for(u16 j = 0; j < 6; j++){
+				// Shader
+				f->tiles[j].shader_id = tile_shader[j];
 				// Texture
 				f->tiles[j].texture = tsrc->getTexture(
 						tiledef[j].name,
 						&f->tiles[j].texture_id);
+				// Normal texture
+				if (enable_shaders && (enable_bumpmapping || enable_parallax_occlusion))
+					f->tiles[j].normal_texture = tsrc->getNormalTexture(tiledef[j].name);
 				// Alpha
 				f->tiles[j].alpha = f->alpha;
 				// Material type
@@ -700,37 +733,46 @@ public:
 				if(tiledef[j].animation.type == TAT_VERTICAL_FRAMES)
 					f->tiles[j].material_flags |= MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
 				// Animation parameters
-				if(f->tiles[j].material_flags &
-						MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
-				{
+				int frame_count = 1;
+				if(f->tiles[j].material_flags &	MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES) {
 					// Get texture size to determine frame count by
 					// aspect ratio
 					v2u32 size = f->tiles[j].texture->getOriginalSize();
 					int frame_height = (float)size.X /
 							(float)tiledef[j].animation.aspect_w *
 							(float)tiledef[j].animation.aspect_h;
-					int frame_count = size.Y / frame_height;
+					frame_count = size.Y / frame_height;
 					int frame_length_ms = 1000.0 *
 							tiledef[j].animation.length / frame_count;
 					f->tiles[j].animation_frame_count = frame_count;
 					f->tiles[j].animation_frame_length_ms = frame_length_ms;
-
-					// If there are no frames for an animation, switch
-					// animation off (so that having specified an animation
-					// for something but not using it in the texture pack
-					// gives no overhead)
-					if(frame_count == 1){
-						f->tiles[j].material_flags &=
-								~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
+				}
+				if(frame_count == 1) {
+					f->tiles[j].material_flags &= ~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
+				} else {
+					std::ostringstream os(std::ios::binary);
+					for (int i = 0; i < frame_count; i++) {
+						FrameSpec frame;
+						os.str("");
+						os<<tiledef[j].name<<"^[verticalframe:"<<frame_count<<":"<<i;
+						frame.texture = tsrc->getTexture(os.str(), &frame.texture_id);
+						if (f->tiles[j].normal_texture)
+							frame.normal_texture = tsrc->getNormalTexture(os.str());
+						f->tiles[j].frames[i]=frame;
 					}
 				}
 			}
 			// Special tiles (fill in f->special_tiles[])
 			for(u16 j=0; j<CF_SPECIAL_COUNT; j++){
+				// Shader
+				f->special_tiles[j].shader_id = tile_shader[j];
 				// Texture
 				f->special_tiles[j].texture = tsrc->getTexture(
 						f->tiledef_special[j].name,
 						&f->special_tiles[j].texture_id);
+				// Normal texture
+				if (enable_shaders && (enable_bumpmapping || enable_parallax_occlusion))
+					f->special_tiles[j].normal_texture = tsrc->getNormalTexture(f->tiledef_special[j].name);
 				// Alpha
 				f->special_tiles[j].alpha = f->alpha;
 				// Material type
@@ -742,28 +784,32 @@ public:
 				if(f->tiledef_special[j].animation.type == TAT_VERTICAL_FRAMES)
 					f->special_tiles[j].material_flags |= MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
 				// Animation parameters
-				if(f->special_tiles[j].material_flags &
-						MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
-				{
+				int frame_count = 1;
+				if(f->special_tiles[j].material_flags &	MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES) {
 					// Get texture size to determine frame count by
 					// aspect ratio
 					v2u32 size = f->special_tiles[j].texture->getOriginalSize();
 					int frame_height = (float)size.X /
 							(float)f->tiledef_special[j].animation.aspect_w *
 							(float)f->tiledef_special[j].animation.aspect_h;
-					int frame_count = size.Y / frame_height;
+					frame_count = size.Y / frame_height;
 					int frame_length_ms = 1000.0 *
 							f->tiledef_special[j].animation.length / frame_count;
 					f->special_tiles[j].animation_frame_count = frame_count;
 					f->special_tiles[j].animation_frame_length_ms = frame_length_ms;
-
-					// If there are no frames for an animation, switch
-					// animation off (so that having specified an animation
-					// for something but not using it in the texture pack
-					// gives no overhead)
-					if(frame_count == 1){
-						f->special_tiles[j].material_flags &=
-								~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
+				}
+				if(frame_count == 1) {
+					f->special_tiles[j].material_flags &= ~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
+				} else {
+					std::ostringstream os(std::ios::binary);
+					for (int i = 0; i < frame_count; i++) {
+						FrameSpec frame;
+						os.str("");
+						os<<f->tiledef_special[j].name<<"^[verticalframe:"<<frame_count<<":"<<i;
+						frame.texture = tsrc->getTexture(os.str(), &frame.texture_id);
+						if (f->special_tiles[j].normal_texture)
+							frame.normal_texture = tsrc->getNormalTexture(os.str());
+						f->special_tiles[j].frames[i]=frame;
 					}
 				}
 			}
@@ -775,7 +821,7 @@ public:
 		writeU8(os, 1); // version
 		u16 count = 0;
 		std::ostringstream os2(std::ios::binary);
-		for(u32 i=0; i<m_content_features.size(); i++)
+		for(u32 i = 0; i < m_content_features.size(); i++)
 		{
 			if(i == CONTENT_IGNORE || i == CONTENT_AIR
 					|| i == CONTENT_UNKNOWN)
@@ -805,7 +851,7 @@ public:
 		u16 count = readU16(is);
 		std::istringstream is2(deSerializeLongString(is), std::ios::binary);
 		ContentFeatures f;
-		for(u16 n=0; n<count; n++){
+		for(u16 n = 0; n < count; n++){
 			u16 i = readU16(is2);
 
 			// Read it from the string wrapper
@@ -890,10 +936,11 @@ void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version)
 		writeU8(os, drawtype);
 		writeF1000(os, visual_scale);
 		writeU8(os, 6);
-		for(u32 i=0; i<6; i++)
+		for(u32 i = 0; i < 6; i++)
 			tiledef[i].serialize(os, protocol_version);
-		writeU8(os, CF_SPECIAL_COUNT);
-		for(u32 i=0; i<CF_SPECIAL_COUNT; i++){
+		//CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24
+		writeU8(os, 2);
+		for(u32 i = 0; i < 2; i++){
 			tiledef_special[i].serialize(os, protocol_version);
 		}
 		writeU8(os, alpha);
@@ -918,18 +965,69 @@ void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version)
 		writeU8(os, liquid_viscosity);
 		writeU8(os, light_source);
 		writeU32(os, damage_per_second);
-		node_box.serialize(os);
-		selection_box.serialize(os);
+		node_box.serialize(os, protocol_version);
+		selection_box.serialize(os, protocol_version);
 		writeU8(os, legacy_facedir_simple);
 		writeU8(os, legacy_wallmounted);
 		serializeSimpleSoundSpec(sound_footstep, os);
 		serializeSimpleSoundSpec(sound_dig, os);
 		serializeSimpleSoundSpec(sound_dug, os);
 	}
-	else
-	{
+	else if (protocol_version > 13 && protocol_version < 24) {
+		writeU8(os, 6); // version
+		os<<serializeString(name);
+		writeU16(os, groups.size());
+		for(ItemGroupList::const_iterator
+			i = groups.begin(); i != groups.end(); i++){
+				os<<serializeString(i->first);
+				writeS16(os, i->second);
+		}
+		writeU8(os, drawtype);
+		writeF1000(os, visual_scale);
+		writeU8(os, 6);
+		for(u32 i = 0; i < 6; i++)
+			tiledef[i].serialize(os, protocol_version);
+		//CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24
+		writeU8(os, 2);
+		for(u32 i = 0; i < 2; i++){
+			tiledef_special[i].serialize(os, protocol_version);
+		}
+		writeU8(os, alpha);
+		writeU8(os, post_effect_color.getAlpha());
+		writeU8(os, post_effect_color.getRed());
+		writeU8(os, post_effect_color.getGreen());
+		writeU8(os, post_effect_color.getBlue());
+		writeU8(os, param_type);
+		writeU8(os, param_type_2);
+		writeU8(os, is_ground_content);
+		writeU8(os, light_propagates);
+		writeU8(os, sunlight_propagates);
+		writeU8(os, walkable);
+		writeU8(os, pointable);
+		writeU8(os, diggable);
+		writeU8(os, climbable);
+		writeU8(os, buildable_to);
+		os<<serializeString(""); // legacy: used to be metadata_name
+		writeU8(os, liquid_type);
+		os<<serializeString(liquid_alternative_flowing);
+		os<<serializeString(liquid_alternative_source);
+		writeU8(os, liquid_viscosity);
+		writeU8(os, liquid_renewable);
+		writeU8(os, light_source);
+		writeU32(os, damage_per_second);
+		node_box.serialize(os, protocol_version);
+		selection_box.serialize(os, protocol_version);
+		writeU8(os, legacy_facedir_simple);
+		writeU8(os, legacy_wallmounted);
+		serializeSimpleSoundSpec(sound_footstep, os);
+		serializeSimpleSoundSpec(sound_dig, os);
+		serializeSimpleSoundSpec(sound_dug, os);
+		writeU8(os, rightclickable);
+		writeU8(os, drowning);
+		writeU8(os, leveled);
+		writeU8(os, liquid_range);
+	} else 
 		throw SerializationError("ContentFeatures::serialize(): Unsupported version requested");
-	}
 }
 
 void ContentFeatures::deSerializeOld(std::istream &is, int version)
@@ -983,10 +1081,60 @@ void ContentFeatures::deSerializeOld(std::istream &is, int version)
 		deSerializeSimpleSoundSpec(sound_footstep, is);
 		deSerializeSimpleSoundSpec(sound_dig, is);
 		deSerializeSimpleSoundSpec(sound_dug, is);
-	}
-	else
-	{
+	} else if (version == 6) {
+		name = deSerializeString(is);
+		groups.clear();
+		u32 groups_size = readU16(is);
+		for(u32 i=0; i<groups_size; i++){
+			std::string name = deSerializeString(is);
+			int	value = readS16(is);
+			groups[name] = value;
+		}
+		drawtype = (enum NodeDrawType)readU8(is);
+		visual_scale = readF1000(is);
+		if(readU8(is) != 6)
+			throw SerializationError("unsupported tile count");
+		for(u32 i=0; i<6; i++)
+			tiledef[i].deSerialize(is);
+		// CF_SPECIAL_COUNT in version 6 = 2
+		if(readU8(is) != 2)
+			throw SerializationError("unsupported CF_SPECIAL_COUNT");
+		for(u32 i=0; i<2; i++)
+			tiledef_special[i].deSerialize(is);
+		alpha = readU8(is);
+		post_effect_color.setAlpha(readU8(is));
+		post_effect_color.setRed(readU8(is));
+		post_effect_color.setGreen(readU8(is));
+		post_effect_color.setBlue(readU8(is));
+		param_type = (enum ContentParamType)readU8(is);
+		param_type_2 = (enum ContentParamType2)readU8(is);
+		is_ground_content = readU8(is);
+		light_propagates = readU8(is);
+		sunlight_propagates = readU8(is);
+		walkable = readU8(is);
+		pointable = readU8(is);
+		diggable = readU8(is);
+		climbable = readU8(is);
+		buildable_to = readU8(is);
+		deSerializeString(is); // legacy: used to be metadata_name
+		liquid_type = (enum LiquidType)readU8(is);
+		liquid_alternative_flowing = deSerializeString(is);
+		liquid_alternative_source = deSerializeString(is);
+		liquid_viscosity = readU8(is);
+		liquid_renewable = readU8(is);
+		light_source = readU8(is);
+		damage_per_second = readU32(is);
+		node_box.deSerialize(is);
+		selection_box.deSerialize(is);
+		legacy_facedir_simple = readU8(is);
+		legacy_wallmounted = readU8(is);
+		deSerializeSimpleSoundSpec(sound_footstep, is);
+		deSerializeSimpleSoundSpec(sound_dig, is);
+		deSerializeSimpleSoundSpec(sound_dug, is);
+		rightclickable = readU8(is);
+		drowning = readU8(is);
+		leveled = readU8(is);
+		liquid_range = readU8(is);
+	} else
 		throw SerializationError("unsupported ContentFeatures version");
-	}
 }
-