DJMaesen The problem is that you're mixing two normal maps in 50-50 ratio. The detail map is much smoother so it will scale down the other one by 50%.

Best to use weighted blend, give smaller weight to the detail map and increase NORMAL_MAP_DEPTH until it all looks as desired. Here's weighted blending function:

vec3 NormalBlend_Linear(vec3 n1, vec3 n2, float bias){
	n1 = n1*2.0 - 1.0;
	n2 = n2*2.0 - 1.0;
	return fma(normalize(mix(n1, n2, bias)), vec3(.5), vec3(.5));    
}

With bias .5 it should behave like your old function, mixing two normals in a half-half ratio. Smaller bias values will put greater weight on n1, while larger values (up to 1.0) will weight the n2 more.

      xyz is there a way to combine 2 normal maps without the mix 50/50? so both normals get applied like u would apply 1?

      • xyz replied to this.

          DJMaesen There are various ways you can blend normals. None of them is perfect. The one you used is the simplest. A good one but still simple is:

          vec3 n = normalize(vec3(n1.xy + n2.xy, n1.z));

          See how that works. Don't forget to decode/encode before/after doing this as this works with proper normals, not with values read from normal maps. So:

          n1 = fma(n1, vec3(2.0), vec3(-1.0));
n2 = fma(n2, vec3(2.0), vec3(-1.0));
vec3 n = normalize(vec3(n1.xy + n2.xy, n1.z));
n = fma(n, vec3(.5), vec3(.5));

              xyz
              i tried it
              sadly ....
              no good results, i give up for now, im waisting time

              • xyz replied to this.

                  DJMaesen Maybe your normal maps should be adjusted for better results. Can you replicate the look you want in Blender?
                  Here is a breakdown of various methods with some example shader code. Maybe you can find something adequate. At least try Reorient Blending, the last one presented. It's the most complex one and probably most performance heavy (not by much though) but it's supposed to give best results for detail maps.

                      xyz there was a discussion in github about this topic. Godot only uses the R and G channels of normal map and calculates the B channel. so maybe that's why it doesn't work?
                      currently godot uses a simple lerp to combine normal maps values. It gives good enough results for me.

                      • xyz replied to this.

                          Jesusemora there was a discussion in github about this topic. Godot only uses the R and G channels of normal map and calculates the B channel. so maybe that's why it doesn't work?

                          This shouldn't matter if maps are properly encoded (either DX or OGL style). However if maps are made specifically for Godot and are lacking the blue channel then this may indeed be the cause of poor results. It's easily fixed though by adding a line of code that calculates the third component when decoding.

                          Jesusemora currently godot uses a simple lerp to combine normal maps values. It gives good enough results for me.

                          It kinda depends on the detail frequency in the maps. Simple linear mixing may work well for some combinations. The problem is more pronounced when combining a low frequency base map with a high frequency detail map.

                              xyz i tried every technique allready from this example>
                              https://www.shadertoy.com/view/4t2SzR
                              strange thing is that when u use a standard material shader and ad a normal map to a model(UV1) and then a detail normal (UV2 with triplanar mapping on) in the shader,it also looks bad.
                              so i think @Jesusemora might be right

                              • xyz replied to this.

                                  i would really like to get this to work to texture large objects in the 3d world

                                  DJMaesen it also looks bad

                                  What are you comparing it against?

                                  It should be doable in general, regardless of how Godot interprets normal maps.

                                      xyz wait a minute ill take some screenshots with the 3 options available:
                                      1 no detail normal on triplanar(standard), 2 the shader im trying to get to work(customshader) , 3 standard shader with detail normal on triplanar(standardwithdetail)

                                        xyz
                                        as u can see
                                        all non standard normal blending messes up the base normal map

                                        • xyz replied to this.

                                            DJMaesen For start, try disabling RGTC compression in import options for all normal maps. It's the Normal Map dropdown in Compress section. Set it to Disabled. Or disable the VRAM compression entirely. How does the blending look in that case?

                                                DJMaesen Here's the mix when compression is disabled. Looks fine to me.

                                                  xyz cant find RGTC compression in import settings

                                                  • xyz replied to this.

                                                      DJMaesen cant find RGTC compression in import settings

                                                      It doesn't say RGTC. It's the dropdown named "Normal Map". Select "Disabled" there.

                                                          DJMaesen why would u check normal map disabled? i dont understand

                                                          Just do it 😃. I'll explain it later if you get blending to work in satisfactory way.

                                                            i got it working yay! there was a problem with my triplanar calculation in the shader.
                                                            works fine now, i didnt had to set normal to disabled

                                                            shader_type spatial;
render_mode blend_mix,depth_draw_opaque,cull_back,diffuse_burley,specular_schlick_ggx;

uniform sampler2D texture_albedo : source_color,filter_linear_mipmap,repeat_enable;
uniform sampler2D texture_roughness : hint_roughness_gray,filter_linear_mipmap,repeat_enable;
uniform sampler2D texture_normal : hint_roughness_normal,filter_linear_mipmap,repeat_enable;
uniform float roughness = 1.0;
uniform sampler2D detail_normal : hint_roughness_normal,filter_linear_mipmap,repeat_enable;
uniform sampler2D detail_overlay : source_color,filter_linear_mipmap,repeat_enable;
uniform vec3 detail_scale = vec3(1.0);


uniform float normal_scale = 1.0;
varying vec3 triplanar_pos;
varying vec3 power_normal;





void vertex() {
	TANGENT = vec3(0.0,0.0,-1.0) * abs(NORMAL.x);
	TANGENT += vec3(1.0,0.0,0.0) * abs(NORMAL.y);
	TANGENT += vec3(1.0,0.0,0.0) * abs(NORMAL.z);
	TANGENT = normalize(TANGENT);
	BINORMAL = vec3(0.0,1.0,0.0) * abs(NORMAL.x);
	BINORMAL += vec3(0.0,0.0,-1.0) * abs(NORMAL.y);
	BINORMAL += vec3(0.0,1.0,0.0) * abs(NORMAL.z);
	BINORMAL = normalize(BINORMAL);
	power_normal = pow(abs(NORMAL),vec3(1.0));
	triplanar_pos = VERTEX;
	power_normal /= dot(power_normal,vec3(1.0));
	triplanar_pos *= vec3(1.0,-1.0, 1.0);
}
vec3 triplanar_texture(sampler2D p_sampler, vec3 p_triplanar_pos) {
	vec3 samp = vec3(0.0);
	samp += texture(p_sampler,p_triplanar_pos.xy).xyz * power_normal.z;
	samp += texture(p_sampler,p_triplanar_pos.xz).xyz * power_normal.y;
	samp += texture(p_sampler,p_triplanar_pos.zy * vec2(-1.0,1.0)).xyz * power_normal.x;
	return samp;
}
//Overlay
vec3 overlay (vec3 target, vec3 blend){
    vec3 temp;
    temp.x = (target.x > 0.5) ? (1.0-(1.0-2.0*(target.x-0.5))*(1.0-blend.x)) : (2.0*target.x)*blend.x;
    temp.y = (target.y > 0.5) ? (1.0-(1.0-2.0*(target.y-0.5))*(1.0-blend.y)) : (2.0*target.y)*blend.y;
    temp.z = (target.z > 0.5) ? (1.0-(1.0-2.0*(target.z-0.5))*(1.0-blend.z)) : (2.0*target.z)*blend.z;
    return temp;
}

// Linear Blending
vec3 NormalBlend_Linear(vec3 n1, vec3 n2)
{
    // Unpack
	n1 = n1*2.0 - 1.0;
    n2 = n2*2.0 - 1.0;
    
	return normalize(n1 + n2);    
}
vec3 CombineNormal(vec3 n1, vec3 n2)
{
 	return NormalBlend_Linear(n1, n2);
       
}




void fragment() {
	vec2 base_uv = UV;
	vec4 albedo_tex = texture(texture_albedo,base_uv);
	vec3 overlayertex = triplanar_texture(detail_overlay,triplanar_pos * detail_scale/100.0);
	ALBEDO = overlay(albedo_tex.rgb,overlayertex.rgb);
	
	
	METALLIC = 0.0;
	
	vec4 roughness_texture_channel = vec4(0.333333,0.333333,0.333333,0.0);
	float roughness_tex = dot(texture(texture_roughness,base_uv),roughness_texture_channel);
	ROUGHNESS = roughness_tex * roughness;
	SPECULAR = 0.5;
	
	vec3 detail_norm_tex = triplanar_texture(detail_normal,triplanar_pos * detail_scale/100.0);
	detail_norm_tex *= 2.0;
	NORMAL_MAP = CombineNormal(texture(texture_normal,base_uv).rgb,detail_norm_tex.rgb );
	
	NORMAL_MAP_DEPTH = normal_scale;
	
}
                                                            • xyz replied to this.