The other way you could do it is 1 call to textureGather.

  fn linearlyFilterDepthTexture(t: texture_depth_2d, normalizedTextureCoord: vec2f) -> f32 {
    // load the 4 texels
    let texel = textureGather(t, s, normalizedTextureCoord);

    // +-+-+
    // |A|B|
    // +-+-+
    // |R|G|
    // +-+-+

    let tSize = textureDimensions(t);
    let texelCoord = max(normalizedTextureCoord * vec2f(tSize) - 0.5, vec2f(0));

    // blend horizontally
    let top = mix(texel.a, texel.b, fract(texelCoord.x));
    let bot = mix(texel.r, texel.g, fract(texelCoord.x));

    // blend vertically
    return mix(top, bot, fract(texelCoord.y));
  }

example

Thank you for your input. Do you agree that sampling & filtering a depth texture is an essential feature for WGSL. I am planning to create an issue which suggests adding at least a work-around to the WGSL spec.

So far I have used this code to get weights and then I used dot with the output to a call to gather:

fn bilinearWeights(texelCoord: vec2f) -> vec4f
{
	let a: vec2f = fract(texelCoord - vec2f(0.5, 0.5));
	let b: vec2f = vec2f(1.0, 1.0) - a;
	return vec4f(
		b.x * a.y, // x
		a.x * a.y, // y
		a.x * b.y, // z
		b.x * b.y, // w
	);
}

Do you agree that sampling & filtering a depth texture is an essential feature for WGSL

No, I don't think I agree. As pointed out above, other native APIs don't support it well so GPU devs are already dealing with the fact that many/most devices don't support it, or maybe they are using it, unaware that it's not working for many users. It looks like it work on metal devices with the exception of float 32 depth formats and all iOS devices only have depth16unorm (filterable) and depth32float (not-filterable). DirectX 12 also seems to list it as unsupported

Emulating is not trival because whether or not to filter is stored in the sampler and that info is not currently available in the shader. Example: you write

 let r = textureSampleLevel(someDepthTexture, fiteringSampler, coord) +
         textureSampleLevel(someDepthTexture, nonFiteringSampler, coord);

to emulate you some how need to pass in the state of all of the samplers or at least all samplers that are used, which some non-insignificant amount of overhead.

Further, emulating textureSampleLevel is easier (except for the issue above) but for other functions like textureSample, textureSampleGrad, textureSampleBias is it much more difficult, especially considering depth cubemaps exist.

Note that using textureSampleCompare and textureSampleCompareLevel don't have this restriction. They support bilinear filtering on depth textures. This PCF article uses comparisons to take advantage of the fact they support filtering.

Given all of that, I think it's best to leave this up to devs to emulate. They know if they want linear filtering and so can choose to call textureGather and use something like your bilinearWeights function to do the filtering. This way they can avoid slowing down all programs using depth textures that would need the overhead of passing in sampler state to every shader if WebGPU did this for them.

ps: you probably need to clamp a in your function. Otherwise, the half texel at the leading edge will wrap to the other side. That assumes you only expect values from 0.0 to 1.0 in your emulation

fn bilinearWeights(texelCoord: vec2f) -> vec4f
{
	let a: vec2f = fract(max(texelCoord - vec2f(0.5), vec2f(0)));
	let b: vec2f = vec2f(1.0) - a;
	return vec4f(
		b.x * a.y, // x
		a.x * a.y, // y
		a.x * b.y, // z
		b.x * b.y, // w
	);
}

test