How to load 3D float filterable textures?

[ifsheldon]

Hi guys!

I recently work on implementing a DVR renderer, and for that, I need to load volumes, which are 3D textures with single channel in my case. I've been learning along with learn-wgpu but in this tutorial, it does not mention how to load 3D textures. I had several trials myself and searched for a while, but I still cannot resolve this problem.

It seems now only textures of TextureFormat::xxUnorm are filterable. As my volumes originally contains a 12-bit scalar integer in each voxel and I use the normalized float point value of the scalar in my shader, I will need something like R16Unorm, but we don't have it right now. In my OpenGL implementation, this is very straightforward just like the code below.

glTexImage3D(GL_TEXTURE_3D, 0, GL_R32F, volume_dim.x, volume_dim.y, volume_dim.z, 0, GL_RED, GL_UNSIGNED_SHORT,
               data_array);

So, GL_R32f means I want the texture "interpreted" as a single-channel float-point texture in my shader, GL_RED means my data has only one channel, and GL_UNSIGNED_SHORT means my data is supplied in 16 bits. Then OpenGL will do the normalization and integer-to-float conversion for me.

Now, I don't know how to do the similar thing with WebGPU. I could use TextureFormat::R8Unorm, I think, but it will definitely lose precisions. I could do the trilinear interpolation myself in my fragment shader if I use non-filterable texture with TextureFormat::R16Uint.

But, are there any workarounds that are easier/faster/lossless and enable filtering? Thank you!

[kvark]

If you are targeting WebGPU proper (i.e. the Web and most portable native configuration), then indeed R32F is not filterable. I don't think it's guaranteed to be filterable in OpenGL either, but this native API has higher tolerance for undefined behavior than we do.

At the same time, we don't have R16Unorm, which would seem appropriate here. Again, the reason here is that it's not portable.

The OpenGL uploading code you posted is guaranteed to be slow: it's not a data copy, it's an actual conversion of each texel to a new format (going from U16 to R32F).

My recommendation is to use R16Float here. It has effective 11 bits of precision, which is one bit short from what you need. If your data is skewed towards 0, then there is going to be no precision loss.

Note that you'd have to convert the data to R16F yourself - there is nothing built into WebGPU that does this.

[ifsheldon]

Thanks! I think R16Float is good for now, but is it a filterable format?

[kvark]

Yes, you can see that the https://gpuweb.github.io/gpuweb/#texture-format-caps table lists both "float" and "unfilterable-float" binding types supported for it.

[ifsheldon]

Thank you very much! I haven't found that page, which is exactly what I need, although I have read the section on textures. Sorry for my sloppiness.