position-based variants

Author: kno10

builtin/game/item.lua

@@ -643,6 +643,7 @@ core.nodedef_default = {
 	description = "",
 	groups = {},
 	variant_count = 1,
+	variant_pos = false,
 	inventory_image = "",
 	wield_image = "",
 	wield_scale = vector.new(1, 1, 1),

doc/lua_api.md

@@ -1152,6 +1152,11 @@ Example node with variants:
     })
 
 
+Alternatively, variants can depend on the position. This is convenient for minor variations
+in textures such as stone or grass that solely serve the purpose of making the world look
+more interesting. In this case, the variant cannot be controlled by the user, but it is
+computed using `hash(pos) % variant_count`. To enable this, set `variant_pos = true`.
+
 
 Sounds
 ======

games/devtest/mods/basenodes/init.lua

@@ -12,6 +12,13 @@ core.register_node("basenodes:stone", {
 	description = "Stone",
 	tiles = {"default_stone.png"},
 	groups = {cracky=3},
+	variant_count = 4,
+	variants = {
+		{ tiles = { "default_stone.png^[transformR180" } },
+		{ tiles = { "default_stone.png^[transformFX" } },
+		{ tiles = { "default_stone.png^[transformFY" } },
+	},
+	variant_pos = true,
 })
 
 core.register_node("basenodes:desert_stone", {
@@ -32,6 +39,25 @@ core.register_node("basenodes:dirt_with_grass", {
 		{name = "default_grass_side.png", tileable_vertical = false},
 	},
 	groups = {crumbly=3, soil=1},
+	variant_count = 4,
+	variants = {
+		{ tiles = { "default_dirt.png^[transform1" },
+		  overlay_tiles = { "default_grass.png^[transform1",
+			  "basenodes_dirt_with_grass_bottom.png^[transform1",
+			  {name = "default_grass_side.png^[transformFX", tileable_vertical = false} },
+		},
+		{ tiles = { "default_dirt.png^[transform2" },
+		  overlay_tiles = { "default_grass.png^[transform2",
+			  "basenodes_dirt_with_grass_bottom.png^[transform2",
+			  {name = "default_grass_side.png", tileable_vertical = false} },
+		},
+		{ tiles = { "default_dirt.png^[transform3" },
+		  overlay_tiles = { "default_grass.png^[transform3",
+			  "basenodes_dirt_with_grass_bottom.png^[transform3",
+			  {name = "default_grass_side.png^[transformFX", tileable_vertical = false} },
+		},
+	},
+	variant_pos = true,
 })
 
 core.register_node("basenodes:dirt_with_snow", {
@@ -47,6 +73,17 @@ core.register_node("basenodes:dirt_with_snow", {
 core.register_node("basenodes:dirt", {
 	description = "Dirt",
 	tiles ={"default_dirt.png"},
+	variant_count = 8,
+	variants = {
+		{tiles ={"default_dirt.png^[transform1"},},
+		{tiles ={"default_dirt.png^[transform2"},},
+		{tiles ={"default_dirt.png^[transform3"},},
+		{tiles ={"default_dirt.png^[transform4"},},
+		{tiles ={"default_dirt.png^[transform5"},},
+		{tiles ={"default_dirt.png^[transform6"},},
+		{tiles ={"default_dirt.png^[transform7"},},
+	},
+	variant_pos = true,
 	groups = {crumbly=3, soil=1},
 })
 

src/client/content_mapblock.cpp

@@ -98,7 +98,7 @@ void MapblockMeshGenerator::getTile(v3s16 direction, TileSpec *tile_ret)
 // Returns a special tile, ready for use, non-rotated.
 void MapblockMeshGenerator::getSpecialTile(int index, TileSpec *tile_ret, bool apply_crack)
 {
-	*tile_ret = cur_node.f->special_tiles[cur_node.n.getVariant(*cur_node.f)][index];
+	*tile_ret = cur_node.f->special_tiles[cur_node.n.getVariant(cur_node.p,*cur_node.f)][index];
 	TileLayer *top_layer = nullptr;
 
 	for (auto &layernum : tile_ret->layers) {
@@ -990,7 +990,7 @@ void MapblockMeshGenerator::drawGlasslikeFramedNode()
 	// Optionally render internal liquid level defined by param2
 	// Liquid is textured with 1 tile defined in nodedef 'special_tiles'
 	if (param2 > 0 && cur_node.f->param_type_2 == CPT2_GLASSLIKE_LIQUID_LEVEL &&
-			cur_node.f->special_tiles[cur_node.n.getVariant(*cur_node.f)][0].layers[0].texture) {
+			cur_node.f->special_tiles[cur_node.n.getVariant(cur_node.p, *cur_node.f)][0].layers[0].texture) {
 		// Internal liquid level has param2 range 0 .. 63,
 		// convert it to -0.5 .. 0.5
 		float vlev = (param2 / 63.0f) * 2.0f - 1.0f;

src/client/mapblock_mesh.cpp

@@ -344,7 +344,7 @@ void getNodeTileN(MapNode mn, const v3s16 &p, u8 tileindex, MeshMakeData *data,
 {
 	const NodeDefManager *ndef = data->m_nodedef;
 	const ContentFeatures &f = ndef->get(mn);
-	tile = f.tiles[mn.getVariant(f)][tileindex];
+	tile = f.tiles[mn.getVariant(p, f)][tileindex];
 	bool has_crack = p == data->m_crack_pos_relative;
 	for (TileLayer &layer : tile.layers) {
 		if (layer.empty())

src/client/minimap.cpp

@@ -403,7 +403,7 @@ void Minimap::blitMinimapPixelsToImageSurface(
 		MinimapPixel *mmpixel = &data->minimap_scan[x + z * data->mode.map_size];
 
 		const ContentFeatures &f = m_ndef->get(mmpixel->n);
-		u16 v = mmpixel->n.getVariant(f);
+		u16 v = mmpixel->n.getVariant(v3s16(x, 0, z), f); // We don't have y here
 		const TileDef *tile = &f.tiledef[v][0];
 		video::SColor minimap_color = f.minimap_color[v];
 

src/client/particles.cpp

@@ -867,7 +867,7 @@ bool ParticleManager::getNodeParticleParams(const MapNode &n,
 		texid = tilenum - 1;
 	else
 		texid = myrand_range(0,5);
-	const TileLayer &tile = f.tiles[n.getVariant(f)][texid].layers[0];
+	const TileLayer &tile = f.tiles[n.getVariant(v3s16(p.pos.X, p.pos.Y, p.pos.Z), f)][texid].layers[0];
 	p.animation.type = TAT_NONE;
 
 	// Only use first frame of animated texture

src/mapnode.cpp

@@ -38,12 +38,35 @@ void MapNode::getColor(const ContentFeatures &f, video::SColor *color) const
 	*color = f.color;
 }
 
-u16 MapNode::getVariant(const ContentFeatures &f) const
+#define rotl32(b, n)  ((b << n) | (b >> (32-n)))
+u16 MapNode::getVariant(const v3s16 &p, const ContentFeatures &f) const
 {
-	if (f.variant_count > 1)
-		return (f.param2_variant.get(param2) + f.variant_offset) % f.variant_count;
-	return 0;
+	if (f.variant_count <= 1) return 0;
+	if (f.variant_pos) {
+		u32 hash = 0; // could use world seed
+		// this is "almost Murmur3", but we trimmed it down to less
+		// instructions that still give the desired effect
+		// double cast, as float to unsigned int is not well specified
+		// u32 hX = totl32(((u16)(s16)p.X) * (u32) 0xcc9e2d51, 15);
+		// u32 hY = rotl32(((u16)(s16)p.Y) * (u32) 0xcc9e2d51, 15);
+		// u32 hZ = rotl32(((u16)(s16)p.Z) * (u32) 0xcc9e2d51, 15);
+		u32 hX = ((u16)(s16)p.X) * 0xcc9e2d51;
+		u32 hY = ((u16)(s16)p.Y) * 0xcc9e2d51;
+		u32 hZ = ((u16)(s16)p.Z) * 0xcc9e2d51;
+		hash = rotl32(hash ^ hX, 13); // * 5 + 0xe6546b64;
+		hash = rotl32(hash ^ hY, 13); // * 5 + 0xe6546b64;
+		hash = rotl32(hash ^ hZ, 13); // * 5 + 0xe6546b64;
+		// partial Murmur3 finalizer for avalanching
+		hash ^= hash >> 16;
+		hash *= 0x85ebca6b;
+		hash ^= hash >> 13;
+		//hash *= 0xc2b2ae35;
+		//hash ^= hash >> 16;
+		return hash % f.variant_count;
+	}
+	return (f.param2_variant.get(param2) + f.variant_offset) % f.variant_count;
 }
+#undef rotl32
 
 u8 MapNode::getFaceDir(const NodeDefManager *nodemgr,
 	bool allow_wallmounted) const

src/mapnode.h

@@ -198,9 +198,10 @@ struct alignas(u32) MapNode
 
 	/*!
 	 * Returns the variant of the node.
+	 * \param p position of this node
 	 * \param f content features of this node
 	 */
-	u16 getVariant(const ContentFeatures &f) const;
+	u16 getVariant(const v3s16 &p, const ContentFeatures &f) const;
 
 	inline void setLight(LightBank bank, u8 a_light, ContentLightingFlags f) noexcept
 	{

src/nodedef.cpp

@@ -371,6 +371,7 @@ void ContentFeatures::reset()
 	param_type_2 = CPT2_NONE;
 	variant_count = 1;
 	variant_offset = 0;
+	variant_pos = false;
 	param2_variant = BitField<u8>();
 	is_ground_content = false;
 	light_propagates = false;
@@ -556,6 +557,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
 		for (const TileDef &td : tiledef_special[v])
 			td.serialize(os, protocol_version);
 	}
+	writeU8(os, variant_pos);
 }
 
 void ContentFeatures::deSerialize(std::istream &is, u16 protocol_version)
@@ -723,6 +725,10 @@ void ContentFeatures::deSerialize(std::istream &is, u16 protocol_version)
 			for (TileDef &td : tiledef_special[v])
 				td.deSerialize(is, drawtype, protocol_version);
 		}
+
+		variant_pos  = readU8(is);
+		if (is.eof())
+			throw SerializationError("");
 	} catch (SerializationError &e) {};
 }