From d1ecbdc8ff49041cddd71614ac9e7d3196107bed Mon Sep 17 00:00:00 2001 From: antonisauren Date: Sat, 23 Jan 2021 22:24:14 +0100 Subject: [PATCH] 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 | 5 +- Event.cpp | 4 +- ref/asio | 1 + shaders/light_common.glsl | 359 +++++++++--------- shaders/mat_default_specgloss.frag | 2 +- 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 +++++++ shaders/mat_normalmap_specgloss.frag | 2 +- shaders/mat_parallax_specgloss.frag | 6 +- shaders/mat_reflmap_specgloss.frag | 2 +- .../mat_shadowlessnormalmap_specgloss.frag | 2 +- shaders/mat_sunlessnormalmap_specgloss.frag | 2 +- shaders/mat_water_specgloss.frag | 2 +- 15 files changed, 636 insertions(+), 196 deletions(-) create mode 160000 ref/asio 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/DynObj.cpp b/DynObj.cpp index e2b3a951..e983c8ef 100644 --- a/DynObj.cpp +++ b/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 diff --git a/Event.cpp b/Event.cpp index 55cc31c9..97c72eda 100644 --- a/Event.cpp +++ b/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 ) { 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 diff --git a/shaders/light_common.glsl b/shaders/light_common.glsl index e0d9ccd0..74338c94 100644 --- a/shaders/light_common.glsl +++ b/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 -#include - -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 +#include + +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; +} 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_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..fbd90257 --- /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); + 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 +} 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..416a6854 --- /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; + 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 +} 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);