Refactor: Add helper functions to GpuTexture2DHandle

crates/re_renderer/src/mesh.rs

@@ -286,14 +286,13 @@ impl GpuMesh {
                 .iter()
                 .zip(uniform_buffer_bindings.into_iter())
             {
-                let texture = ctx.texture_manager_2d.get(&material.albedo);
                 let bind_group = pools.bind_groups.alloc(
                     device,
                     pools,
                     &BindGroupDesc {
                         label: material.label.clone(),
                         entries: smallvec![
-                            BindGroupEntry::DefaultTextureView(texture.handle),
+                            BindGroupEntry::DefaultTextureView(material.albedo.wgpu_handle()),
                             uniform_buffer_binding
                         ],
                         layout: mesh_bind_group_layout,

crates/re_renderer/src/renderer/rectangles.rs

@@ -214,10 +214,8 @@ mod gpu_data {
     }
 
     impl UniformBuffer {
-        pub fn from_textured_rect(
-            rectangle: &super::TexturedRect,
-            texture_format: &wgpu::TextureFormat,
-        ) -> Result<Self, RectangleError> {
+        pub fn from_textured_rect(rectangle: &super::TexturedRect) -> Result<Self, RectangleError> {
+            let texture_format = rectangle.colormapped_texture.texture.format();
             let texture_info = texture_format.describe();
 
             let TexturedRect {
@@ -245,7 +243,7 @@ mod gpu_data {
 
             let sample_type = match texture_info.sample_type {
                 wgpu::TextureSampleType::Float { .. } => {
-                    if super::is_float_filterable(texture_format) {
+                    if super::is_float_filterable(&texture_format) {
                         SAMPLE_TYPE_FLOAT_FILTER
                     } else {
                         SAMPLE_TYPE_FLOAT_NOFILTER
@@ -351,19 +349,10 @@ impl RectangleDrawData {
             });
         }
 
-        let textures: Vec<_> = rectangles
-            .iter()
-            .map(|rectangle| {
-                ctx.texture_manager_2d
-                    .get(&rectangle.colormapped_texture.texture)
-            })
-            .collect();
-
         // TODO(emilk): continue on error (skipping just that rectangle)?
-        let uniform_buffers: Vec<_> = izip!(rectangles, &textures)
-            .map(|(rect, texture)| {
-                gpu_data::UniformBuffer::from_textured_rect(rect, &texture.creation_desc.format)
-            })
+        let uniform_buffers: Vec<_> = rectangles
+            .iter()
+            .map(gpu_data::UniformBuffer::from_textured_rect)
             .try_collect()?;
 
         let uniform_buffer_bindings = create_and_fill_uniform_buffer_batch(
@@ -373,9 +362,7 @@ impl RectangleDrawData {
         );
 
         let mut instances = Vec::with_capacity(rectangles.len());
-        for (rectangle, uniform_buffer, texture) in
-            izip!(rectangles, uniform_buffer_bindings, textures)
-        {
+        for (rectangle, uniform_buffer) in izip!(rectangles, uniform_buffer_bindings) {
             let options = &rectangle.options;
             let sampler = ctx.gpu_resources.samplers.get_or_create(
                 &ctx.device,
@@ -398,6 +385,7 @@ impl RectangleDrawData {
                 },
             );
 
+            let texture = rectangle.colormapped_texture.texture.texture();
             let texture_format = texture.creation_desc.format;
             let texture_description = texture_format.describe();
             if texture_description.required_features != Default::default() {
@@ -435,13 +423,11 @@ impl RectangleDrawData {
             let colormap_texture = if let Some(ColorMapper::Texture(handle)) =
                 &rectangle.colormapped_texture.color_mapper
             {
-                let colormap_texture = ctx.texture_manager_2d.get(handle);
-                if colormap_texture.creation_desc.format != wgpu::TextureFormat::Rgba8UnormSrgb {
-                    return Err(RectangleError::UnsupportedColormapTextureFormat(
-                        colormap_texture.creation_desc.format,
-                    ));
+                let format = handle.format();
+                if format != wgpu::TextureFormat::Rgba8UnormSrgb {
+                    return Err(RectangleError::UnsupportedColormapTextureFormat(format));
                 }
-                colormap_texture.handle
+                handle.wgpu_handle()
             } else {
                 ctx.texture_manager_2d.zeroed_texture_float().handle
             };

crates/re_renderer/src/resource_managers/texture_manager.rs

@@ -16,20 +16,38 @@ use crate::{
 pub struct GpuTexture2DHandle(GpuTexture);
 
 impl GpuTexture2DHandle {
+    #[inline]
+    pub fn texture(&self) -> &GpuTexture {
+        &self.0
+    }
+
+    #[inline]
+    pub fn wgpu_handle(&self) -> crate::wgpu_resources::GpuTextureHandle {
+        self.0.handle
+    }
+
     /// Width of the texture.
+    #[inline]
     pub fn width(&self) -> u32 {
         self.0.texture.width()
     }
 
     /// Height of the texture.
+    #[inline]
     pub fn height(&self) -> u32 {
         self.0.texture.height()
     }
 
     /// Width and height of the texture.
+    #[inline]
     pub fn width_height(&self) -> [u32; 2] {
         [self.width(), self.height()]
     }
+
+    #[inline]
+    pub fn format(&self) -> wgpu::TextureFormat {
+        self.0.texture.format()
+    }
 }
 
 /// Data required to create a texture 2d resource.
@@ -294,12 +312,6 @@ impl TextureManager2D {
         GpuTexture2DHandle(texture)
     }
 
-    /// Retrieves gpu handle.
-    #[allow(clippy::unused_self)]
-    pub fn get(&self, handle: &GpuTexture2DHandle) -> GpuTexture {
-        handle.0.clone()
-    }
-
     pub(crate) fn begin_frame(&mut self, _frame_index: u64) {
         // Drop any textures that weren't accessed in the last frame
         self.texture_cache

crates/re_viewer/src/gpu_bridge/tensor_to_gpu.rs

@@ -96,8 +96,7 @@ fn color_tensor_to_gpu(
         })
     })?;
 
-    let gpu_texture = render_ctx.texture_manager_2d.get(&texture_handle);
-    let texture_format = gpu_texture.creation_desc.format;
+    let texture_format = texture_handle.format();
 
     // Special casing for normalized textures used above:
     let range = if matches!(