Fix relief mapping issues

client/shaders/nodes_shader/opengl_fragment.glsl

@@ -1,6 +1,6 @@
 uniform sampler2D baseTexture;
 uniform sampler2D normalTexture;
-uniform sampler2D useNormalmap;
+uniform sampler2D textureFlags;
 
 uniform vec4 skyBgColor;
 uniform float fogDistance;
@@ -15,19 +15,73 @@ varying vec3 tsEyeVec;
 varying vec3 lightVec;
 varying vec3 tsLightVec;
 
-bool normalTexturePresent = false; 
+bool normalTexturePresent = false;
+bool texTileableHorizontal = false;
+bool texTileableVertical = false;
+bool texSeamless = false;
 
 const float e = 2.718281828459;
 const float BS = 10.0;
-
-float intensity (vec3 color)
+
+void get_texture_flags()
+{
+	vec4 flags = texture2D(textureFlags, vec2(0.0, 0.0));
+	if (flags.r > 0.5) {
+		normalTexturePresent = true;
+	}
+	if (flags.g > 0.5) {
+		texTileableHorizontal = true;
+	}
+	if (flags.b > 0.5) {
+		texTileableVertical = true;
+	}
+	if (texTileableHorizontal && texTileableVertical) {
+		texSeamless = true;
+	}
+}
+
+vec2 validate_displacement(vec2 uv, vec2 ds, float dist)
+{
+	if (texSeamless) {
+		uv += dist * ds;
+	} else if (texTileableVertical == false) {
+		vec2 uv2 = uv + dist * ds;
+		// limit vertical texure displacement
+		if ((uv.y + uv2.y) < 0.0) {
+			uv.y = 0.0;
+		} else if ((uv.y + uv2.y) > 1.999) {
+			uv.y = 0.999;
+		} else {
+			uv.y = uv2.y;
+		}
+		uv.x = uv2.x;
+	} else {
+		vec2 uv2 = uv + dist * ds;
+		// limit horizontal texure displacement 
+		if ((uv.x + uv2.x) < 0.0) {
+			uv.x = 0.0;
+		} else if ((uv.x + uv2.x) > 1.999) {
+			uv.x = 0.999;
+		} else {
+			uv.x = uv2.x;
+		}
+		uv.y = uv2.y;
+	}
+	return uv;
+}
+
+float intensity(vec3 color)
 {
 	return (color.r + color.g + color.b) / 3.0;
 }
 
-float get_rgb_height (vec2 uv)
+float get_rgb_height(vec2 uv)
 {
-	return intensity(texture2D(baseTexture,uv).rgb);
+	if (texSeamless) {
+		return intensity(texture2D(baseTexture, uv).rgb);
+	} else {
+		return intensity(texture2D(baseTexture, clamp(uv, 0.0, 0.999)).rgb);
+	}
 }
 
 vec4 get_normal_map(vec2 uv)
@@ -50,7 +104,8 @@ float find_intersection(vec2 dp, vec2 ds)
 	return depth;
 }
 
-float find_intersectionRGB(vec2 dp, vec2 ds) {
+float find_intersectionRGB(vec2 dp, vec2 ds)
+{
 	const float depth_step = 1.0 / 24.0;
 	float depth = 1.0;
 	for (int i = 0 ; i < 24 ; i++) {
@@ -62,24 +117,19 @@ float find_intersectionRGB(vec2 dp, vec2 ds) {
 	return depth;
 }
 
-void main (void)
+void main(void)
 {
 	vec3 color;
 	vec4 bump;
 	vec2 uv = gl_TexCoord[0].st;
 	bool use_normalmap = false;
-
-#if USE_NORMALMAPS == 1
-	if (texture2D(useNormalmap,vec2(1.0, 1.0)).r > 0.0) {
-		normalTexturePresent = true;
-	}
-#endif
+	get_texture_flags();
 
 #ifdef ENABLE_PARALLAX_OCCLUSION
 	vec2 eyeRay = vec2 (tsEyeVec.x, -tsEyeVec.y);
 	const float scale = PARALLAX_OCCLUSION_SCALE / PARALLAX_OCCLUSION_ITERATIONS;
 	const float bias = PARALLAX_OCCLUSION_BIAS / PARALLAX_OCCLUSION_ITERATIONS;
-		
+
 #if PARALLAX_OCCLUSION_MODE == 0
 	// Parallax occlusion with slope information
 	if (normalTexturePresent && area_enable_parallax > 0.0) {
@@ -89,28 +139,34 @@ void main (void)
 			uv += h * normal.z * eyeRay;
 		}
 #endif
+
 #if PARALLAX_OCCLUSION_MODE == 1
 	// Relief mapping
 	if (normalTexturePresent && area_enable_parallax > 0.0) {
 		vec2 ds = eyeRay * PARALLAX_OCCLUSION_SCALE;
+		// offset the texture by maximum possible displacement,
+		// this will help align seamless and non seamless textures
+		uv -= ds;
 		float dist = find_intersection(uv, ds);
-		uv += dist * ds;
+		uv = validate_displacement(uv, ds, dist);
+
 #endif
 	} else if (GENERATE_NORMALMAPS == 1 && area_enable_parallax > 0.0) {
 		vec2 ds = eyeRay * PARALLAX_OCCLUSION_SCALE;
+		uv -= ds;
 		float dist = find_intersectionRGB(uv, ds);
-		uv += dist * ds;
+		uv = validate_displacement(uv, ds, dist);
 	}
 #endif
 
 #if USE_NORMALMAPS == 1
 	if (normalTexturePresent) {
 		bump = get_normal_map(uv);
 		use_normalmap = true;
-	} 
+	}
 #endif
 
-	if (GENERATE_NORMALMAPS == 1 && use_normalmap == false) {
+	if (GENERATE_NORMALMAPS == 1 && normalTexturePresent == false) {
 		float tl = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y + SAMPLE_STEP));
 		float t  = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y - SAMPLE_STEP));
 		float tr = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y + SAMPLE_STEP));

client/shaders/nodes_shader/opengl_vertex.glsl

@@ -94,7 +94,7 @@ void main(void)
 
 	// Don't generate heightmaps when too far from the eye
 	float dist = distance (vec3(0.0, 0.0 ,0.0), vPosition);
-	if (dist > 120.0) {
+	if (dist > 300.0) {
 		area_enable_parallax = 0.0;
 	}
 

client/shaders/water_surface_shader/opengl_fragment.glsl

@@ -1,6 +1,6 @@
 uniform sampler2D baseTexture;
 uniform sampler2D normalTexture;
-uniform sampler2D useNormalmap;
+uniform sampler2D textureFlags;
 
 uniform vec4 skyBgColor;
 uniform float fogDistance;
@@ -15,37 +15,55 @@ varying vec3 lightVec;
 varying vec3 tsLightVec;
 
 bool normalTexturePresent = false;
+bool texTileableHorizontal = false;
+bool texTileableVertical = false;
+bool texSeamless = false;
 
 const float e = 2.718281828459;
 const float BS = 10.0;
-
-float intensity (vec3 color){
+
+void get_texture_flags()
+{
+	vec4 flags = texture2D(textureFlags, vec2(0.0, 0.0));
+	if (flags.r > 0.5) {
+		normalTexturePresent = true;
+	}
+	if (flags.g > 0.5) {
+		texTileableHorizontal = true;
+	}
+	if (flags.b > 0.5) {
+		texTileableVertical = true;
+	}
+	if (texTileableHorizontal && texTileableVertical) {
+		texSeamless = true;
+	}
+}
+
+float intensity(vec3 color)
+{
 	return (color.r + color.g + color.b) / 3.0;
 }
 
-float get_rgb_height (vec2 uv){
+float get_rgb_height(vec2 uv)
+{
 	return intensity(texture2D(baseTexture,uv).rgb);
 }
 
-vec4 get_normal_map(vec2 uv){
+vec4 get_normal_map(vec2 uv)
+{
 	vec4 bump = texture2D(normalTexture, uv).rgba;
 	bump.xyz = normalize(bump.xyz * 2.0 -1.0);
 	bump.y = -bump.y;
 	return bump;
 }
 
-void main (void)
+void main(void)
 {
 	vec3 color;
 	vec4 bump;
 	vec2 uv = gl_TexCoord[0].st;
 	bool use_normalmap = false;
-
-#ifdef USE_NORMALMAPS
-	if (texture2D(useNormalmap,vec2(1.0,1.0)).r > 0.0) {
-		normalTexturePresent = true;
-	}
-#endif
+	get_texture_flags();
 
 #ifdef ENABLE_PARALLAX_OCCLUSION
 	if (normalTexturePresent) {

doc/lua_api.txt

@@ -3058,8 +3058,13 @@ Definition tables
 ### Tile definition
 * `"image.png"`
 * `{name="image.png", animation={Tile Animation definition}}`
-* `{name="image.png", backface_culling=bool}`
-    * backface culling only supported in special tiles
+* `{name="image.png", backface_culling=bool, tileable_vertical=bool,
+    tileable_horizontal=bool}`
+    * backface culling only supported in special tiles.
+    * tileable flags are info for shaders, how they should treat texture
+	  when displacement mapping is used
+	  Directions are from the point of view of the tile texture,
+	  not the node it's on
 * deprecated, yet still supported field names:
     * `image` (name)
 

games/minimal/mods/default/init.lua

@@ -722,7 +722,9 @@ minetest.register_node("default:stone_with_iron", {
 
 minetest.register_node("default:dirt_with_grass", {
 	description = "Dirt with grass",
-	tiles ={"default_grass.png", "default_dirt.png", "default_dirt.png^default_grass_side.png"},
+	tiles ={"default_grass.png", "default_dirt.png",
+		{name = "default_dirt.png^default_grass_side.png",
+		tileable_vertical = false}},
 	groups = {crumbly=3, soil=1},
 	drop = 'default:dirt',
 	sounds = default.node_sound_dirt_defaults({
@@ -732,7 +734,9 @@ minetest.register_node("default:dirt_with_grass", {
 
 minetest.register_node("default:dirt_with_grass_footsteps", {
 	description = "Dirt with grass and footsteps",
-	tiles ={"default_grass_footsteps.png", "default_dirt.png", "default_dirt.png^default_grass_side.png"},
+	tiles ={"default_grass_footsteps.png", "default_dirt.png",
+		{name = "default_dirt.png^default_grass_side.png",
+		tileable_vertical = false}},
 	groups = {crumbly=3, soil=1},
 	drop = 'default:dirt',
 	sounds = default.node_sound_dirt_defaults({

src/client/tile.cpp

@@ -35,6 +35,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "util/string.h" // for parseColorString()
 #include "imagefilters.h"
 #include "guiscalingfilter.h"
+#include "nodedef.h"
+
 
 #ifdef __ANDROID__
 #include <GLES/gl.h>
@@ -330,7 +332,7 @@ class TextureSource : public IWritableTextureSource
 	*/
 	video::ITexture* getTexture(u32 id);
 
-	video::ITexture* getTexture(const std::string &name, u32 *id);
+	video::ITexture* getTexture(const std::string &name, u32 *id = NULL);
 
 	/*
 		Get a texture specifically intended for mesh
@@ -383,6 +385,7 @@ class TextureSource : public IWritableTextureSource
 
 	video::ITexture* getNormalTexture(const std::string &name);
 	video::SColor getTextureAverageColor(const std::string &name);
+	video::ITexture *getShaderFlagsTexture(TileDef *tiledef, TileSpec *tile);
 
 private:
 
@@ -1992,9 +1995,8 @@ void imageTransform(u32 transform, video::IImage *src, video::IImage *dst)
 
 video::ITexture* TextureSource::getNormalTexture(const std::string &name)
 {
-	u32 id;
 	if (isKnownSourceImage("override_normal.png"))
-		return getTexture("override_normal.png", &id);
+		return getTexture("override_normal.png");
 	std::string fname_base = name;
 	std::string normal_ext = "_normal.png";
 	size_t pos = fname_base.find(".");
@@ -2006,7 +2008,7 @@ video::ITexture* TextureSource::getNormalTexture(const std::string &name)
 			fname_base.replace(i, 4, normal_ext);
 			i += normal_ext.length();
 		}
-		return getTexture(fname_base, &id);
+		return getTexture(fname_base);
 		}
 	return NULL;
 }
@@ -2015,8 +2017,7 @@ video::SColor TextureSource::getTextureAverageColor(const std::string &name)
 {
 	video::IVideoDriver *driver = m_device->getVideoDriver();
 	video::SColor c(0, 0, 0, 0);
-	u32 id;
-	video::ITexture *texture = getTexture(name, &id);
+	video::ITexture *texture = getTexture(name);
 	video::IImage *image = driver->createImage(texture,
 		core::position2d<s32>(0, 0),
 		texture->getOriginalSize());
@@ -2048,3 +2049,31 @@ video::SColor TextureSource::getTextureAverageColor(const std::string &name)
 	c.setAlpha(255);
 	return c;
 }
+
+video::ITexture *TextureSource::getShaderFlagsTexture(TileDef *tiledef, TileSpec *tile)
+{
+	std::string tname = "__shaderFlagsTexture";
+
+	bool normalmap_present = tile->normal_texture ? true : false;
+	tname += normalmap_present ? "1" : "0";
+	tname += tiledef->tileable_horizontal ? "1" : "0";
+	tname += tiledef->tileable_vertical ? "1" : "0";
+
+	if (isKnownSourceImage(tname)) {
+		return getTexture(tname);
+	} else {
+		video::IVideoDriver *driver = m_device->getVideoDriver();
+		video::IImage *flags_image = driver->createImage(
+			video::ECF_A8R8G8B8, core::dimension2d<u32>(1, 1));
+		sanity_check(flags_image != NULL);
+		video::SColor c(
+			255,
+			normalmap_present ? 255 : 0,
+			tiledef->tileable_horizontal ? 255 : 0,
+			tiledef->tileable_vertical ? 255 : 0);
+		flags_image->setPixel(0, 0, c);
+		insertSourceImage(tname, flags_image);
+		flags_image->drop();
+		return getTexture(tname);
+	}
+}