tor-browser

textures.rs (6281B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use super::{Gui, Document, DocumentKind};
use webrender_api::debugger::DebuggerTextureContent;
use webrender_api::TextureCacheCategory;

pub fn texture_viewer_ui(ui: &mut egui::Ui, image: &DebuggerTextureContent, handle: &egui::TextureHandle) {
   ui.label(format!("Size: {}x{}, Format {:?}", image.width, image.height, image.format));

   egui::ScrollArea::both().show(ui, |ui| {
       ui.image(egui::ImageSource::Texture(
           egui::load::SizedTexture::new(
               handle.id(),
               egui::vec2(image.width as f32, image.height as f32)
           )
       ));
   });
}

pub fn texture_list_ui(app: &mut Gui, ui: &mut egui::Ui) {
  texture_list_inner(app, ui, TextureCacheCategory::Atlas);
  texture_list_inner(app, ui, TextureCacheCategory::Standalone);
  texture_list_inner(app, ui, TextureCacheCategory::RenderTarget);
  texture_list_inner(app, ui, TextureCacheCategory::PictureTile);
}

fn texture_category_query(category: TextureCacheCategory) -> &'static str {
   match category {
       TextureCacheCategory::Atlas => "atlas-textures",
       TextureCacheCategory::Standalone => "standalone-textures",
       TextureCacheCategory::PictureTile => "tile-textures",
       TextureCacheCategory::RenderTarget => "target-textures",
   }
}

fn texture_category_label(category: TextureCacheCategory) -> &'static str {
   match category {
       TextureCacheCategory::Atlas => "Atlases",
       TextureCacheCategory::Standalone => "Standalone",
       TextureCacheCategory::PictureTile => "Tiles",
       TextureCacheCategory::RenderTarget => "Render targets",
   }
}

fn texture_list_inner(app: &mut Gui, ui: &mut egui::Ui, category: TextureCacheCategory) {
   let width = ui.available_width();

   let cursor = ui.cursor().min;
   let refresh_rect = egui::Rect {
       min: egui::Pos2::new(cursor.x + width - 20.0, cursor.y),
       max: egui::Pos2::new(cursor.x + width, cursor.y + 20.0),
   };
   let refresh_button = egui::widgets::Button::new("↓");
   if ui.place(refresh_rect, refresh_button).clicked() {
       let query_result = app.net.get_with_query(
           "query", &[("type", texture_category_query(category))]
       );

       if let Ok(Some(msg)) = query_result {
           app.data_model.preview_doc_index = None;
           app.data_model.documents.retain(|doc| !doc_is_texture(doc, category));

           // Note: deserializing the textures takes a long time in
           // debug builds.
           let new_textures = serde_json::from_str(msg.as_str()).unwrap();
           add_textures(app, new_textures);
       }
   }

   egui::CollapsingHeader::new(texture_category_label(category)).default_open(true).show(ui, |ui| {
       egui::ScrollArea::vertical().show(ui, |ui| {
           for (i, doc) in app.data_model.documents.iter().enumerate() {
               if !doc_is_texture(doc, category) {
                   continue;
               }

               let item = egui::Button::selectable(
                   app.data_model.preview_doc_index == Some(i),
                   &doc.title,
               ).min_size(egui::vec2(width - 20.0, 20.0));

               if ui.add(item).clicked() {
                   app.data_model.preview_doc_index = Some(i);
               }
           }
       });
   });
}

pub fn add_textures(
   app: &mut Gui,
   mut textures: Vec<DebuggerTextureContent>,
) {
   textures.sort_by(|a, b| a.name.cmp(&b.name));
   for texture in textures {
       app.data_model.documents.push(Document {
           title: texture.name.clone(),
           kind: DocumentKind::Texture {
               content: texture,
               handle: None,
           }
       });
   }
}

/// Perform uploads if need be. Happens earlier in the update because it needs
/// access to the egui context.
pub fn prepare(app: &mut super::Gui, ctx: &egui::Context) {
   if let Some(idx) = app.data_model.preview_doc_index {
       if idx >= app.data_model.documents.len() {
           return;
       }

       let DocumentKind::Texture { content, handle } = &mut app.data_model.documents[idx].kind else {
           return;
       };

       if handle.is_some() {
           return;
       }

       if let Some(gpu_texture) = upload_texture(ctx, content) {
           *handle = Some(gpu_texture)
       }
   }
}

fn upload_texture(
   ctx: &egui::Context,
   texture: &DebuggerTextureContent,
) -> Option<egui::TextureHandle> {
   use webrender_api::ImageFormat;

   let color_image = match texture.format {
       ImageFormat::RGBA8 => {
           egui::ColorImage::from_rgba_unmultiplied(
               [texture.width as usize, texture.height as usize],
               &texture.data,
           )
       }
       ImageFormat::BGRA8 => {
           // Convert BGRA to RGBA
           let mut rgba_data = texture.data.clone();
           for pixel in rgba_data.chunks_exact_mut(4) {
               pixel.swap(0, 2); // Swap B and R
           }
           egui::ColorImage::from_rgba_unmultiplied(
               [texture.width as usize, texture.height as usize],
               &rgba_data,
           )
       }
       ImageFormat::R8 => {
           // Convert grayscale to RGBA
           let rgba_data: Vec<u8> = texture.data.iter()
               .flat_map(|&gray| [gray, gray, gray, 255])
               .collect();
           egui::ColorImage::from_rgba_unmultiplied(
               [texture.width as usize, texture.height as usize],
               &rgba_data,
           )
       }
       _ => {
           println!("Unsupported texture format: {:?}", texture.format);
           return None;
       }
   };

   Some(ctx.load_texture(
       &texture.name,
       color_image,
       egui::TextureOptions::default(),
   ))
}

fn doc_is_texture(doc: &Document, kind: TextureCacheCategory) -> bool {
   match doc.kind {
       DocumentKind::Texture { content: DebuggerTextureContent { category, .. }, .. } => {
           category == kind
       },
       _ => false,
   }
}