Sim (#11)

* Wheels animation distance changed to 200*D*LODbias

* Fixed spelling error in event syntax; old one remains for compatibility.

* Spelling error left in log text

* Zamiana metalic na floata z wazonym efektem.

# Conflicts:
#	shaders/light_common.glsl

* Detail normalmap shaders @Jan21

* Explicit type conversion

* Leftover metalic as bool

* Syntax error

* Normalmap sampling inside ParallaxMapping function

DynObj.cpp

@@ -4974,9 +4974,8 @@ void TDynamicObject::LoadMMediaFile( std::string const &TypeName, std::string co
                         { //++iAnimatedAxles;
                             pAnimations[i].smAnimated->WillBeAnimated(); // wyłączenie optymalizacji transformu
 							pAnimations[i].yUpdate = std::bind( &TDynamicObject::UpdateAxle, this, std::placeholders::_1 );
-                            pAnimations[i].fMaxDist = 50 * MoverParameters->WheelDiameter; // nie kręcić w większej odległości
-                            pAnimations[i].fMaxDist *= pAnimations[i].fMaxDist * MoverParameters->WheelDiameter; // 50m do kwadratu, a średnica do trzeciej
-                            pAnimations[i].fMaxDist *= Global.fDistanceFactor; // współczynnik przeliczeniowy jakości ekranu
+							pAnimations[i].fMaxDist = Global.fDistanceFactor * MoverParameters->WheelDiameter * 200;
+							pAnimations[i].fMaxDist *= pAnimations[i].fMaxDist;
                         }
                     }
                     // Ra: ustawianie indeksów osi

Event.cpp

@@ -192,7 +192,7 @@ basic_event::event_conditions::deserialize( cParser &Input ) {
         else if( token == "trackfree" ) {
             flags |= flags::track_free;
         }
-        else if( token == "propability" ) {
+        else if( token == "propability" || "probability") { //remove propability in few years after changing old scenery scripts 01.2021
             flags |= flags::probability;
             Input.getTokens();
             Input >> probability;
@@ -267,7 +267,7 @@ basic_event::event_conditions::export_as_text( std::ostream &Output ) const {
         }
         if( ( flags & flags::probability ) != 0 ) {
             Output
-                << "propability "
+                << "probability "
                 << probability << ' ';
         }
         if( ( flags & ( flags::text | flags::value1 | flags::value2 ) ) != 0 ) {

shaders/light_common.glsl

@@ -1,182 +1,177 @@
-#if SHADOWMAP_ENABLED
-in vec4 f_light_pos[MAX_CASCADES];
-uniform sampler2DArrayShadow shadowmap;
-#endif
-uniform sampler2D headlightmap;
-
-#include <envmapping.glsl>
-#include <conversion.glsl>
-
-float glossiness = 1.0;
-bool metalic = false;
-
-float length2(vec3 v)
-{
-        return dot(v, v);
-}
-
-float calc_shadow()
-{
-#if SHADOWMAP_ENABLED
-	float distance = dot(f_pos.xyz, f_pos.xyz);
-	uint cascade;
-	for (cascade = 0U; cascade < MAX_CASCADES; cascade++)
-		if (distance <= cascade_end[cascade])
-			break;
-
-	vec3 coords = f_light_pos[cascade].xyz / f_light_pos[cascade].w;
-	if (coords.z < 0.0f)
-		return 0.0f;
-
-	float shadow = 0.0;
-	//basic
-//	shadow = texture(shadowmap, coords.xyz + vec3(0.0, 0.0, bias));
-	//PCF
-	float bias = 0.00005f * float(cascade + 1U);
-	vec2 texel = vec2(1.0) / vec2(textureSize(shadowmap, 0));
-	float radius = 1.0;
-	for (float y = -1.5; y <= 1.5; y += 1.0)
-		for (float x = -1.5; x <= 1.5; x += 1.0)
-			shadow += texture( shadowmap, vec4(coords.xy + vec2(x, y) * radius * texel, cascade, coords.z + bias) );
-	shadow /= 16.0;
-
-	return shadow;
-#else
-	return 0.0;
-#endif
-}
-
-vec2 calc_light(vec3 light_dir, vec3 fragnormal)
-{
-	vec3 view_dir = normalize(vec3(0.0f, 0.0f, 0.0f) - f_pos.xyz);
-	vec3 halfway_dir = normalize(light_dir + view_dir);
-
-	float diffuse_v = max(dot(fragnormal, light_dir), 0.0);
-	float specular_v = pow(max(dot(fragnormal, halfway_dir), 0.0), max(glossiness, 0.01)) * diffuse_v;
-
-	return vec2(diffuse_v, specular_v);
-}
-
-vec2 calc_point_light(light_s light, vec3 fragnormal)
-{
-	vec3 light_dir = normalize(light.pos - f_pos.xyz);
-	vec2 val = calc_light(light_dir, fragnormal);
-	val.x += light.ambient;
-	val *= light.intensity;
-	
-	float distance = length(light.pos - f_pos.xyz);
-	float atten = 1.0f / (1.0f + light.linear * distance + light.quadratic * (distance * distance));
-	
-	return val * atten;
-}
-
-vec2 calc_spot_light(light_s light, vec3 fragnormal)
-{
-	vec3 light_dir = normalize(light.pos - f_pos.xyz);
-	
-	float theta = dot(light_dir, normalize(-light.dir));
-	float epsilon = light.in_cutoff - light.out_cutoff;
-	float intensity = clamp((theta - light.out_cutoff) / epsilon, 0.0, 1.0);
-
-	vec2 point = calc_point_light(light, fragnormal);	
-	return point * intensity;
-}
-
-vec2 calc_dir_light(light_s light, vec3 fragnormal)
-{
-	vec3 light_dir = normalize(-light.dir);
-	return calc_light(light_dir, fragnormal);
-}
-
-vec2 calc_headlights(light_s light, vec3 fragnormal)
-{
-	vec4 headlightpos = light.headlight_projection * f_pos;
-	vec3 coords = headlightpos.xyz / headlightpos.w;
-
-	if (coords.z > 1.0)
-		return vec2(0.0);
-	if (coords.z < 0.0)
-		return vec2(0.0);
-
-	vec3 light_dir = normalize(light.pos - f_pos.xyz);
-	vec2 part = vec2(1.0) * clamp(dot(fragnormal, light_dir) + 0.25, 0.0, 1.0);
-	float distance = length(light.pos - f_pos.xyz);
-	float atten = 1.0f / (1.0f + light.linear * distance + light.quadratic * (distance * distance));
-	atten *= mix(1.0, 0.0, clamp((coords.z - 0.998) * 500.0, 0.0, 1.0));
-	vec3 lights = textureProj(headlightmap, headlightpos).rgb * light.headlight_weights.rgb;
-	float lightintensity = max(max(lights.r, lights.g), lights.b);
-	return part * atten * lightintensity;
-}
-
-// [0] - diffuse, [1] - specular
-// do magic here
-vec3 apply_lights(vec3 fragcolor, vec3 fragnormal, vec3 texturecolor, float reflectivity, float specularity, float shadowtone)
-{
-	vec3 basecolor = param[0].rgb;
-
-	fragcolor *= basecolor;
-
-	vec3 emissioncolor = basecolor * emission;
-	vec3 envcolor = envmap_color(fragnormal);
-
-// yuv path
-	vec3 texturecoloryuv = rgb2yuv(texturecolor);
-	vec3 texturecolorfullv = yuv2rgb(vec3(0.2176, texturecoloryuv.gb));
-// hsl path
-//	vec3 texturecolorhsl = rgb2hsl(texturecolor);
-//	vec3 texturecolorfullv = hsl2rgb(vec3(texturecolorhsl.rg, 0.5));
-
-	vec3 envyuv = rgb2yuv(envcolor);
-	texturecolor = mix(texturecolor, texturecolorfullv, envyuv.r * reflectivity);
-
-	if(lights_count == 0U) 
-		return (fragcolor + emissioncolor + envcolor * reflectivity) * texturecolor;
-
-//	fragcolor *= lights[0].intensity;
-	vec2 sunlight = calc_dir_light(lights[0], fragnormal);
-
-	float diffuseamount = (sunlight.x * param[1].x) * lights[0].intensity;
-//	fragcolor += mix(lights[0].color * diffuseamount, envcolor, reflectivity);
-	fragcolor += lights[0].color * diffuseamount;
-	fragcolor = mix(fragcolor, envcolor, reflectivity);
-
-	for (uint i = 1U; i < lights_count; i++)
-	{
-		light_s light = lights[i];
-		vec2 part = vec2(0.0);
-
-//		if (light.type == LIGHT_SPOT)
-//			part = calc_spot_light(light, fragnormal);
-//		else if (light.type == LIGHT_POINT)
-//			part = calc_point_light(light, fragnormal);
-//		else if (light.type == LIGHT_DIR)
-//			part = calc_dir_light(light, fragnormal);
-//		else if (light.type == LIGHT_HEADLIGHTS)
-			part = calc_headlights(light, fragnormal);
-
-		fragcolor += light.color * (part.x * param[1].x + part.y * param[1].y) * light.intensity;
-	}
-
-	float specularamount = (sunlight.y * param[1].y * specularity) * lights[0].intensity * clamp(1.0 - shadowtone, 0.0, 1.0);
-	if (shadowtone < 1.0)
-	{
-		float shadow = calc_shadow();
-		specularamount *= clamp(1.0 - shadow, 0.0, 1.0);
-		fragcolor = mix(fragcolor,  fragcolor * shadowtone,  clamp(diffuseamount * shadow + specularamount, 0.0, 1.0));
-	}
-	fragcolor += emissioncolor;
-	vec3 specularcolor = specularamount * lights[0].color;
-
-	if ((param[1].w < 0.0) || (metalic == true))
-	{
-		fragcolor += specularcolor;
-		fragcolor *= texturecolor;
-	}
-	else
-	{
-		fragcolor *= texturecolor;
-		fragcolor += specularcolor;
-	}
-
-	return fragcolor;
-}
+#if SHADOWMAP_ENABLED
+in vec4 f_light_pos[MAX_CASCADES];
+uniform sampler2DArrayShadow shadowmap;
+#endif
+uniform sampler2D headlightmap;
+
+#include <envmapping.glsl>
+#include <conversion.glsl>
+
+float glossiness = 1.0;
+float metalic = 0.0;
+
+float length2(vec3 v)
+{
+        return dot(v, v);
+}
+
+float calc_shadow()
+{
+#if SHADOWMAP_ENABLED
+	float distance = dot(f_pos.xyz, f_pos.xyz);
+	uint cascade;
+	for (cascade = 0U; cascade < MAX_CASCADES; cascade++)
+		if (distance <= cascade_end[cascade])
+			break;
+
+	vec3 coords = f_light_pos[cascade].xyz / f_light_pos[cascade].w;
+	if (coords.z < 0.0f)
+		return 0.0f;
+
+	float shadow = 0.0;
+	//basic
+//	shadow = texture(shadowmap, coords.xyz + vec3(0.0, 0.0, bias));
+	//PCF
+	float bias = 0.00005f * float(cascade + 1U);
+	vec2 texel = vec2(1.0) / vec2(textureSize(shadowmap, 0));
+	float radius = 1.0;
+	for (float y = -1.5; y <= 1.5; y += 1.0)
+		for (float x = -1.5; x <= 1.5; x += 1.0)
+			shadow += texture( shadowmap, vec4(coords.xy + vec2(x, y) * radius * texel, cascade, coords.z + bias) );
+	shadow /= 16.0;
+
+	return shadow;
+#else
+	return 0.0;
+#endif
+}
+
+vec2 calc_light(vec3 light_dir, vec3 fragnormal)
+{
+	vec3 view_dir = normalize(vec3(0.0f, 0.0f, 0.0f) - f_pos.xyz);
+	vec3 halfway_dir = normalize(light_dir + view_dir);
+
+	float diffuse_v = max(dot(fragnormal, light_dir), 0.0);
+	float specular_v = pow(max(dot(fragnormal, halfway_dir), 0.0), max(glossiness, 0.01)) * diffuse_v;
+
+	return vec2(diffuse_v, specular_v);
+}
+
+vec2 calc_point_light(light_s light, vec3 fragnormal)
+{
+	vec3 light_dir = normalize(light.pos - f_pos.xyz);
+	vec2 val = calc_light(light_dir, fragnormal);
+	val.x += light.ambient;
+	val *= light.intensity;
+	
+	float distance = length(light.pos - f_pos.xyz);
+	float atten = 1.0f / (1.0f + light.linear * distance + light.quadratic * (distance * distance));
+	
+	return val * atten;
+}
+
+vec2 calc_spot_light(light_s light, vec3 fragnormal)
+{
+	vec3 light_dir = normalize(light.pos - f_pos.xyz);
+	
+	float theta = dot(light_dir, normalize(-light.dir));
+	float epsilon = light.in_cutoff - light.out_cutoff;
+	float intensity = clamp((theta - light.out_cutoff) / epsilon, 0.0, 1.0);
+
+	vec2 point = calc_point_light(light, fragnormal);	
+	return point * intensity;
+}
+
+vec2 calc_dir_light(light_s light, vec3 fragnormal)
+{
+	vec3 light_dir = normalize(-light.dir);
+	return calc_light(light_dir, fragnormal);
+}
+
+vec2 calc_headlights(light_s light, vec3 fragnormal)
+{
+	vec4 headlightpos = light.headlight_projection * f_pos;
+	vec3 coords = headlightpos.xyz / headlightpos.w;
+
+	if (coords.z > 1.0)
+		return vec2(0.0);
+	if (coords.z < 0.0)
+		return vec2(0.0);
+
+	vec3 light_dir = normalize(light.pos - f_pos.xyz);
+	vec2 part = vec2(1.0) * clamp(dot(fragnormal, light_dir) + 0.25, 0.0, 1.0);
+	float distance = length(light.pos - f_pos.xyz);
+	float atten = 1.0f / (1.0f + light.linear * distance + light.quadratic * (distance * distance));
+	atten *= mix(1.0, 0.0, clamp((coords.z - 0.998) * 500.0, 0.0, 1.0));
+	vec3 lights = textureProj(headlightmap, headlightpos).rgb * light.headlight_weights.rgb;
+	float lightintensity = max(max(lights.r, lights.g), lights.b);
+	return part * atten * lightintensity;
+}
+
+// [0] - diffuse, [1] - specular
+// do magic here
+vec3 apply_lights(vec3 fragcolor, vec3 fragnormal, vec3 texturecolor, float reflectivity, float specularity, float shadowtone)
+{
+	vec3 basecolor = param[0].rgb;
+
+	fragcolor *= basecolor;
+
+	vec3 emissioncolor = basecolor * emission;
+	vec3 envcolor = envmap_color(fragnormal);
+
+// yuv path
+	vec3 texturecoloryuv = rgb2yuv(texturecolor);
+	vec3 texturecolorfullv = yuv2rgb(vec3(0.2176, texturecoloryuv.gb));
+// hsl path
+//	vec3 texturecolorhsl = rgb2hsl(texturecolor);
+//	vec3 texturecolorfullv = hsl2rgb(vec3(texturecolorhsl.rg, 0.5));
+
+	vec3 envyuv = rgb2yuv(envcolor);
+	texturecolor = mix(texturecolor, texturecolorfullv, envyuv.r * reflectivity);
+
+	if(lights_count == 0U) 
+		return (fragcolor + emissioncolor + envcolor * reflectivity) * texturecolor;
+
+//	fragcolor *= lights[0].intensity;
+	vec2 sunlight = calc_dir_light(lights[0], fragnormal);
+
+	float diffuseamount = (sunlight.x * param[1].x) * lights[0].intensity;
+//	fragcolor += mix(lights[0].color * diffuseamount, envcolor, reflectivity);
+	fragcolor += lights[0].color * diffuseamount;
+	fragcolor = mix(fragcolor, envcolor, reflectivity);
+
+	for (uint i = 1U; i < lights_count; i++)
+	{
+		light_s light = lights[i];
+		vec2 part = vec2(0.0);
+
+//		if (light.type == LIGHT_SPOT)
+//			part = calc_spot_light(light, fragnormal);
+//		else if (light.type == LIGHT_POINT)
+//			part = calc_point_light(light, fragnormal);
+//		else if (light.type == LIGHT_DIR)
+//			part = calc_dir_light(light, fragnormal);
+//		else if (light.type == LIGHT_HEADLIGHTS)
+			part = calc_headlights(light, fragnormal);
+
+		fragcolor += light.color * (part.x * param[1].x + part.y * param[1].y) * light.intensity;
+	}
+
+	float specularamount = (sunlight.y * param[1].y * specularity) * lights[0].intensity * clamp(1.0 - shadowtone, 0.0, 1.0);
+	if (shadowtone < 1.0)
+	{
+		float shadow = calc_shadow();
+		specularamount *= clamp(1.0 - shadow, 0.0, 1.0);
+		fragcolor = mix(fragcolor,  fragcolor * shadowtone,  clamp(diffuseamount * shadow + specularamount, 0.0, 1.0));
+	}
+	fragcolor += emissioncolor;
+	vec3 specularcolor = specularamount * lights[0].color;
+
+	if (param[1].w < 0.0)
+		{
+		float metalic = 1.0;
+		}
+	fragcolor = mix(((fragcolor + specularcolor) * texturecolor),(fragcolor * texturecolor + specularcolor),metalic) ;
+
+	return fragcolor;
+}

shaders/mat_default_specgloss.frag

@@ -43,7 +43,7 @@ void main()
 	float reflectivity = param[1].z;
 	float specularity = texture(specgloss, f_coord).r;
 	glossiness = texture(specgloss, f_coord).g * abs(param[1].w);
-	metalic = (texture(specgloss, f_coord).b > 0.5) ? true : false;
+	float metalic = texture(specgloss, f_coord).b;
 	
 	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
 	vec4 color = vec4(apply_fog(fragcolor), tex_color.a * alpha_mult);

shaders/mat_detail_normalmap.frag

@@ -0,0 +1,81 @@
+in vec3 f_normal;
+in vec2 f_coord;
+in vec4 f_pos;
+in mat3 f_tbn;
+
+in vec4 f_clip_pos;
+in vec4 f_clip_future_pos;
+
+#include <common>
+
+layout(location = 0) out vec4 out_color;
+#if MOTIONBLUR_ENABLED
+layout(location = 1) out vec4 out_motion;
+#endif
+
+#param (color, 0, 0, 4, diffuse)
+#param (diffuse, 1, 0, 1, diffuse)
+#param (specular, 1, 1, 1, specular)
+#param (reflection, 1, 2, 1, one)
+#param (glossiness, 1, 3, 1, glossiness)
+#param (detail_scale, 2, 0, 1, one)
+#param (detail_height_scale, 2, 1, 1, one)
+
+#texture (diffuse, 0, sRGB_A)
+uniform sampler2D diffuse;
+
+#texture (normalmap, 1, RGBA)
+uniform sampler2D normalmap;
+
+#texture (detailnormalmap, 2, RGBA)
+uniform sampler2D detailnormalmap;
+
+#define NORMALMAP
+#include <light_common.glsl>
+#include <apply_fog.glsl>
+#include <tonemapping.glsl>
+
+void main()
+{
+	vec4 tex_color = texture(diffuse, f_coord);
+
+	bool alphatestfail = ( opacity >= 0.0 ? (tex_color.a < opacity) : (tex_color.a >= -opacity) );
+	if(alphatestfail)
+		discard;
+
+	vec3 fragcolor = ambient;
+	
+	vec4 normal_map = texture(normalmap, f_coord);
+	vec4 detailnormal_map = texture(detailnormalmap, f_coord * param[2].x);
+	vec3 normal;
+	vec3 normaldetail;
+	
+	normaldetail.xy = detailnormal_map.rg* 2.0 - 1.0;
+	normaldetail.z = sqrt(1.0 - clamp((dot(normaldetail.xy, normaldetail.xy)), 0.0, 1.0));
+	normaldetail.xyz = normaldetail.xyz * param[2].y;
+	normal.xy =       normal_map.rg* 2.0 - 1.0;
+	normal.z = sqrt(1.0 - clamp((dot(normal.xy, normal.xy)), 0.0, 1.0));
+	
+	vec3 fragnormal = normalize(f_tbn * normalize(vec3(normal.xy + normaldetail.xy, normal.z)));
+	
+
+	float reflblend = (normal_map.a + detailnormal_map.a);
+	float reflectivity = reflblend > 1.0 ? param[1].z * 1.0 : param[1].z * reflblend;
+	float specularity = (tex_color.r + tex_color.g + tex_color.b) * 0.5;
+	
+	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
+	vec4 color = vec4(apply_fog(fragcolor), tex_color.a * alpha_mult);
+#if POSTFX_ENABLED
+    out_color = color;
+#else
+    out_color = tonemap(color);
+#endif
+#if MOTIONBLUR_ENABLED
+	{
+        vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
+        vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
+        
+        out_motion = vec4(a - b, 0.0f, 0.0f);
+	}
+#endif
+}

shaders/mat_detail_normalmap_specgloss.frag

@@ -0,0 +1,89 @@
+in vec3 f_normal;
+in vec2 f_coord;
+in vec4 f_pos;
+in mat3 f_tbn;
+
+in vec4 f_clip_pos;
+in vec4 f_clip_future_pos;
+
+#include <common>
+
+layout(location = 0) out vec4 out_color;
+#if MOTIONBLUR_ENABLED
+layout(location = 1) out vec4 out_motion;
+#endif
+
+#param (color, 0, 0, 4, diffuse)
+#param (diffuse, 1, 0, 1, diffuse)
+#param (specular, 1, 1, 1, specular)
+#param (reflection, 1, 2, 1, one)
+#param (glossiness, 1, 3, 1, glossiness)
+#param (detail_scale, 2, 0, 1, one)
+#param (detail_height_scale, 2, 1, 1, one)
+
+#texture (diffuse, 0, sRGB_A)
+uniform sampler2D diffuse;
+
+#texture (normalmap, 1, RGBA)
+uniform sampler2D normalmap;
+
+#texture (detailnormalmap, 2, RGBA)
+uniform sampler2D detailnormalmap;
+
+#texture (specgloss, 3, RGBA)
+uniform sampler2D specgloss;
+
+#define NORMALMAP
+#include <light_common.glsl>
+#include <apply_fog.glsl>
+#include <tonemapping.glsl>
+
+void main()
+{
+	vec4 tex_color = texture(diffuse, f_coord);
+
+	bool alphatestfail = ( opacity >= 0.0 ? (tex_color.a < opacity) : (tex_color.a >= -opacity) );
+	if(alphatestfail)
+		discard;
+//	if (tex_color.a < opacity)
+//		discard;
+
+	vec3 fragcolor = ambient;
+	
+	vec4 normal_map = texture(normalmap, f_coord);
+	vec4 detailnormal_map = texture(detailnormalmap, f_coord * param[2].x);
+	vec4 specgloss_map = texture(specgloss, f_coord);
+	vec3 normal;
+	vec3 normaldetail;
+	
+	normaldetail.xy = detailnormal_map.rg* 2.0 - 1.0;
+	normaldetail.z = sqrt(1.0 - clamp((dot(normaldetail.xy, normaldetail.xy)), 0.0, 1.0));
+	normaldetail.xyz = normaldetail.xyz * param[2].y;
+	normal.xy =       normal_map.rg* 2.0 - 1.0;
+	normal.z = sqrt(1.0 - clamp((dot(normal.xy, normal.xy)), 0.0, 1.0));
+	
+	vec3 fragnormal = normalize(f_tbn * normalize(vec3(normal.xy + normaldetail.xy, normal.z)));
+	
+	float reflblend = (normal_map.a + detailnormal_map.a);
+	float reflectivity = reflblend > 1.0 ? param[1].z * 1.0 : param[1].z * reflblend;
+	float specularity = specgloss_map.r;
+	glossiness = specgloss_map.g * abs(param[1].w);
+	float metalic = specgloss_map.b;
+	
+	
+	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
+	vec4 color = vec4(apply_fog(fragcolor), tex_color.a * alpha_mult);
+#if POSTFX_ENABLED
+    out_color = color;
+#else
+    out_color = tonemap(color);
+#endif
+#if MOTIONBLUR_ENABLED
+	{
+        vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
+        vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
+        
+        out_motion = vec4(a - b, 0.0f, 0.0f);
+	}
+#endif
+}

shaders/mat_detail_parallax.frag

@@ -0,0 +1,134 @@
+in vec3 f_normal;
+in vec2 f_coord;
+in vec4 f_pos;
+in mat3 f_tbn; //tangent matrix nietransponowany; mnożyć przez f_tbn dla TangentLightPos; TangentViewPos; TangentFragPos;
+in vec4 f_clip_pos;
+in vec4 f_clip_future_pos;
+in vec3 TangentFragPos;
+
+#include <common>
+
+layout(location = 0) out vec4 out_color;
+#if MOTIONBLUR_ENABLED
+layout(location = 1) out vec4 out_motion;
+#endif
+
+
+#param (color, 0, 0, 4, diffuse)
+#param (diffuse, 1, 0, 1, diffuse)
+#param (specular, 1, 1, 1, specular)
+#param (reflection, 1, 2, 1, one)
+#param (glossiness, 1, 3, 1, glossiness)
+#param (detail_scale, 2, 0, 1, one)
+#param (detail_height_scale, 2, 1, 1, one)
+#param (height_scale, 2, 2, 1, zero)
+#param (height_offset, 2, 3, 1, zero)
+
+#texture (diffuse, 0, sRGB_A)
+uniform sampler2D diffuse;
+
+#texture (normalmap, 1, RGBA)
+uniform sampler2D normalmap;
+
+#texture (detailnormalmap, 2, RGBA)
+uniform sampler2D detailnormalmap;
+
+#define PARALLAX
+#include <light_common.glsl>
+#include <apply_fog.glsl>
+#include <tonemapping.glsl>
+
+vec2 ParallaxMapping(vec2 f_coord, vec3 viewDir);
+
+void main()
+{
+	//parallax mapping
+	vec3 viewDir = normalize(-TangentFragPos); //tangent view pos - tangent frag pos
+	vec2 f_coord_p = ParallaxMapping(f_coord, viewDir);
+	vec4 normal_map = texture(normalmap, f_coord_p);
+	vec4 detailnormal_map = texture(detailnormalmap, f_coord_p * param[2].x);
+	vec4 tex_color = texture(diffuse, f_coord_p);
+
+	bool alphatestfail = ( opacity >= 0.0 ? (tex_color.a < opacity) : (tex_color.a >= -opacity) );
+	if(alphatestfail)
+		discard;
+//	if (tex_color.a < opacity)
+//		discard;
+
+	vec3 fragcolor = ambient;
+
+	vec3 normal;
+	vec3 normaldetail;
+	
+	normaldetail.xy = detailnormal_map.rg* 2.0 - 1.0;
+	normaldetail.z = sqrt(1.0 - clamp((dot(normaldetail.xy, normaldetail.xy)), 0.0, 1.0));
+	normaldetail.xyz = normaldetail.xyz * param[2].y;
+	normal.xy =       normal_map.rg* 2.0 - 1.0;
+	normal.z = sqrt(1.0 - clamp((dot(normal.xy, normal.xy)), 0.0, 1.0));
+	
+	vec3 fragnormal = normalize(f_tbn * normalize(vec3(normal.xy + normaldetail.xy, normal.z)));
+	float reflectivity = param[1].z * normal_map.a;
+	float specularity = (tex_color.r + tex_color.g + tex_color.b) * 0.5;	
+	
+	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
+
+	vec4 color = vec4(apply_fog(fragcolor), tex_color.a * alpha_mult);
+#if POSTFX_ENABLED
+	out_color = color;
+#else
+	out_color = tonemap(color);
+#endif
+#if MOTIONBLUR_ENABLED
+	{
+		vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
+		vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
+
+		out_motion = vec4(a - b, 0.0f, 0.0f);
+	}
+#endif
+}
+
+vec2 ParallaxMapping(vec2 f_coord, vec3 viewDir)
+{
+	float pos_len = length(f_pos.xyz);
+
+	if (pos_len > 100.0) {
+		return f_coord;
+	}
+
+#if EXTRAEFFECTS_ENABLED
+	const float minLayers = 8.0;
+	const float maxLayers = 32.0;
+	float LayersWeight = pos_len / 20.0;
+	vec2  currentTexCoords = f_coord;
+	float currentDepthMapValue = texture(normalmap, currentTexCoords).b;
+	LayersWeight = min(abs(dot(vec3(0.0, 0.0, 1.0), viewDir)),LayersWeight);
+	float numLayers = mix(maxLayers, minLayers, clamp(LayersWeight, 0.0, 1.0)); // number of depth layers
+	float layerDepth = 1.0 / numLayers; // calculate the size of each layer
+	float currentLayerDepth = 0.0; // depth of current layer
+	vec2 P = viewDir.xy * param[2].z; // the amount to shift the texture coordinates per layer (from vector P)
+	vec2 deltaTexCoords = P / numLayers;
+
+	  
+	while(currentLayerDepth < currentDepthMapValue)
+	{
+		currentTexCoords -= deltaTexCoords;		// shift texture coordinates along direction of P
+		currentDepthMapValue = texture(normalmap, currentTexCoords).b;		// get depthmap value at current texture coordinates
+		currentLayerDepth += layerDepth;  		// get depth of next layer
+	}
+	
+	vec2 prevTexCoords = currentTexCoords + deltaTexCoords; // get texture coordinates before collision (reverse operations)
+
+	float afterDepth  = currentDepthMapValue - currentLayerDepth; // get depth after and before collision for linear interpolation
+	float beforeDepth = texture(normalmap, prevTexCoords).b - currentLayerDepth + layerDepth;
+	 
+	float weight = afterDepth / (afterDepth - beforeDepth); // interpolation of texture coordinates
+	vec2 finalTexCoords = prevTexCoords * weight + currentTexCoords * (1.0 - weight);
+
+	return finalTexCoords;
+#else
+	float height = texture(normalmap, f_coord).b;
+	vec2 p = viewDir.xy / viewDir.z * (height * (param[2].z - param[2].w) * 0.2);
+	return f_coord - p;
+#endif
+} 

shaders/mat_detail_parallax_specgloss.frag

@@ -0,0 +1,141 @@
+in vec3 f_normal;
+in vec2 f_coord;
+in vec4 f_pos;
+in mat3 f_tbn; //tangent matrix nietransponowany; mnożyć przez f_tbn dla TangentLightPos; TangentViewPos; TangentFragPos;
+in vec4 f_clip_pos;
+in vec4 f_clip_future_pos;
+in vec3 TangentFragPos;
+
+#include <common>
+
+layout(location = 0) out vec4 out_color;
+#if MOTIONBLUR_ENABLED
+layout(location = 1) out vec4 out_motion;
+#endif
+
+
+#param (color, 0, 0, 4, diffuse)
+#param (diffuse, 1, 0, 1, diffuse)
+#param (specular, 1, 1, 1, specular)
+#param (reflection, 1, 2, 1, one)
+#param (glossiness, 1, 3, 1, glossiness)
+#param (detail_scale, 2, 0, 1, one)
+#param (detail_height_scale, 2, 1, 1, one)
+#param (height_scale, 2, 2, 1, zero)
+#param (height_offset, 2, 3, 1, zero)
+
+#texture (diffuse, 0, sRGB_A)
+uniform sampler2D diffuse;
+
+#texture (normalmap, 1, RGBA)
+uniform sampler2D normalmap;
+
+#texture (specgloss, 2, RGBA)
+uniform sampler2D specgloss;
+
+#texture (detailnormalmap, 3, RGBA)
+uniform sampler2D detailnormalmap;
+
+
+#define PARALLAX
+#include <light_common.glsl>
+#include <apply_fog.glsl>
+#include <tonemapping.glsl>
+
+vec2 ParallaxMapping(vec2 f_coord, vec3 viewDir);
+
+void main()
+{
+	//parallax mapping
+	vec3 viewDir = normalize(vec3(0.0f, 0.0f, 0.0f) - TangentFragPos); //tangent view pos - tangent frag pos
+	vec2 f_coord_p = ParallaxMapping(f_coord, viewDir);
+	
+	vec4 normal_map = texture(normalmap, f_coord_p);
+	vec4 detailnormal_map = texture(detailnormalmap,  f_coord_p * param[2].x);
+	vec4 tex_color = texture(diffuse, f_coord_p);
+	vec4 specgloss_map = texture(specgloss,  f_coord_p);
+	
+	bool alphatestfail = ( opacity >= 0.0 ? (tex_color.a < opacity) : (tex_color.a >= -opacity) );
+	if(alphatestfail)
+		discard;
+
+	vec3 fragcolor = ambient;
+
+	vec3 normal;
+	vec3 normaldetail;
+	
+	normaldetail.xy = detailnormal_map.rg* 2.0 - 1.0;
+	normaldetail.z = sqrt(1.0 - clamp((dot(normaldetail.xy, normaldetail.xy)), 0.0, 1.0));
+	normaldetail.xyz = normaldetail.xyz * param[2].y;
+	normal.xy = normal_map.rg* 2.0 - 1.0;
+	normal.z = sqrt(1.0 - clamp((dot(normal.xy, normal.xy)), 0.0, 1.0));
+	
+	vec3 fragnormal = normalize(f_tbn * normalize(vec3(normal.xy + normaldetail.xy, normal.z)));
+	float reflectivity = param[1].z * normal_map.a;
+	float specularity = specgloss_map.r;
+	float glossiness = specgloss_map.g * abs(param[1].w);
+	float metalic = specgloss_map.b;
+	
+	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
+
+	vec4 color = vec4(apply_fog(fragcolor), tex_color.a * alpha_mult);
+#if POSTFX_ENABLED
+	out_color = color;
+#else
+	out_color = tonemap(color);
+#endif
+#if MOTIONBLUR_ENABLED
+	{
+		vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
+		vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
+
+		out_motion = vec4(a - b, 0.0f, 0.0f);
+	}
+#endif
+}
+
+vec2 ParallaxMapping(vec2 f_coord, vec3 viewDir)
+{	
+
+	float pos_len = length(f_pos.xyz);
+
+	if (pos_len > 100.0) {
+		return f_coord;
+	}
+
+#if EXTRAEFFECTS_ENABLED
+	const float minLayers = 8.0;
+	const float maxLayers = 32.0;
+	float LayersWeight = pos_len / 20.0;
+	vec2  currentTexCoords = f_coord;
+	float currentDepthMapValue = texture(normalmap, currentTexCoords).b;
+	LayersWeight = min(abs(dot(vec3(0.0, 0.0, 1.0), viewDir)),LayersWeight);
+	float numLayers = mix(maxLayers, minLayers, clamp(LayersWeight, 0.0, 1.0)); // number of depth layers
+	float layerDepth = 1.0 / numLayers; // calculate the size of each layer
+	float currentLayerDepth = 0.0; // depth of current layer
+	vec2 P = viewDir.xy * param[2].z; // the amount to shift the texture coordinates per layer (from vector P)
+	vec2 deltaTexCoords = P / numLayers;
+
+	  
+	while(currentLayerDepth < currentDepthMapValue)
+	{
+		currentTexCoords -= deltaTexCoords;		// shift texture coordinates along direction of P
+		currentDepthMapValue = texture(normalmap, currentTexCoords).b;		// get depthmap value at current texture coordinates
+		currentLayerDepth += layerDepth;  		// get depth of next layer
+	}
+	
+	vec2 prevTexCoords = currentTexCoords + deltaTexCoords; // get texture coordinates before collision (reverse operations)
+
+	float afterDepth  = currentDepthMapValue - currentLayerDepth; // get depth after and before collision for linear interpolation
+	float beforeDepth = texture(normalmap, prevTexCoords).b - currentLayerDepth + layerDepth;
+	 
+	float weight = afterDepth / (afterDepth - beforeDepth); // interpolation of texture coordinates
+	vec2 finalTexCoords = prevTexCoords * weight + currentTexCoords * (1.0 - weight);
+
+	return finalTexCoords;
+#else
+	float height = texture(normalmap, f_coord).b;
+	vec2 p = viewDir.xy / viewDir.z * (height * (param[2].z - param[2].w) * 0.2);
+	return f_coord - p;
+#endif
+} 

shaders/mat_normalmap_specgloss.frag

@@ -53,7 +53,7 @@ void main()
 	float reflectivity = param[1].z * texture(normalmap, f_coord).a;
 	float specularity = texture(specgloss, f_coord).r;
 	glossiness = texture(specgloss, f_coord).g * abs(param[1].w);
-	metalic = (texture(specgloss, f_coord).b > 0.5) ? true : false;
+	float metalic = texture(specgloss, f_coord).b;
 
 	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
 

shaders/mat_parallax_specgloss.frag

@@ -59,9 +59,9 @@ void main()
 	normal.z = sqrt(1.0 - clamp((dot(normal.xy, normal.xy)), 0.0, 1.0));
 	vec3 fragnormal = normalize(f_tbn * normalize(normal.xyz));
 	float reflectivity = param[1].z * texture(normalmap, f_coord_p).a;
-	float specularity = texture(specgloss, f_coord).r;
-	glossiness = texture(specgloss, f_coord).g * abs(param[1].w);
-	metalic = (texture(specgloss, f_coord).b > 0.5) ? true : false;
+	float specularity = texture(specgloss, f_coord_p).r;
+	glossiness = texture(specgloss, f_coord_p).g * abs(param[1].w);
+	float metalic = texture(specgloss, f_coord_p).b;
 	
 	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
 

shaders/mat_reflmap_specgloss.frag

@@ -47,7 +47,7 @@ void main()
 	float reflectivity = param[1].z * texture(reflmap, f_coord).a;
 	float specularity = texture(specgloss, f_coord).r;
 	glossiness = texture(specgloss, f_coord).g * abs(param[1].w);
-	metalic = (texture(specgloss, f_coord).b > 0.5) ? true : false;
+	float metalic = texture(specgloss, f_coord).b;
 	
 	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
 

shaders/mat_shadowlessnormalmap_specgloss.frag

@@ -53,7 +53,7 @@ void main()
 	float reflectivity = param[1].z * texture(normalmap, f_coord).a;
 	float specularity = texture(specgloss, f_coord).r;
 	glossiness = texture(specgloss, f_coord).g * abs(param[1].w);
-	metalic = (texture(specgloss, f_coord).b > 0.5) ? true : false;
+	float metalic = texture(specgloss, f_coord).b;
 	
 	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, 1.0);
 	vec4 color = vec4(apply_fog(fragcolor), tex_color.a * alpha_mult);

shaders/mat_sunlessnormalmap_specgloss.frag

@@ -110,7 +110,7 @@ void main()
 	float reflectivity = param[1].z * texture(normalmap, f_coord).a;
 	float specularity = texture(specgloss, f_coord).r;
 	glossiness = texture(specgloss, f_coord).g * abs(param[1].w);
-	metalic = (texture(specgloss, f_coord).b > 0.5) ? true : false;
+	float metalic = texture(specgloss, f_coord).b;
 	
 	fragcolor = apply_lights_sunless(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);
 	vec4 color = vec4(apply_fog(fragcolor), tex_color.a * alpha_mult);

shaders/mat_water_specgloss.frag

@@ -64,7 +64,7 @@ void main()
 	float reflectivity = param[1].z * texture(normalmap, texture_coords ).a;
 	float specularity = texture(specgloss, f_coord).r;
 	glossiness = texture(specgloss, f_coord).g * abs(param[1].w);
-	metalic = (texture(specgloss, f_coord).b > 0.5) ? true : false;
+	float metalic = texture(specgloss, f_coord).b;
 	
 	fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone);