Disabling the texture filtering?

[Rain-Gayming]

Description

I want to be able to use solid colours for textures and the blurring/texture filtering is something i don't like. Could there be a way to disable it?

[TokisanGames]

Change texture filtering to nearest in the material settings, or enable the shader override and adjust the sampler filtering however you like.

[Rain-Gayming]

@TokisanGames Changing it from Liniar to Nearest doesnt seem to change anything

[TokisanGames]

It does. Zoom in, increase the uv scale of your textures, or watch the tutorial videos where it's demonstrated.

[Rain-Gayming]

This is it on each setting without a change

[TokisanGames]

This shows what texture filtering does with textures that have detail:
https://youtu.be/YtiAI2F6Xkk?t=537

This shows what it changes:
https://github.com/TokisanGames/Terrain3D/blob/main/src/shaders/uniforms.glsl

You can look through the Godot docs for other filtering options and enable the override shader to experiment with them. We don't control the renderer. For filtering we just pass it along to the renderer.

However, what you have on your screen probably has nothing to do with texture filtering. Read this:
https://terrain3d.readthedocs.io/en/stable/docs/shader_design.html

Most likely you're looking at the blend between vertices. Edit the shader override and disable the weighted average of adjacent vertices, aka bilinear interpolation, and use the values of just one vertex.

[Rain-Gayming]

is there a way to remove the blend?

[Xtarsia]

You can set up the terrain matertial to how you want it, then click "shader override enabled"

it will then generate a shader based on your current choices.

from there, you can modify the shader to remove the blend.

	vec2 texel_pos = uv;
	highp vec2 texel_pos_floor = floor(uv);
	
	// Create a cross hatch grid of alternating 0/1 horizontal and vertical stripes 1 unit wide in XY 
	//vec4 mirror = vec4(fract(texel_pos_floor * 0.5) * 2.0, 1.0, 1.0);
	// And the opposite grid in ZW
	//mirror.zw = vec2(1.0) - mirror.xy;

	// Get the region and control map ID for the vertices
	//ivec3 index00UV = get_region_uv(texel_pos_floor + mirror.xy);
	ivec3 index00UV = get_region_uv(texel_pos_floor);
	//ivec3 index01UV = get_region_uv(texel_pos_floor + mirror.xw);
	//ivec3 index10UV = get_region_uv(texel_pos_floor + mirror.zy);
	//ivec3 index11UV = get_region_uv(texel_pos_floor + mirror.zw);

	// Lookup adjacent vertices. 4 lookups
	uint control00 = texelFetch(_control_maps, index00UV, 0).r;
	//uint control01 = texelFetch(_control_maps, index01UV, 0).r;
	//uint control10 = texelFetch(_control_maps, index10UV, 0).r;
	//uint control11 = texelFetch(_control_maps, index11UV, 0).r;

	// Get the textures for each vertex. 8-16 lookups (2-4 ea)
	Material mat[1];
	get_material(uv, control00, index00UV, w_normal, mat[0]);
	//get_material(uv, control01, index01UV, w_normal, mat[1]);
	//get_material(uv, control10, index10UV, w_normal, mat[2]);
	//get_material(uv, control11, index11UV, w_normal, mat[3]);

	// Calculate weight for the pixel position between the vertices
	// Bilinear interpolation of difference of uv and floor(uv)
	//vec2 weights1 = clamp(texel_pos - texel_pos_floor, 0, 1);
	//weights1 = mix(weights1, vec2(1.0) - weights1, mirror.xy);
	//vec2 weights0 = vec2(1.0) - weights1;
	// Adjust final weights by texture's height/depth + noise. 1 lookup
	//float noise3 = texture(noise_texture, uv*noise3_scale).r;
	//vec4 weights;
	//weights.x = blend_weights(weights0.x * weights0.y, clamp(mat[0].alb_ht.a + noise3, 0., 1.));
	//weights.y = blend_weights(weights0.x * weights1.y, clamp(mat[1].alb_ht.a + noise3, 0., 1.));
	//weights.z = blend_weights(weights1.x * weights0.y, clamp(mat[2].alb_ht.a + noise3, 0., 1.));
	//weights.w = blend_weights(weights1.x * weights1.y, clamp(mat[3].alb_ht.a + noise3, 0., 1.));
	//float weight_sum = weights.x + weights.y + weights.z + weights.w;
	//float weight_inv = 1.0/weight_sum;

	// Weighted average of albedo & height
	//vec4 albedo_height = weight_inv * (
		//mat[0].alb_ht * weights.x +
		//mat[1].alb_ht * weights.y +
		//mat[2].alb_ht * weights.z +
		//mat[3].alb_ht * weights.w );
	vec4 albedo_height = mat[0].alb_ht;

	// Weighted average of normal & rough
	//vec4 normal_rough = weight_inv * (
		//mat[0].nrm_rg * weights.x +
		//mat[1].nrm_rg * weights.y +
		//mat[2].nrm_rg * weights.z +
		//mat[3].nrm_rg * weights.w );
	vec4 normal_rough = mat[0].nrm_rg;

	// Determine if we're in a region or not (region_uv.z>0)
	vec3 region_uv = get_region_uv2(uv2);

from approximatley line 412 through line 470 you can comment out / delete as I have shown here with some very small replacements. as you can see almost everything is commented out in this section to disable the bilinear blend.

this will also be significantly faster :)

[TokisanGames]

I just told you in the last paragraph.

[TokisanGames]

Converted to a Q&A discussion as it's not a bug.
Closed because the answer was given. By design pixels bilinearly interpolate among 4 adjacent vertices. If you don't want that, edit the shader in the editor and just take the value from any one vertex, removing the weighting.