From 75cadb007953446850591a275c590bf486c05fd1 Mon Sep 17 00:00:00 2001 From: stele Date: Sat, 24 Oct 2020 19:14:45 +0200 Subject: [PATCH 01/11] Zamiana metalic na floata z wazonym efektem. --- shaders/light_common.glsl | 17 ++++++----------- shaders/mat_default_specgloss.frag | 2 +- shaders/mat_normalmap_specgloss.frag | 2 +- shaders/mat_parallax_specgloss.frag | 6 +++--- shaders/mat_reflmap_specgloss.frag | 2 +- shaders/mat_shadowlessnormalmap_specgloss.frag | 2 +- shaders/mat_sunlessnormalmap_specgloss.frag | 2 +- shaders/mat_water_specgloss.frag | 2 +- 8 files changed, 15 insertions(+), 20 deletions(-) diff --git a/shaders/light_common.glsl b/shaders/light_common.glsl index 79b8ce1e..f22394e6 100644 --- a/shaders/light_common.glsl +++ b/shaders/light_common.glsl @@ -8,7 +8,7 @@ uniform sampler2D headlightmap; #include float glossiness = 1.0; -bool metalic = false; +float metalic = 0.0; float length2(vec3 v) { @@ -167,16 +167,11 @@ vec3 apply_lights(vec3 fragcolor, vec3 fragnormal, vec3 texturecolor, float refl 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; - } + if (param[1].w < 0.0) + { + float metalic = 1.0; + } + fragcolor = mix(((fragcolor + specularcolor) * texturecolor),(fragcolor * texturecolor + specularcolor),metalic) ; return fragcolor; } diff --git a/shaders/mat_default_specgloss.frag b/shaders/mat_default_specgloss.frag index a72f04d5..cb7a2e5a 100644 --- a/shaders/mat_default_specgloss.frag +++ b/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); diff --git a/shaders/mat_normalmap_specgloss.frag b/shaders/mat_normalmap_specgloss.frag index 08059c28..86085df2 100644 --- a/shaders/mat_normalmap_specgloss.frag +++ b/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); diff --git a/shaders/mat_parallax_specgloss.frag b/shaders/mat_parallax_specgloss.frag index 74e9e78c..4ce17da7 100644 --- a/shaders/mat_parallax_specgloss.frag +++ b/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); diff --git a/shaders/mat_reflmap_specgloss.frag b/shaders/mat_reflmap_specgloss.frag index 60f99add..b5f9bc38 100644 --- a/shaders/mat_reflmap_specgloss.frag +++ b/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); diff --git a/shaders/mat_shadowlessnormalmap_specgloss.frag b/shaders/mat_shadowlessnormalmap_specgloss.frag index ac0775b4..58175c7c 100644 --- a/shaders/mat_shadowlessnormalmap_specgloss.frag +++ b/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); diff --git a/shaders/mat_sunlessnormalmap_specgloss.frag b/shaders/mat_sunlessnormalmap_specgloss.frag index ca84c346..cf5a7433 100644 --- a/shaders/mat_sunlessnormalmap_specgloss.frag +++ b/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); diff --git a/shaders/mat_water_specgloss.frag b/shaders/mat_water_specgloss.frag index 3dc3adcd..8d263a83 100644 --- a/shaders/mat_water_specgloss.frag +++ b/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); From d3ba7c10fc52b6d1f6c04b88cf8333b87462d786 Mon Sep 17 00:00:00 2001 From: stele Date: Sun, 13 Dec 2020 21:24:36 +0100 Subject: [PATCH 02/11] Detail normalmap shaders @Jan21 --- shaders/mat_detail_normalmap.frag | 81 +++++++++++ shaders/mat_detail_normalmap_specgloss.frag | 89 ++++++++++++ shaders/mat_detail_parallax.frag | 134 +++++++++++++++++++ shaders/mat_detail_parallax_specgloss.frag | 141 ++++++++++++++++++++ 4 files changed, 445 insertions(+) create mode 100644 shaders/mat_detail_normalmap.frag create mode 100644 shaders/mat_detail_normalmap_specgloss.frag create mode 100644 shaders/mat_detail_parallax.frag create mode 100644 shaders/mat_detail_parallax_specgloss.frag diff --git a/shaders/mat_detail_normalmap.frag b/shaders/mat_detail_normalmap.frag new file mode 100644 index 00000000..85f55289 --- /dev/null +++ b/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 + +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 +#include +#include + +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 +} diff --git a/shaders/mat_detail_normalmap_specgloss.frag b/shaders/mat_detail_normalmap_specgloss.frag new file mode 100644 index 00000000..f2c30763 --- /dev/null +++ b/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 + +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 +#include +#include + +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); + metalic = (specgloss_map.b > 0.5) ? true : false; + + + 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 +} diff --git a/shaders/mat_detail_parallax.frag b/shaders/mat_detail_parallax.frag new file mode 100644 index 00000000..75919b13 --- /dev/null +++ b/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 + +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 +#include +#include + +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 +} diff --git a/shaders/mat_detail_parallax_specgloss.frag b/shaders/mat_detail_parallax_specgloss.frag new file mode 100644 index 00000000..40d914f6 --- /dev/null +++ b/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 + +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 +#include +#include + +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; + glossiness = specgloss_map.g * abs(param[1].w); + metalic = (specgloss_map.b > 0.5) ? true : false; + + 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, currentTexCoords).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 = normal_map.b; + vec2 p = viewDir.xy / viewDir.z * (height * (param[2].z - param[2].w) * 0.2); + return f_coord - p; +#endif +} From 3ac9b0381ffe0e73449a21da789affde75c43261 Mon Sep 17 00:00:00 2001 From: stele Date: Sat, 23 Jan 2021 18:14:30 +0100 Subject: [PATCH 03/11] Wheels animation distance changed to 200*D*LODbias --- DynObj.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/DynObj.cpp b/DynObj.cpp index 99d07a17..394ec012 100644 --- a/DynObj.cpp +++ b/DynObj.cpp @@ -4937,9 +4937,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 From 6b214b473f0c6a2835e5a94ed171a1e08e5e4e28 Mon Sep 17 00:00:00 2001 From: stele Date: Sat, 23 Jan 2021 18:42:25 +0100 Subject: [PATCH 04/11] Fixed spelling error in event syntax; old one remains for compatibility. --- Event.cpp | 2 +- ref/asio | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) create mode 160000 ref/asio diff --git a/Event.cpp b/Event.cpp index b59c9fa3..dc822f18 100644 --- a/Event.cpp +++ b/Event.cpp @@ -191,7 +191,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; diff --git a/ref/asio b/ref/asio new file mode 160000 index 00000000..22afb860 --- /dev/null +++ b/ref/asio @@ -0,0 +1 @@ +Subproject commit 22afb86087a77037cd296d27134756c9b0d2cb75 From 49f01b16902005aaa56f4a48b70c98081cd56087 Mon Sep 17 00:00:00 2001 From: stele Date: Sat, 23 Jan 2021 19:32:25 +0100 Subject: [PATCH 05/11] Spelling error left in log text --- Event.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Event.cpp b/Event.cpp index dc822f18..1a3e88af 100644 --- a/Event.cpp +++ b/Event.cpp @@ -266,7 +266,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 ) { From 134e459dbd9cd226350dedfd13133c95191c6e2c Mon Sep 17 00:00:00 2001 From: stele Date: Sat, 23 Jan 2021 20:11:05 +0100 Subject: [PATCH 06/11] Explicit type conversion --- shaders/light_common.glsl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shaders/light_common.glsl b/shaders/light_common.glsl index f22394e6..74338c94 100644 --- a/shaders/light_common.glsl +++ b/shaders/light_common.glsl @@ -32,7 +32,7 @@ float calc_shadow() //basic // shadow = texture(shadowmap, coords.xyz + vec3(0.0, 0.0, bias)); //PCF - float bias = 0.00005f * (cascade + 1U); + 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) From 4f11ead6401f30599f0201c0b1de17411e6f2634 Mon Sep 17 00:00:00 2001 From: stele Date: Sat, 23 Jan 2021 20:20:07 +0100 Subject: [PATCH 07/11] Leftover metalic as bool --- shaders/mat_detail_normalmap_specgloss.frag | 2 +- shaders/mat_detail_parallax_specgloss.frag | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/shaders/mat_detail_normalmap_specgloss.frag b/shaders/mat_detail_normalmap_specgloss.frag index f2c30763..fbd90257 100644 --- a/shaders/mat_detail_normalmap_specgloss.frag +++ b/shaders/mat_detail_normalmap_specgloss.frag @@ -68,7 +68,7 @@ void main() 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); - metalic = (specgloss_map.b > 0.5) ? true : false; + float metalic = specgloss_map.b; fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone); diff --git a/shaders/mat_detail_parallax_specgloss.frag b/shaders/mat_detail_parallax_specgloss.frag index 40d914f6..dc621dc1 100644 --- a/shaders/mat_detail_parallax_specgloss.frag +++ b/shaders/mat_detail_parallax_specgloss.frag @@ -74,7 +74,7 @@ void main() float reflectivity = param[1].z * normal_map.a; float specularity = specgloss_map.r; glossiness = specgloss_map.g * abs(param[1].w); - metalic = (specgloss_map.b > 0.5) ? true : false; + float metalic = specgloss_map.b; fragcolor = apply_lights(fragcolor, fragnormal, tex_color.rgb, reflectivity, specularity, shadow_tone); From 0ff083282dbe15b0641576064534323495c3e919 Mon Sep 17 00:00:00 2001 From: stele Date: Sat, 23 Jan 2021 21:08:20 +0100 Subject: [PATCH 08/11] Syntax error --- shaders/mat_detail_parallax_specgloss.frag | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/shaders/mat_detail_parallax_specgloss.frag b/shaders/mat_detail_parallax_specgloss.frag index dc621dc1..e5309317 100644 --- a/shaders/mat_detail_parallax_specgloss.frag +++ b/shaders/mat_detail_parallax_specgloss.frag @@ -67,13 +67,13 @@ void main() 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.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; - glossiness = specgloss_map.g * abs(param[1].w); + 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); @@ -127,7 +127,7 @@ vec2 ParallaxMapping(vec2 f_coord, vec3 viewDir) 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, currentTexCoords).b; - currentLayerDepth + layerDepth; + 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); From c98ff244f9104b818b2a7e3d8601af732f504794 Mon Sep 17 00:00:00 2001 From: stele Date: Sat, 23 Jan 2021 21:22:17 +0100 Subject: [PATCH 09/11] Normalmap sampling inside ParallaxMapping function --- shaders/mat_detail_parallax_specgloss.frag | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shaders/mat_detail_parallax_specgloss.frag b/shaders/mat_detail_parallax_specgloss.frag index e5309317..416a6854 100644 --- a/shaders/mat_detail_parallax_specgloss.frag +++ b/shaders/mat_detail_parallax_specgloss.frag @@ -134,7 +134,7 @@ vec2 ParallaxMapping(vec2 f_coord, vec3 viewDir) return finalTexCoords; #else - float height = normal_map.b; + 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 From f92a355e89655608641f4fe905952bf1eee0184f Mon Sep 17 00:00:00 2001 From: stele Date: Sun, 24 Jan 2021 18:27:28 +0100 Subject: [PATCH 10/11] Shader with only detail normalmap --- shaders/mat_default_detail.frag | 70 +++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 shaders/mat_default_detail.frag diff --git a/shaders/mat_default_detail.frag b/shaders/mat_default_detail.frag new file mode 100644 index 00000000..2761aff5 --- /dev/null +++ b/shaders/mat_default_detail.frag @@ -0,0 +1,70 @@ +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 + +#param (color, 0, 0, 4, diffuse) +#param (diffuse, 1, 0, 1, diffuse) +#param (specular, 1, 1, 1, specular) +#param (reflection, 1, 2, 1, zero) +#param (glossiness, 1, 3, 1, glossiness) +#param (detail_scale, 2, 0, 1, one) + +#texture (diffuse, 0, sRGB_A) +uniform sampler2D diffuse; + +layout(location = 0) out vec4 out_color; +#if MOTIONBLUR_ENABLED +layout(location = 1) out vec4 out_motion; +#endif + +#texture (detailnormalmap, 1, RGBA) +uniform sampler2D detailnormalmap; + +#define NORMALMAP +#include +#include +#include + +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; + + vec3 normal; + normal.xy = (texture(detailnormalmap, f_coord * param[2].x).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(normal.xyz)); + float reflectivity = param[1].z; + float specularity = (tex_color.r + tex_color.g + tex_color.b) * 0.5; + glossiness = abs(param[1].w); + + 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, tex_color.a * alpha_mult); + } +#endif +} From ea6e75741679b37361b07fe5e81a3e87fcb5d9de Mon Sep 17 00:00:00 2001 From: stele Date: Mon, 25 Jan 2021 00:30:22 +0100 Subject: [PATCH 11/11] Shouldn't take any keyword as random condition anymore. --- Event.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Event.cpp b/Event.cpp index 1a3e88af..1627df8c 100644 --- a/Event.cpp +++ b/Event.cpp @@ -191,7 +191,7 @@ basic_event::event_conditions::deserialize( cParser &Input ) { else if( token == "trackfree" ) { flags |= flags::track_free; } - else if( token == "propability" || "probability") { //remove propability in few years after changing old scenery scripts 01.2021 + else if( ( token == "propability" ) || ( token == "probability" )) { //remove propability in few years after changing old scenery scripts 01.2021 flags |= flags::probability; Input.getTokens(); Input >> probability;