how to copy texture view to another one?

[videni]

Any example of how to copy a texture view to an area of another texture view? I am using Vello to render a PDF page to a temporary texture view, then need to copy it to a larger texture view created by Iced GUI application.

struct Pipeline {
    renderer: vello::Renderer,
    render_params: vello::RenderParams,
    target_texture: Option<TargetTexture>,
}

impl Pipeline {
    fn new(device: &wgpu::Device, queue: &wgpu::Queue, format: wgpu::TextureFormat, target_size: Size<u32>) -> Self {
        let renderer = vello::Renderer::new(
            device,
            RendererOptions {
                surface_format: Some( wgpu::TextureFormat::Bgra8Unorm),
                use_cpu: false,
                num_init_threads: NonZeroUsize::new(1),
                antialiasing_support: vello::AaSupport::area_only(),
            },
        )
        .expect("Unable to create Vello Renderer");

        let render_params = vello::RenderParams {
            base_color: vello::peniko::Color::BLACK,
            width: target_size.width as u32,
            height: target_size.height as u32,
            antialiasing_method: vello::AaConfig::Area,
            debug: DebugLayers::none(),
        };

        Self {
            renderer,
            render_params,
            target_texture: None,
        }
    }

    pub fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, scene: &Scene, target_size: Size<u32>) {
        // We have to create temporary texture, because
        // 1. Vello needs the device , queue arguments which are not available when at render phrase of Iced application
        // 2. The Iced texture is not available at this stage, so we save it to the pipeline , copy it to
        //the one of iced later.
        let target: TargetTexture = TargetTexture::new(device, target_size.width, target_size.height);

        self.render_params.width = target_size.width as u32;
        self.render_params.height = target_size.height as u32;

        self.renderer
            .render_to_texture(device, queue, scene, &target.view, &self.render_params)
            .expect("Got non-Send/Sync error from rendering");

        self.target_texture = Some(target);
    }
    
     //called at the render phrase of Iced GUI
    pub fn render(&self, iced_encoder: &mut wgpu::CommandEncoder, target: &wgpu::TextureView, clip_bounds: &Rectangle<u32>) {
        let vello_encoder = self.encoder;

        // Now we can copy the temporary texture to the target texture view of iced
       // We may need a new pipeline, but I don't have to do it.

        if let Some(target) = self.target_texture.as_ref() {
            dbg!(&target.view);
        }
   
    }
}

[BGR360]

Disclaimer: I am not a wgpu expert.

My first thought was that you could use copy_texture_to_texture, however that takes in Textures rather than TextureViews. And unfortunately, there doesn't appear to be any way to recover the underlying Texture from a TextureView in wgpu.

So the only way I can think of to do what you want to do is to use a RenderPipeline to "blit" your PDF texture onto Iced's TextureView. You can find an example of this in wgpu's mipmap example. That example uses the blit.wgsl shader to copy a texture's data onto another texture, which is how it generates the mipmaps for the texture.

[videni]

@BGR360 thanks for help, just checked some examples, it is best to use the textLoad function to get exact texel from the texture outputted by Vello, I can see the rendered PDF page now, but somehow, got some mysterious white strips in background, I didn't draw it , any way to debug it please?