Compatability Shader - and more ways to skin a cat..

[Xtarsia]

When in Compatability;

Having too large an array of samplers results in major errors, or even crashes.
Attempting to sample the height map multiple times in fragment also causes similar results, unsure why.
Large functions seem to break, outputing annomolous values?

Compatability will require core changes to use array[sampler] rather than samplerArray objects, which may have many benefits, i've yet to attempt implementing that to the extension itself - for now manually assigned textures for testing. Thats for another topic really, upon which this is dependant.

everything else works fine, though I had to re-write the entire material function as it was just not working correctly (potentially related to the use of structs, too many in/outs in the function? unsure. It was an excuse to attempt a different approach to it anyways!)

swapping to array[samplers]:

uniform sampler2D[32] test_height_maps : filter_linear, repeat_disable;
uniform usampler2D[32] test_control_maps : repeat_disable;
uniform sampler2D[32] test_color_maps : source_color, filter_linear_mipmap_anisotropic, repeat_disable;
//uniform sampler2DArray _height_maps : filter_linear, repeat_disable;
//uniform usampler2DArray _control_maps : repeat_disable;
//uniform sampler2DArray _color_maps : source_color, filter_linear_mipmap_anisotropic, repeat_disable;

uniform sampler2D[32] test_texture_array_albedo : source_color, filter_linear_mipmap_anisotropic, repeat_enable;
uniform sampler2D[32] test_texture_array_normal : filter_linear_mipmap_anisotropic, repeat_enable;
//uniform sampler2DArray _texture_array_albedo : source_color, filter_linear_mipmap_anisotropic, repeat_enable;
//uniform sampler2DArray _texture_array_normal : hint_normal, filter_linear_mipmap_anisotropic, repeat_enable;

vertex function is straightforwards

void vertex() {
	// Get camera pos in world vertex coords
	v_camera_pos = INV_VIEW_MATRIX[3].xyz;

	// Get vertex of flat plane in world coordinates and set world UV
	v_vertex = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;

	// Camera distance to vertex on flat plane
	v_vertex_xz_dist = length(v_vertex.xz - v_camera_pos.xz);

	// UV coordinates in world space. Values are 0 to _region_size within regions
	UV = round(v_vertex.xz * _mesh_vertex_density);

	// UV coordinates in region space + texel offset. Values are 0 to 1 within regions
	UV2 = (UV + vec2(0.5)) * _region_texel_size;

	// Save current region data
	v_region = get_region_uv(UV);

	// Discard vertices for Holes. 1 lookup
	uint control = texelFetch(test_control_maps[v_region.z], v_region.xy, 0).r;
	bool hole = bool(control >>2u & 0x1u);

	// Show holes to all cameras except mouse camera (on exactly 1 layer)
	if ( !(CAMERA_VISIBLE_LAYERS == _mouse_layer) && 
			(hole || (_background_mode == 0u && v_region.z < 0)) ) {
		VERTEX.x = 0. / 0.;
	} else {
		// Get final vertex location and save it
		float h = get_height(UV2);
		// Vertex Normals
		vec2 offset = vec2(0.0, _region_texel_size);
		float u = get_height(UV2 + offset.yx);
		float v = get_height(UV2 + offset.xy);
		#ifdef BG_WORLD_NOISE
			if (_background_mode == 2u) {
				h += get_noise_height(UV2);
				u += get_noise_height(UV2 + offset.yx);
				v += get_noise_height(UV2 + offset.xy);
			}
		#endif
		v_normal = vec3(h - u, _mesh_vertex_spacing, h - v);
		VERTEX.y = h;
		v_vertex.y = h;
	}
		
	// Transform UVs to local to avoid poor precision during varying interpolation.
	v_uv_offset = MODEL_MATRIX[3].xz * _mesh_vertex_density;
	UV -= v_uv_offset;
	v_uv2_offset = v_uv_offset * _region_texel_size;
	UV2 -= v_uv2_offset;

	// Convert model space to view space w/ skip_vertex_transform render mode
	VERTEX = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
	VERTEX = (VIEW_MATRIX * vec4(VERTEX, 1.0)).xyz;
	NORMAL = (MODELVIEW_MATRIX * vec4(NORMAL, 0.0)).xyz;
	BINORMAL = (MODELVIEW_MATRIX * vec4(BINORMAL, 0.0)).xyz;
	TANGENT = (MODELVIEW_MATRIX * vec4(TANGENT, 0.0)).xyz;
}

Start of fragment, almost no changes besides directly reading v_normal:

void fragment() {
	// Recover UVs
	vec2 uv = UV + v_uv_offset;
	vec2 uv2 = UV2 + v_uv2_offset;
	
	// Calculate Terrain Normals.
	vec3 w_normal = normalize(v_normal);
	vec3 w_tangent = normalize(cross(w_normal, vec3(0, 0, 1)));
	vec3 w_binormal = normalize(cross(w_normal, w_tangent));
	NORMAL = mat3(VIEW_MATRIX) * w_normal;
	TANGENT = mat3(VIEW_MATRIX) * w_tangent;
	BINORMAL = mat3(VIEW_MATRIX) * w_binormal;

	vec4 ddxy = vec4(dFdx(uv),dFdy(uv)) * texture_lod_bias;

	vec2 domain_id = floor(uv);
	vec2 weight = fract(uv);
	
	const vec2 offsets = vec2(0,1);
	ivec3 indexUV[4] = {
		get_region_uv(domain_id + offsets.xy),
		get_region_uv(domain_id + offsets.yy),
		get_region_uv(domain_id + offsets.yx),
		get_region_uv(domain_id + offsets.xx)
	};
	
	// Read control maps 4 lookups
	uint control[4] = {
		texelFetch(test_control_maps[indexUV[0].z], indexUV[0].xy, 0).r,
		texelFetch(test_control_maps[indexUV[1].z], indexUV[1].xy, 0).r,
		texelFetch(test_control_maps[indexUV[2].z], indexUV[2].xy, 0).r,
		texelFetch(test_control_maps[indexUV[3].z], indexUV[3].xy, 0).r
	};

Skip a ton of math, by calculating the auto shader only once, and also interpolating the blend value for even smoother blending!

	// Interpolate Height blend 
	// Only calculate auto shader blend once.
	#define AUTOSHADER(i) indexUV[i].z < 0 || bool(control[i] & 0x1u)
	bool auto_shader[4] = {AUTOSHADER(0), AUTOSHADER(1), AUTOSHADER(2), AUTOSHADER(3)};
	float auto_blend = clamp(dot(vec3(0., 1., 0.), w_normal * auto_slope * 2. - (auto_slope * 2. - 1.))
		 - auto_height_reduction * .01 * v_vertex.y, 0., 1.) * 255.0;
	#define AUTO_BLEND(i) auto_shader[i] ? auto_blend : float(control[i] >>14u & 0xFFu)
	float _blend = mix(
		mix(AUTO_BLEND(3), AUTO_BLEND(2), weight.x),
		mix(AUTO_BLEND(0), AUTO_BLEND(1), weight.x),
		weight.y) * 0.003921568627450;

next, rather than sampling base, over, albdo & normal for all 4 corners seperatley, process the 4 control values and generate an index for all 4 corners containing the textureID integers - include the autoshader over-ride at this step

	// build index of all potential texture IDs
	#define AUTO_BASE(i) auto_shader[i] ? auto_base_texture : int(control[i] >>27u & 0x1Fu)
	#define AUTO_OVER(i) auto_shader[i] ? auto_overlay_texture : int(control[i] >>22u & 0x1Fu)
	int texture_index[8] = {
		// Base
		AUTO_BASE(0), AUTO_BASE(1),
		AUTO_BASE(2), AUTO_BASE(3),
		// Over
		AUTO_OVER(0), AUTO_OVER(1),
		AUTO_OVER(2), AUTO_OVER(3)
	};

then iterate over the index, and sample each texture into a array of vec4s. if the same ID is encountered again, it is skipped, saving a texture read, and any duplicate texture uv_scale & texture_color array multiplys along with it.
for dual scaling, whilst going through all 8 values, if the dual scale texture is seen we check the blend factor to potentially skip the near texture read, and also update the bool to show that dual scaling is needed for this fragment. we dont update the sampled array unless the read actually occurs. finally during this step, read the dual scaled texture, +2 reads only during blend.

	// for dual scaling check if the texture is present
	#ifdef DUAL_SCALING
		bool dual_scale = false;
		float far_factor = clamp(smoothstep(dual_scale_near, dual_scale_far, length(v_vertex - v_camera_pos)), 0.0, 1.0);
	#endif
	
	float tri_scale = v_region.z == -1 ? tri_scale_reduction : 1.0;
	for (int i = 0; i < 8; i++) {
		#ifdef DUAL_SCALING
			if (texture_index[i] == dual_scale_texture) {
				dual_scale = true;
			};
			if (texture_index[i] == dual_scale_texture && far_factor > 0.99) {
				continue;
			}
		#endif
		if (_sampled[texture_index[i]] == false) {
			int index = texture_index[i];
			float scale = _texture_uv_scale_array[index] * tri_scale * 0.5;
			vec2 _uv = uv * scale;
			vec4 dds = ddxy * scale;
			_albedo[index] = textureGrad(test_texture_array_albedo[index], _uv, dds.xy, dds.zw) * _texture_color_array[index];
			_normal[index] = unpack_normal(textureGrad(test_texture_array_normal[index], _uv, dds.xy, dds.zw));
			_sampled[index] = true;
		};

	}
	
	#ifdef DUAL_SCALING
	// dual scale blend if present, and above threshold, read the dual scale texture.
	if (dual_scale && far_factor > 0.05) {
		float scale = _texture_uv_scale_array[dual_scale_texture] * dual_scale_reduction * tri_scale * 0.5;
		vec2 _uv = uv * scale;
		vec4 dds = ddxy * scale;
		vec4 ds_tex = textureGrad(test_texture_array_albedo[dual_scale_texture], _uv, dds.xy, dds.zw) * _texture_color_array[dual_scale_texture];
		vec4 ds_nrm = unpack_normal(textureGrad(test_texture_array_normal[dual_scale_texture], _uv, dds.xy, dds.zw));
		_albedo[dual_scale_texture] = mix(_albedo[dual_scale_texture], ds_tex, far_factor);
		_normal[dual_scale_texture] = mix(_normal[dual_scale_texture], ds_nrm, far_factor);
	}
	#endif

next we bilerp all base, and over values, useing the index for each corner to access the aldebo/normal arrays that were filled earlier.
the final step is to height blend base and over for the final output.

	// Base Layer
	vec4 base_albdeo = mix(
		mix(_albedo[texture_index[3]], _albedo[texture_index[2]], weight.x),
		mix(_albedo[texture_index[0]], _albedo[texture_index[1]], weight.x),
		weight.y);
	vec4 base_normal = mix(
		mix(_normal[texture_index[3]], _normal[texture_index[2]], weight.x),
		mix(_normal[texture_index[0]], _normal[texture_index[1]], weight.x),
		weight.y);

	// Overlay Layer
	vec4 over_albedo = mix(
		mix(_albedo[texture_index[7]], _albedo[texture_index[6]], weight.x),
		mix(_albedo[texture_index[4]], _albedo[texture_index[5]], weight.x),
		weight.y);
	vec4 over_normal = mix(
		mix(_normal[texture_index[7]], _normal[texture_index[6]], weight.x),
		mix(_normal[texture_index[4]], _normal[texture_index[5]], weight.x),
		weight.y);
		
	// Height blend overlay and base
	vec4 albedo_ht = mix(base_albdeo, over_albedo,
		height_blend(base_albdeo.a, over_albedo.a, _blend));
	// Apply curve to blend weight in favor of base normals, adds extra detailing options at mid blend levels.
	vec4 normal_rg = mix(base_normal, over_normal,
		height_blend(base_albdeo.a, over_albedo.a, _blend*clamp(_blend*overlay_normal_weight,0.0,1.0)));

then just the rest of the fragment function as normal:

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

	// Colormap. 1 lookup
	vec4 color_map = vec4(1., 1., 1., .5);
	if (region_uv.z >= 0.) {
		// offset to align color map correctly in region space
		region_uv.xy -= _region_texel_size * 0.5;
		ddxy *= _region_texel_size;
		color_map = textureGrad(test_color_maps[int(region_uv.z)], region_uv.xy, ddxy.xy, ddxy.zw);
	}

	#ifndef MACRO_VARIATION
	#define MACRO_MULT
	#endif
	#ifdef MACRO_VARIATION
	#define MACRO_MULT * macrov
	// Macro variation. 2 Lookups
	float noise1 = texture(noise_texture, rotate(uv*noise1_scale * .1, cos(noise1_angle), sin(noise1_angle)) + noise1_offset).r;
	float noise2 = texture(noise_texture, uv*noise2_scale * .1).r;
	vec3 macrov = mix(macro_variation1, vec3(1.), clamp(noise1 + v_vertex_xz_dist * .0002, 0., 1.));
	macrov *= mix(macro_variation2, vec3(1.), clamp(noise2 + v_vertex_xz_dist * .0002, 0., 1.));
	#endif
	
	// Wetness/roughness modifier, converting 0-1 range to -1 to 1 range
	float roughness = ((color_map.a - 0.5)  * 2.0) + normal_rg.a;

	AO = clamp(albedo_ht.a + (1.0 - Height_AO_Strength), 0.0, 1.0);
	ROUGHNESS = roughness;
	SPECULAR = 1. - normal_rg.a;
	ALBEDO = albedo_ht.rgb;
	ALBEDO *= color_map.rgb MACRO_MULT;
	NORMAL_MAP = pack_normal(normal_rg.xyz);
	NORMAL_MAP_DEPTH = 1.0;

}

while this method is actually the fastest (overall) material method so far, unfortunatley is makes individual scale/angle per domain unworkable.

World noise is unchanged, besides seperating it from get_height() like this:

float get_noise_height(const vec2 uv) {
	highp float height = 0.0;
	float weight = region_blend(uv);
	// only calculate world noise when it could be visibile.
	if (weight <= 0.66) {
		return height;
	}
	float noise = world_noise((uv + world_noise_offset.xz) * world_noise_scale * .1) *
            world_noise_height * 10. + world_noise_offset.y * 100.;
	weight = smoothstep(0.66, 1.0, weight);
	height = mix(height, noise, weight);
	return height;
}

misc functions if someone wants put all this together

float region_blend(vec2 uv) {
	uv -= 0.5;
	const vec2 offset = vec2(0.0,1.0);
	float a = clamp(get_region_uv2(uv + offset.xy).z, -1.0, 0.0) + 1.0;
	float b = clamp(get_region_uv2(uv + offset.yy).z, -1.0, 0.0) + 1.0;
	float c = clamp(get_region_uv2(uv + offset.yx).z, -1.0, 0.0) + 1.0;
	float d = clamp(get_region_uv2(uv + offset.xx).z, -1.0, 0.0) + 1.0;
	vec2 w = smoothstep(vec2(0.0), vec2(1.0), fract(uv));
	float blend = mix(mix(d, c, w.x), mix(a, b, w.x), w.y);
    return 1.0 - blend;
}

vec4 unpack_normal(vec4 n) {
	n.xyz = n.xzy * 2.0 - 1.0;
	return n;
}

vec3 pack_normal(vec3 n) {
	return (n.xzy + 1.0) * 0.5;
}

vec2 rotate(const vec2 v, const float cosa, const float sina) {
	return vec2(cosa * v.x - sina * v.y, sina * v.x + cosa * v.y);
}

float height_blend(const float a_height, const float b_height, const float blend) {
	if(height_blending) {
		float ma = max(a_height + (1.0 - blend), b_height + blend) - (1.001 - blend_sharpness);
		float b1 = max(a_height + (1.0 - blend) - ma, 0.0);
		float b2 = max(b_height + blend - ma, 0.0);
		return clamp((b2) / (b1 + b2),0.0,1.0);
	} else {
		float contrast = 1.0 - blend_sharpness;
		float factor = (blend - contrast) / contrast;
		return clamp(factor, 0.0, 1.0);
	}
}

[Xtarsia]

as an example of pixel normals being broken, doing this:

	vec2 offset = vec2(0.0, _region_texel_size);
	float h = get_height(uv2);
	float u = get_height(uv2 + offset.yx);
	float v = get_height(uv2 + offset.xy);
	vec3 normal = vec3(h-u, _mesh_vertex_spacing, h-v);
	
	vec3 w_normal = normalize(normal);
	vec3 w_tangent = normalize(cross(w_normal, vec3(0, 0, 1)));
	vec3 w_binormal = normalize(cross(w_normal, w_tangent));
	NORMAL = mat3(VIEW_MATRIX) * w_normal;
	TANGENT = mat3(VIEW_MATRIX) * w_tangent;
	BINORMAL = mat3(VIEW_MATRIX) * w_binormal;

results in this:

[Xtarsia]

#define texelOffset(b, c) ivec3(ivec2(b.xy * _region_size + c -0.4979), int(b.z))
#define textureGather(a, b) vec4( \
    texelFetch(a, texelOffset(b, vec2(0,1)), 0).r, \
    texelFetch(a, texelOffset(b, vec2(1,1)), 0).r, \
    texelFetch(a, texelOffset(b, vec2(1,0)), 0).r, \
    texelFetch(a, texelOffset(b, vec2(0,0)), 0).r  \
)

allows mock use of "textureGather" in compatibility