Merge remote-tracking branch 'upstream/master'

builtin/falling.lua

@@ -111,6 +111,11 @@ function nodeupdate_single(p)
 end
 
 function nodeupdate(p)
+	-- Round p to prevent falling entities to get stuck
+	p.x = math.floor(p.x+0.5)
+	p.y = math.floor(p.y+0.5)
+	p.z = math.floor(p.z+0.5)
+	
 	for x = -1,1 do
 	for y = -1,1 do
 	for z = -1,1 do

builtin/misc_register.lua

@@ -259,6 +259,7 @@ minetest.register_node(":air", {
 	diggable = false,
 	buildable_to = true,
 	air_equivalent = true,
+	drop = "",
 	groups = {not_in_creative_inventory=1},
 })
 
@@ -274,6 +275,7 @@ minetest.register_node(":ignore", {
 	diggable = false,
 	buildable_to = true, -- A way to remove accidentally placed ignores
 	air_equivalent = true,
+	drop = "",
 	groups = {not_in_creative_inventory=1},
 })
 

doc/lua_api.txt

@@ -1347,6 +1347,8 @@ Node definition (register_node)
     liquid_alternative_flowing = "", -- Flowing version of source liquid
     liquid_alternative_source = "", -- Source version of flowing liquid
     liquid_viscosity = 0, -- Higher viscosity = slower flow (max. 7)
+    liquid_renewable = true, -- Can new liquid source be created by placing
+    two or more sources nearly?
     light_source = 0, -- Amount of light emitted by node
     damage_per_second = 0, -- If player is inside node, this damage is caused
     node_box = {type="regular"}, -- See "Node boxes"

src/camera.cpp

@@ -189,7 +189,7 @@ void Camera::step(f32 dtime)
 
 	if (m_digging_button != -1)
 	{
-		f32 offset = dtime * 3.5;
+		f32 offset = dtime * 4.5;
 		float m_digging_anim_was = m_digging_anim;
 		m_digging_anim += offset;
 		if (m_digging_anim >= 1)
@@ -336,13 +336,13 @@ void Camera::update(LocalPlayer* player, f32 frametime, v2u32 screensize,
 	if (m_digging_button != -1)
 	{
 		f32 digfrac = m_digging_anim;
-		wield_position.X -= 30 * sin(pow(digfrac, 0.8f) * M_PI);
-		wield_position.Y += 15 * sin(digfrac * 2 * M_PI);
-		wield_position.Z += 5 * digfrac;
-
+		wield_position.X -= 50 * sin(pow(digfrac, 0.8f) * M_PI);
+		wield_position.Y += 24 * sin(digfrac * 1.8 * M_PI);
+		wield_position.Z += 25 * 0.5;
+	
 		// Euler angles are PURE EVIL, so why not use quaternions?
 		core::quaternion quat_begin(wield_rotation * core::DEGTORAD);
-		core::quaternion quat_end(v3f(90, -10, -130) * core::DEGTORAD);
+		core::quaternion quat_end(v3f(80, 30, 100) * core::DEGTORAD);
 		core::quaternion quat_slerp;
 		quat_slerp.slerp(quat_begin, quat_end, sin(digfrac * M_PI));
 		quat_slerp.toEuler(wield_rotation);

src/clientmap.cpp

@@ -413,6 +413,10 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 		m_last_drawn_sectors.clear();
 	}
 
+	bool use_trilinear_filter = g_settings->getBool("trilinear_filter");
+	bool use_bilinear_filter = g_settings->getBool("bilinear_filter");
+	bool use_anisotropic_filter = g_settings->getBool("anisotropic_filter");
+
 	/*
 		Get time for measuring timeout.
 		
@@ -544,6 +548,11 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
 			for(u32 i=0; i<c; i++)
 			{
 				scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
+
+				buf->getMaterial().setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+				buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+				buf->getMaterial().setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
+
 				const video::SMaterial& material = buf->getMaterial();
 				video::IMaterialRenderer* rnd =
 						driver->getMaterialRenderer(material.MaterialType);

src/content_mapblock.cpp

@@ -492,15 +492,15 @@ void mapblock_mesh_generate_special(MeshMakeData *data,
 				// -Z towards +Z, thus the direction is +Z.
 				// Rotate texture to make animation go in flow direction
 				// Positive if liquid moves towards +Z
-				int dz = (corner_levels[side_corners[2][0]] +
-						corner_levels[side_corners[2][1]] <
-						corner_levels[side_corners[3][0]] +
-						corner_levels[side_corners[3][1]]);
+				int dz = (corner_levels[side_corners[3][0]] +
+						corner_levels[side_corners[3][1]]) -
+						(corner_levels[side_corners[2][0]] +
+						corner_levels[side_corners[2][1]]);
 				// Positive if liquid moves towards +X
-				int dx = (corner_levels[side_corners[0][0]] +
-						corner_levels[side_corners[0][1]] <
-						corner_levels[side_corners[1][0]] +
-						corner_levels[side_corners[1][1]]);
+				int dx = (corner_levels[side_corners[1][0]] +
+						corner_levels[side_corners[1][1]]) -
+						(corner_levels[side_corners[0][0]] +
+						corner_levels[side_corners[0][1]]);
 				// -X
 				if(-dx >= abs(dz))
 				{

src/defaultsettings.cpp

@@ -142,5 +142,10 @@ void set_default_settings(Settings *settings)
 	settings->setDefault("full_block_send_enable_min_time_from_building", "2.0");
 	settings->setDefault("dedicated_server_step", "0.05");
 	settings->setDefault("ignore_world_load_errors", "false");
+	settings->setDefault("mip_map", "false");
+	settings->setDefault("anisotropic_filter", "false");
+	settings->setDefault("bilinear_filter", "false");
+	settings->setDefault("trilinear_filter", "false");
+
 }
 

src/guiFormSpecMenu.cpp

@@ -692,17 +692,8 @@ void GUIFormSpecMenu::drawMenu()
 	m_tooltip_element->setVisible(false);
 
 	/*
-		Draw items
-		Phase 0: Item slot rectangles
-		Phase 1: Item images; prepare tooltip
+		Draw images
 	*/
-	
-	for(int phase=0; phase<=1; phase++)
-	for(u32 i=0; i<m_inventorylists.size(); i++)
-	{
-		drawList(m_inventorylists[i], phase);
-	}
-
 	for(u32 i=0; i<m_images.size(); i++)
 	{
 		const ImageDrawSpec &spec = m_images[i];
@@ -720,6 +711,17 @@ void GUIFormSpecMenu::drawMenu()
 			NULL/*&AbsoluteClippingRect*/, colors, true);
 	}
 
+	/*
+		Draw items
+		Phase 0: Item slot rectangles
+		Phase 1: Item images; prepare tooltip
+	*/
+	for(int phase=0; phase<=1; phase++)
+	for(u32 i=0; i<m_inventorylists.size(); i++)
+	{
+		drawList(m_inventorylists[i], phase);
+	}
+
 	/*
 		Draw dragged item stack
 	*/

src/guiMainMenu.cpp

@@ -98,6 +98,10 @@ enum
 	GUI_ID_SMOOTH_LIGHTING_CB,
 	GUI_ID_3D_CLOUDS_CB,
 	GUI_ID_OPAQUE_WATER_CB,
+	GUI_ID_MIPMAP_CB,
+	GUI_ID_ANISOTROPIC_CB,
+	GUI_ID_BILINEAR_CB,
+	GUI_ID_TRILINEAR_CB,
 	GUI_ID_DAMAGE_CB,
 	GUI_ID_CREATIVE_CB,
 	GUI_ID_JOIN_GAME_BUTTON,
@@ -580,6 +584,38 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
 			Environment->addCheckBox(m_data->opaque_water, rect, this,
 					GUI_ID_OPAQUE_WATER_CB, wgettext("Opaque water"));
 		}
+
+
+		// Anisotropic/mipmap/bi-/trilinear settings
+
+		{
+			core::rect<s32> rect(0, 0, option_w+20, 30);
+			rect += m_topleft_client + v2s32(option_x+175, option_y);
+			Environment->addCheckBox(m_data->mip_map, rect, this,
+				       GUI_ID_MIPMAP_CB, wgettext("Mip-Mapping"));
+		}
+
+		{
+			core::rect<s32> rect(0, 0, option_w+20, 30);
+			rect += m_topleft_client + v2s32(option_x+175, option_y+20);
+			Environment->addCheckBox(m_data->anisotropic_filter, rect, this,
+				       GUI_ID_ANISOTROPIC_CB, wgettext("Anisotropic Filtering"));
+		}
+
+		{
+			core::rect<s32> rect(0, 0, option_w+20, 30);
+			rect += m_topleft_client + v2s32(option_x+175, option_y+20*2);
+			Environment->addCheckBox(m_data->bilinear_filter, rect, this,
+				       GUI_ID_BILINEAR_CB, wgettext("Bi-Linear Filtering"));
+		}
+
+		{
+			core::rect<s32> rect(0, 0, option_w+20, 30);
+			rect += m_topleft_client + v2s32(option_x+175, option_y+20*3);
+			Environment->addCheckBox(m_data->trilinear_filter, rect, this,
+				       GUI_ID_TRILINEAR_CB, wgettext("Tri-Linear Filtering"));
+		}
+
 		// Key change button
 		{
 			core::rect<s32> rect(0, 0, 120, 30);
@@ -760,6 +796,30 @@ void GUIMainMenu::readInput(MainMenuData *dst)
 			dst->opaque_water = ((gui::IGUICheckBox*)e)->isChecked();
 	}
 
+	{
+		gui::IGUIElement *e = getElementFromId(GUI_ID_MIPMAP_CB);
+		if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
+			dst->mip_map = ((gui::IGUICheckBox*)e)->isChecked();
+	}
+
+	{
+		gui::IGUIElement *e = getElementFromId(GUI_ID_ANISOTROPIC_CB);
+		if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
+			dst->anisotropic_filter = ((gui::IGUICheckBox*)e)->isChecked();
+	}
+
+	{
+		gui::IGUIElement *e = getElementFromId(GUI_ID_BILINEAR_CB);
+		if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
+			dst->bilinear_filter = ((gui::IGUICheckBox*)e)->isChecked();
+	}
+
+	{
+		gui::IGUIElement *e = getElementFromId(GUI_ID_TRILINEAR_CB);
+		if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
+			dst->trilinear_filter = ((gui::IGUICheckBox*)e)->isChecked();
+	}
+
 	{
 		gui::IGUIElement *e = getElementFromId(GUI_ID_WORLD_LISTBOX);
 		if(e != NULL && e->getType() == gui::EGUIET_LIST_BOX)

src/guiMainMenu.h

@@ -41,6 +41,10 @@ struct MainMenuData
 	bool smooth_lighting;
 	bool clouds_3d;
 	bool opaque_water;
+	bool mip_map;
+	bool anisotropic_filter;
+	bool bilinear_filter;
+	bool trilinear_filter;
 	// Server options
 	bool creative_mode;
 	bool enable_damage;

src/main.cpp

@@ -1292,9 +1292,6 @@ int main(int argc, char *argv[])
 
 	video::IVideoDriver* driver = device->getVideoDriver();
 
-	// Disable mipmaps (because some of them look ugly)
-	driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
-
 	/*
 		This changes the minimum allowed number of vertices in a VBO.
 		Default is 500.
@@ -1439,6 +1436,11 @@ int main(int argc, char *argv[])
 				menudata.smooth_lighting = g_settings->getBool("smooth_lighting");
 				menudata.clouds_3d = g_settings->getBool("enable_3d_clouds");
 				menudata.opaque_water = g_settings->getBool("opaque_water");
+				menudata.mip_map = g_settings->getBool("mip_map");
+				menudata.anisotropic_filter = g_settings->getBool("anisotropic_filter");
+				menudata.bilinear_filter = g_settings->getBool("bilinear_filter");
+				menudata.trilinear_filter = g_settings->getBool("trilinear_filter");
+				driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, menudata.mip_map);
 				menudata.creative_mode = g_settings->getBool("creative_mode");
 				menudata.enable_damage = g_settings->getBool("enable_damage");
 				// Default to selecting nothing
@@ -1552,6 +1554,12 @@ int main(int argc, char *argv[])
 				g_settings->set("smooth_lighting", itos(menudata.smooth_lighting));
 				g_settings->set("enable_3d_clouds", itos(menudata.clouds_3d));
 				g_settings->set("opaque_water", itos(menudata.opaque_water));
+
+				g_settings->set("mip_map", itos(menudata.mip_map));
+				g_settings->set("anisotropic_filter", itos(menudata.anisotropic_filter));
+				g_settings->set("bilinear_filter", itos(menudata.bilinear_filter));
+				g_settings->set("trilinear_filter", itos(menudata.trilinear_filter));
+
 				g_settings->set("creative_mode", itos(menudata.creative_mode));
 				g_settings->set("enable_damage", itos(menudata.enable_damage));
 				g_settings->set("name", playername);

src/map.cpp

@@ -1746,12 +1746,12 @@ void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 		content_t new_node_content;
 		s8 new_node_level = -1;
 		s8 max_node_level = -1;
-		if (num_sources >= 2 || liquid_type == LIQUID_SOURCE) {
+		if ((num_sources >= 2 && nodemgr->get(liquid_kind).liquid_renewable) || liquid_type == LIQUID_SOURCE) {
 			// liquid_kind will be set to either the flowing alternative of the node (if it's a liquid)
 			// or the flowing alternative of the first of the surrounding sources (if it's air), so
 			// it's perfectly safe to use liquid_kind here to determine the new node content.
 			new_node_content = nodemgr->getId(nodemgr->get(liquid_kind).liquid_alternative_source);
-		} else if (num_sources == 1 && sources[0].t != NEIGHBOR_LOWER) {
+		} else if (num_sources >= 1 && sources[0].t != NEIGHBOR_LOWER) {
 			// liquid_kind is set properly, see above
 			new_node_content = liquid_kind;
 			max_node_level = new_node_level = LIQUID_LEVEL_MAX;

src/mapgen.cpp

@@ -1228,7 +1228,7 @@ double base_rock_level_2d(u64 seed, v2s16 p)
 			0.5+(float)p.X/125., 0.5+(float)p.Y/125.,
 			seed-932, 5, 0.7);
 	b = rangelim(b, 0.0, 1000.0);
-	b = pow(b, 7);
+	b = b*b*b*b*b*b*b;
 	b *= 5;
 	b = rangelim(b, 0.5, 1000.0);
 	// Values 1.5...100 give quite horrible looking slopes

src/mesh.cpp

@@ -433,6 +433,9 @@ video::ITexture *generateTextureFromMesh(scene::IMesh *mesh,
 	}
 
 	// Create render target texture
+	video::ITexture *oldtexture = driver->findTexture(texture_name.c_str());
+	if(oldtexture)
+		driver->removeTexture(oldtexture);
 	video::ITexture *rtt = driver->addRenderTargetTexture(
 			dim, texture_name.c_str(), video::ECF_A8R8G8B8);
 	if(rtt == NULL)

src/nodedef.cpp

@@ -203,6 +203,7 @@ void ContentFeatures::reset()
 	liquid_alternative_flowing = "";
 	liquid_alternative_source = "";
 	liquid_viscosity = 0;
+	liquid_renewable = true;
 	light_source = 0;
 	damage_per_second = 0;
 	node_box = NodeBox();
@@ -262,6 +263,9 @@ void ContentFeatures::serialize(std::ostream &os)
 	serializeSimpleSoundSpec(sound_footstep, os);
 	serializeSimpleSoundSpec(sound_dig, os);
 	serializeSimpleSoundSpec(sound_dug, os);
+	// Stuff below should be moved to correct place in a version that otherwise changes
+	// the protocol version
+	writeU8(os, liquid_renewable);
 }
 
 void ContentFeatures::deSerialize(std::istream &is)
@@ -319,6 +323,9 @@ void ContentFeatures::deSerialize(std::istream &is)
 	// If you add anything here, insert it primarily inside the try-catch
 	// block to not need to increase the version.
 	try{
+		// Stuff below should be moved to correct place in a version that
+		// otherwise changes the protocol version
+		liquid_renewable = readU8(is);
 	}catch(SerializationError &e) {};
 }
 

src/nodedef.h

@@ -209,6 +209,8 @@ struct ContentFeatures
 	// 1 giving almost instantaneous propagation and 7 being
 	// the slowest possible
 	u8 liquid_viscosity;
+	// Is liquid renewable (new liquid source will be created between 2 existing)
+	bool liquid_renewable;
 	// Amount of light the node emits
 	u8 light_source;
 	u32 damage_per_second;

src/noise.cpp

@@ -37,7 +37,7 @@ double dotProduct(double vx, double vy, double wx, double wy){
 }
  
 double easeCurve(double t){
-    return 6*pow(t,5)-15*pow(t,4)+10*pow(t,3);
+    return t * t * t * (6. * t * t - 15. * t + 10.);
 }
  
 double linearInterpolation(double x0, double x1, double t){

src/scriptapi.cpp

@@ -1238,6 +1238,7 @@ static ContentFeatures read_content_features(lua_State *L, int index)
 	// the slowest possible
 	f.liquid_viscosity = getintfield_default(L, index,
 			"liquid_viscosity", f.liquid_viscosity);
+	getboolfield(L, index, "liquid_renewable", f.liquid_renewable);
 	// Amount of light the node emits
 	f.light_source = getintfield_default(L, index,
 			"light_source", f.light_source);

src/tile.cpp

@@ -518,6 +518,15 @@ core::dimension2d<u32> imageTransformDimension(u32 transform, core::dimension2d<
 // Apply transform to image data
 void imageTransform(u32 transform, video::IImage *src, video::IImage *dst);
 
+/*
+	Adds a new texture to the video driver and returns a pointer to it.
+	This pointer should not be dropped. Any texture that was registered
+	with that name before is removed (this may invalidate some ITexture
+	pointers).
+*/
+video::ITexture* register_texture(video::IVideoDriver *driver,
+		std::string name, video::IImage *img);
+
 /*
 	Generate image based on a string like "stone.png" or "[crack0".
 	if baseimg is NULL, it is created. Otherwise stuff is made on it.
@@ -686,11 +695,9 @@ u32 TextureSource::getTextureIdDirect(const std::string &name)
 				" create texture \""<<name<<"\""<<std::endl;
 	}
 	
+	// Create texture from resulting image
 	if(baseimg != NULL)
-	{
-		// Create texture from resulting image
-		t = driver->addTexture(name.c_str(), baseimg);
-	}
+		t = register_texture(driver, name, baseimg);
 	
 	/*
 		Add texture to caches (add NULL textures too)
@@ -809,7 +816,7 @@ void TextureSource::rebuildImagesAndTextures()
 		// Create texture from resulting image
 		video::ITexture *t = NULL;
 		if(img)
-			t = driver->addTexture(sap->name.c_str(), img);
+			t = register_texture(driver, sap->name, img);
 		
 		// Replace texture
 		sap->a.atlas = t;
@@ -1044,7 +1051,7 @@ void TextureSource::buildMainAtlas(class IGameDef *gamedef)
 	/*
 		Make texture
 	*/
-	video::ITexture *t = driver->addTexture("__main_atlas__", atlas_img);
+	video::ITexture *t = register_texture(driver, "__main_atlas__", atlas_img);
 	assert(t);
 
 	/*
@@ -1135,6 +1142,15 @@ video::IImage* generate_image_from_scratch(std::string name,
 	return baseimg;
 }
 
+video::ITexture* register_texture(video::IVideoDriver *driver,
+		std::string name, video::IImage *img)
+{
+	video::ITexture *old_texture = driver->findTexture(name.c_str());
+	if(old_texture)
+		driver->removeTexture(old_texture);
+	return driver->addTexture(name.c_str(), img);
+}
+
 bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 		IrrlichtDevice *device, SourceImageCache *sourcecache)
 {
@@ -1541,12 +1557,12 @@ bool generate_image(std::string part_of_name, video::IImage *& baseimg,
 			assert(img_top && img_left && img_right);
 
 			// Create textures from images
-			video::ITexture *texture_top = driver->addTexture(
-					(imagename_top + "__temp__").c_str(), img_top);
-			video::ITexture *texture_left = driver->addTexture(
-					(imagename_left + "__temp__").c_str(), img_left);
-			video::ITexture *texture_right = driver->addTexture(
-					(imagename_right + "__temp__").c_str(), img_right);
+			video::ITexture *texture_top = register_texture(driver,
+					imagename_top + "__temp1__", img_top);
+			video::ITexture *texture_left = register_texture(driver,
+					imagename_left + "__temp2__", img_left);
+			video::ITexture *texture_right = register_texture(driver,
+					imagename_right + "__temp3__", img_right);
 			assert(texture_top && texture_left && texture_right);
 
 			// Drop images