Using texture from wgpu-native

[Murmele]

Hi,

I have a library which is using the C/C++ implementation of wgpu (https://github.com/gfx-rs/wgpu-native), but my application is in Rust. To reuse the texture from wgpu-native the idea is to use Texture::from_custom introduced in https://github.com/gfx-rs/wgpu/pull/8315/changes.

So in the overall it will look like this:
wgpu-native Texture pointer -> rust cxx (ffi) -> rust

To be able to use the from_custom I had to implement the wgpu::custom::TextureInterface trait for my type. In this case a few parameters are copied but not the complete texture.

Is this the correct way to pass a texture from wgpu native to rust?

pub struct CustomTexture(pub UniquePtr<ffi::Texture>); // ffi::Texture is the opaque C++ type of wgpu::Texture

impl wgpu::custom::TextureInterface for CustomTexture {
    fn create_view(
        &self,
        desc: &wgpu::TextureViewDescriptor<'_>,
    ) -> wgpu::custom::DispatchTextureView {
        // TODO: get rid of unwraps!
        let format = TextureFormat(desc.format.unwrap_or(self.0.getFormat().0));
        let dimension = TextureViewDimension(desc.dimension.unwrap()); // _or(self.0.getDimension().0);
        let usage = TextureUsages(desc.usage.unwrap_or(self.0.getUsage().0));
        let aspect = TextureAspect(desc.aspect);
        let base_mip_level = desc.base_mip_level;
        let mip_level_count = desc.mip_level_count.unwrap();
        let base_array_layer = desc.base_array_layer;
        let array_layer_count = desc.array_layer_count.unwrap(); // _or(default)
        wgpu::custom::DispatchTextureView::custom(TextureViewInterface(self.0.createView(
            format,
            dimension,
            usage,
            aspect,
            base_mip_level,
            mip_level_count,
            base_array_layer,
            array_layer_count,
        )))
    }

    fn destroy(&self) {
        self.0.destroy();
    }
}

pub fn get_texture(&mut self) -> wgpu::Texture {
        let t = self.instance.pin_mut().getTexture(); // From ffi: fn getTexture(self: Pin<&mut MapRenderer>) -> UniquePtr<Texture>;
        assert!(!t.is_null());

        let desc = wgpu::TextureDescriptor {
            /// Debug label of the texture. This will show up in graphics debuggers for easy identification.
            label: None,
            size: t.getExtend3d().0,
            mip_level_count: t.getMipLevelCount(),
            sample_count: t.getSampleCount(),
            dimension: t.getDimension().0,
            format: t.getFormat().0,
            usage: t.getUsage().0,
            view_formats: &[],
        };

        wgpu::Texture::from_custom(TextureInterface(t), &desc)
    }

[R-Cramer4]

Is this the correct way to pass a texture from wgpu native to rust?

It looks like that is correct. The purpose of that function is to allow your custom backend to create textures to give to wgpu and works like how from_custom works for the device and adapter.

[Murmele]

Thanks for the confirmation