mirror of https://github.com/emilk/egui.git
Browse Source
* add types from proposal * add load methods on `egui::Context` * implement loaders from proposal in `egui_extras` * impl `From<Vec2>` for `SizeHint` * re-export `SizeHint` from `egui` root * rework `svg` example to use new managed `Image` * split loaders into separate files + add logging * add `log_trace` * clean up `RetainedImage` from `svg` example * refactor ehttp loader response to bytes mapping * remove spammy trace * load images even without extension * fix lints * remove unused imports * use `Image2` in `download_image` * use `visuals.error_fg_color` in `Image2` error state * update lockfile * use `Arc<ColorImage>` in `ImageData` + add `forget` API * add `ui.image2` * add byte size query api * use iterators to sum loader byte sizes * add static image loading * use static image in `svg` example * small refactor of `Image2::ui` texture loading code * add `ImageFit` to size images properly * remove println calls * add bad image load to `download_image` example * add loader file extension support tests * fix lint errors in `loaders` * remove unused `poll-promise` dependency * add some docs to `Image2` * add some docs to `egui_extras::loaders::install` * explain `loaders::install` in examples * fix lint * upgrade `ehttp` to `0.3` for some crates * Remove some unused dependencies * Remove unnecessary context clone * Turn on the `log` create feature of egui_extras in all examples * rename `forget` and document it * derive `Debug` on `SizeHint` Co-authored-by: Emil Ernerfeldt <emil.ernerfeldt@gmail.com> * round when converting SizeHint from vec2 Co-authored-by: Emil Ernerfeldt <emil.ernerfeldt@gmail.com> * add `load` module docs * docstring `add_loader` methods * expose + document `load_include_bytes` * cache texture handles in `DefaultTextureLoader` * add `image2` doctest + further document `Image2` * use `Default` for default `Image2` options * update `image2` doc comment * mention immediate-mode safety * more fit calculation into inherent impl * add hover text on spinner * add `all-loaders` feature * clarify `egui_extras::loaders::install` behavior * explain how to enable image formats * properly format `uri` * use `thread::Builder` instead of `spawn` * use eq op instead of `matches` * inline `From<Arc<ColorImage>>` for `ImageData` * allow non-`'static` bytes + `forget` in `DefaultTextureLoader` * sort features * change `ehttp` feature to `http` * update `Image2` docs * refactor loader cache type --------- Co-authored-by: Emil Ernerfeldt <emil.ernerfeldt@gmail.com>pull/3314/head
Jan Procházka
1 year ago
committed by
GitHub
GitHub
24 changed files with 1343 additions and 79 deletions
@ -0,0 +1,417 @@ |
|||
//! Types and traits related to image loading.
|
|||
//!
|
|||
//! If you just want to load some images, see [`egui_extras`](https://crates.io/crates/egui_extras/),
|
|||
//! which contains reasonable default implementations of these traits. You can get started quickly
|
|||
//! using [`egui_extras::loaders::install`](https://docs.rs/egui_extras/latest/egui_extras/loaders/fn.install.html).
|
|||
//!
|
|||
//! ## Loading process
|
|||
//!
|
|||
//! There are three kinds of loaders:
|
|||
//! - [`BytesLoader`]: load the raw bytes of an image
|
|||
//! - [`ImageLoader`]: decode the bytes into an array of colors
|
|||
//! - [`TextureLoader`]: ask the backend to put an image onto the GPU
|
|||
//!
|
|||
//! The different kinds of loaders represent different layers in the loading process:
|
|||
//!
|
|||
//! ```text,ignore
|
|||
//! ui.image2("file://image.png")
|
|||
//! └► ctx.try_load_texture("file://image.png", ...)
|
|||
//! └► TextureLoader::load("file://image.png", ...)
|
|||
//! └► ctx.try_load_image("file://image.png", ...)
|
|||
//! └► ImageLoader::load("file://image.png", ...)
|
|||
//! └► ctx.try_load_bytes("file://image.png", ...)
|
|||
//! └► BytesLoader::load("file://image.png", ...)
|
|||
//! ```
|
|||
//!
|
|||
//! As each layer attempts to load the URI, it first asks the layer below it
|
|||
//! for the data it needs to do its job. But this is not a strict requirement,
|
|||
//! an implementation could instead generate the data it needs!
|
|||
//!
|
|||
//! Loader trait implementations may be registered on a context with:
|
|||
//! - [`Context::add_bytes_loader`]
|
|||
//! - [`Context::add_image_loader`]
|
|||
//! - [`Context::add_texture_loader`]
|
|||
//!
|
|||
//! There may be multiple loaders of the same kind registered at the same time.
|
|||
//! The `try_load` methods on [`Context`] will attempt to call each loader one by one,
|
|||
//! until one of them returns something other than [`LoadError::NotSupported`].
|
|||
//!
|
|||
//! The loaders are stored in the context. This means they may hold state across frames,
|
|||
//! which they can (and _should_) use to cache the results of the operations they perform.
|
|||
//!
|
|||
//! For example, a [`BytesLoader`] that loads file URIs (`file://image.png`)
|
|||
//! would cache each file read. A [`TextureLoader`] would cache each combination
|
|||
//! of `(URI, TextureOptions)`, and so on.
|
|||
//!
|
|||
//! Each URI will be passed through the loaders as a plain `&str`.
|
|||
//! The loaders are free to derive as much meaning from the URI as they wish to.
|
|||
//! For example, a loader may determine that it doesn't support loading a specific URI
|
|||
//! if the protocol does not match what it expects.
|
|||
|
|||
use crate::Context; |
|||
use ahash::HashMap; |
|||
use epaint::mutex::Mutex; |
|||
use epaint::TextureHandle; |
|||
use epaint::{textures::TextureOptions, ColorImage, TextureId, Vec2}; |
|||
use std::ops::Deref; |
|||
use std::{error::Error as StdError, fmt::Display, sync::Arc}; |
|||
|
|||
#[derive(Clone, Debug)] |
|||
pub enum LoadError { |
|||
/// This loader does not support this protocol or image format.
|
|||
NotSupported, |
|||
|
|||
/// A custom error message (e.g. "File not found: foo.png").
|
|||
Custom(String), |
|||
} |
|||
|
|||
impl Display for LoadError { |
|||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
|||
match self { |
|||
LoadError::NotSupported => f.write_str("not supported"), |
|||
LoadError::Custom(message) => f.write_str(message), |
|||
} |
|||
} |
|||
} |
|||
|
|||
impl StdError for LoadError {} |
|||
|
|||
pub type Result<T, E = LoadError> = std::result::Result<T, E>; |
|||
|
|||
/// Given as a hint for image loading requests.
|
|||
///
|
|||
/// Used mostly for rendering SVG:s to a good size.
|
|||
///
|
|||
/// All variants will preserve the original aspect ratio.
|
|||
///
|
|||
/// Similar to `usvg::FitTo`.
|
|||
#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] |
|||
pub enum SizeHint { |
|||
/// Keep original size.
|
|||
#[default] |
|||
Original, |
|||
|
|||
/// Scale to width.
|
|||
Width(u32), |
|||
|
|||
/// Scale to height.
|
|||
Height(u32), |
|||
|
|||
/// Scale to size.
|
|||
Size(u32, u32), |
|||
} |
|||
|
|||
impl From<Vec2> for SizeHint { |
|||
fn from(value: Vec2) -> Self { |
|||
Self::Size(value.x.round() as u32, value.y.round() as u32) |
|||
} |
|||
} |
|||
|
|||
// TODO: API for querying bytes caches in each loader
|
|||
|
|||
pub type Size = [usize; 2]; |
|||
|
|||
#[derive(Clone)] |
|||
pub enum Bytes { |
|||
Static(&'static [u8]), |
|||
Shared(Arc<[u8]>), |
|||
} |
|||
|
|||
impl From<&'static [u8]> for Bytes { |
|||
#[inline] |
|||
fn from(value: &'static [u8]) -> Self { |
|||
Bytes::Static(value) |
|||
} |
|||
} |
|||
|
|||
impl From<Arc<[u8]>> for Bytes { |
|||
#[inline] |
|||
fn from(value: Arc<[u8]>) -> Self { |
|||
Bytes::Shared(value) |
|||
} |
|||
} |
|||
|
|||
impl AsRef<[u8]> for Bytes { |
|||
#[inline] |
|||
fn as_ref(&self) -> &[u8] { |
|||
match self { |
|||
Bytes::Static(bytes) => bytes, |
|||
Bytes::Shared(bytes) => bytes, |
|||
} |
|||
} |
|||
} |
|||
|
|||
impl Deref for Bytes { |
|||
type Target = [u8]; |
|||
|
|||
#[inline] |
|||
fn deref(&self) -> &Self::Target { |
|||
self.as_ref() |
|||
} |
|||
} |
|||
|
|||
#[derive(Clone)] |
|||
pub enum BytesPoll { |
|||
/// Bytes are being loaded.
|
|||
Pending { |
|||
/// Set if known (e.g. from a HTTP header, or by parsing the image file header).
|
|||
size: Option<Size>, |
|||
}, |
|||
|
|||
/// Bytes are loaded.
|
|||
Ready { |
|||
/// Set if known (e.g. from a HTTP header, or by parsing the image file header).
|
|||
size: Option<Size>, |
|||
|
|||
/// File contents, e.g. the contents of a `.png`.
|
|||
bytes: Bytes, |
|||
}, |
|||
} |
|||
|
|||
pub type BytesLoadResult = Result<BytesPoll>; |
|||
|
|||
pub trait BytesLoader { |
|||
/// Try loading the bytes from the given uri.
|
|||
///
|
|||
/// Implementations should call `ctx.request_repaint` to wake up the ui
|
|||
/// once the data is ready.
|
|||
///
|
|||
/// The implementation should cache any result, so that calling this
|
|||
/// is immediate-mode safe.
|
|||
///
|
|||
/// # Errors
|
|||
/// This may fail with:
|
|||
/// - [`LoadError::NotSupported`] if the loader does not support loading `uri`.
|
|||
/// - [`LoadError::Custom`] if the loading process failed.
|
|||
fn load(&self, ctx: &Context, uri: &str) -> BytesLoadResult; |
|||
|
|||
/// Forget the given `uri`.
|
|||
///
|
|||
/// If `uri` is cached, it should be evicted from cache,
|
|||
/// so that it may be fully reloaded.
|
|||
fn forget(&self, uri: &str); |
|||
|
|||
/// Implementations may use this to perform work at the end of a frame,
|
|||
/// such as evicting unused entries from a cache.
|
|||
fn end_frame(&self, frame_index: usize) { |
|||
let _ = frame_index; |
|||
} |
|||
|
|||
/// If the loader caches any data, this should return the size of that cache.
|
|||
fn byte_size(&self) -> usize; |
|||
} |
|||
|
|||
#[derive(Clone)] |
|||
pub enum ImagePoll { |
|||
/// Image is loading.
|
|||
Pending { |
|||
/// Set if known (e.g. from a HTTP header, or by parsing the image file header).
|
|||
size: Option<Size>, |
|||
}, |
|||
|
|||
/// Image is loaded.
|
|||
Ready { image: Arc<ColorImage> }, |
|||
} |
|||
|
|||
pub type ImageLoadResult = Result<ImagePoll>; |
|||
|
|||
pub trait ImageLoader { |
|||
/// Try loading the image from the given uri.
|
|||
///
|
|||
/// Implementations should call `ctx.request_repaint` to wake up the ui
|
|||
/// once the image is ready.
|
|||
///
|
|||
/// The implementation should cache any result, so that calling this
|
|||
/// is immediate-mode safe.
|
|||
///
|
|||
/// # Errors
|
|||
/// This may fail with:
|
|||
/// - [`LoadError::NotSupported`] if the loader does not support loading `uri`.
|
|||
/// - [`LoadError::Custom`] if the loading process failed.
|
|||
fn load(&self, ctx: &Context, uri: &str, size_hint: SizeHint) -> ImageLoadResult; |
|||
|
|||
/// Forget the given `uri`.
|
|||
///
|
|||
/// If `uri` is cached, it should be evicted from cache,
|
|||
/// so that it may be fully reloaded.
|
|||
fn forget(&self, uri: &str); |
|||
|
|||
/// Implementations may use this to perform work at the end of a frame,
|
|||
/// such as evicting unused entries from a cache.
|
|||
fn end_frame(&self, frame_index: usize) { |
|||
let _ = frame_index; |
|||
} |
|||
|
|||
/// If the loader caches any data, this should return the size of that cache.
|
|||
fn byte_size(&self) -> usize; |
|||
} |
|||
|
|||
/// A texture with a known size.
|
|||
#[derive(Clone)] |
|||
pub struct SizedTexture { |
|||
pub id: TextureId, |
|||
pub size: Size, |
|||
} |
|||
|
|||
impl SizedTexture { |
|||
pub fn from_handle(handle: &TextureHandle) -> Self { |
|||
Self { |
|||
id: handle.id(), |
|||
size: handle.size(), |
|||
} |
|||
} |
|||
} |
|||
|
|||
#[derive(Clone)] |
|||
pub enum TexturePoll { |
|||
/// Texture is loading.
|
|||
Pending { |
|||
/// Set if known (e.g. from a HTTP header, or by parsing the image file header).
|
|||
size: Option<Size>, |
|||
}, |
|||
|
|||
/// Texture is loaded.
|
|||
Ready { texture: SizedTexture }, |
|||
} |
|||
|
|||
pub type TextureLoadResult = Result<TexturePoll>; |
|||
|
|||
pub trait TextureLoader { |
|||
/// Try loading the texture from the given uri.
|
|||
///
|
|||
/// Implementations should call `ctx.request_repaint` to wake up the ui
|
|||
/// once the texture is ready.
|
|||
///
|
|||
/// The implementation should cache any result, so that calling this
|
|||
/// is immediate-mode safe.
|
|||
///
|
|||
/// # Errors
|
|||
/// This may fail with:
|
|||
/// - [`LoadError::NotSupported`] if the loader does not support loading `uri`.
|
|||
/// - [`LoadError::Custom`] if the loading process failed.
|
|||
fn load( |
|||
&self, |
|||
ctx: &Context, |
|||
uri: &str, |
|||
texture_options: TextureOptions, |
|||
size_hint: SizeHint, |
|||
) -> TextureLoadResult; |
|||
|
|||
/// Forget the given `uri`.
|
|||
///
|
|||
/// If `uri` is cached, it should be evicted from cache,
|
|||
/// so that it may be fully reloaded.
|
|||
fn forget(&self, uri: &str); |
|||
|
|||
/// Implementations may use this to perform work at the end of a frame,
|
|||
/// such as evicting unused entries from a cache.
|
|||
fn end_frame(&self, frame_index: usize) { |
|||
let _ = frame_index; |
|||
} |
|||
|
|||
/// If the loader caches any data, this should return the size of that cache.
|
|||
fn byte_size(&self) -> usize; |
|||
} |
|||
|
|||
#[derive(Default)] |
|||
pub(crate) struct DefaultBytesLoader { |
|||
cache: Mutex<HashMap<&'static str, Bytes>>, |
|||
} |
|||
|
|||
impl DefaultBytesLoader { |
|||
pub(crate) fn insert_static(&self, uri: &'static str, bytes: &'static [u8]) { |
|||
self.cache |
|||
.lock() |
|||
.entry(uri) |
|||
.or_insert_with(|| Bytes::Static(bytes)); |
|||
} |
|||
|
|||
pub(crate) fn insert_shared(&self, uri: &'static str, bytes: impl Into<Arc<[u8]>>) { |
|||
self.cache |
|||
.lock() |
|||
.entry(uri) |
|||
.or_insert_with(|| Bytes::Shared(bytes.into())); |
|||
} |
|||
} |
|||
|
|||
impl BytesLoader for DefaultBytesLoader { |
|||
fn load(&self, _: &Context, uri: &str) -> BytesLoadResult { |
|||
match self.cache.lock().get(uri).cloned() { |
|||
Some(bytes) => Ok(BytesPoll::Ready { size: None, bytes }), |
|||
None => Err(LoadError::NotSupported), |
|||
} |
|||
} |
|||
|
|||
fn forget(&self, uri: &str) { |
|||
let _ = self.cache.lock().remove(uri); |
|||
} |
|||
|
|||
fn byte_size(&self) -> usize { |
|||
self.cache.lock().values().map(|bytes| bytes.len()).sum() |
|||
} |
|||
} |
|||
|
|||
#[derive(Default)] |
|||
struct DefaultTextureLoader { |
|||
cache: Mutex<HashMap<(String, TextureOptions), TextureHandle>>, |
|||
} |
|||
|
|||
impl TextureLoader for DefaultTextureLoader { |
|||
fn load( |
|||
&self, |
|||
ctx: &Context, |
|||
uri: &str, |
|||
texture_options: TextureOptions, |
|||
size_hint: SizeHint, |
|||
) -> TextureLoadResult { |
|||
let mut cache = self.cache.lock(); |
|||
if let Some(handle) = cache.get(&(uri.into(), texture_options)) { |
|||
let texture = SizedTexture::from_handle(handle); |
|||
Ok(TexturePoll::Ready { texture }) |
|||
} else { |
|||
match ctx.try_load_image(uri, size_hint)? { |
|||
ImagePoll::Pending { size } => Ok(TexturePoll::Pending { size }), |
|||
ImagePoll::Ready { image } => { |
|||
let handle = ctx.load_texture(uri, image, texture_options); |
|||
let texture = SizedTexture::from_handle(&handle); |
|||
cache.insert((uri.into(), texture_options), handle); |
|||
Ok(TexturePoll::Ready { texture }) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
fn forget(&self, uri: &str) { |
|||
self.cache.lock().retain(|(u, _), _| u != uri); |
|||
} |
|||
|
|||
fn end_frame(&self, _: usize) {} |
|||
|
|||
fn byte_size(&self) -> usize { |
|||
self.cache |
|||
.lock() |
|||
.values() |
|||
.map(|texture| texture.byte_size()) |
|||
.sum() |
|||
} |
|||
} |
|||
|
|||
pub(crate) struct Loaders { |
|||
pub include: Arc<DefaultBytesLoader>, |
|||
pub bytes: Vec<Arc<dyn BytesLoader + Send + Sync + 'static>>, |
|||
pub image: Vec<Arc<dyn ImageLoader + Send + Sync + 'static>>, |
|||
pub texture: Vec<Arc<dyn TextureLoader + Send + Sync + 'static>>, |
|||
} |
|||
|
|||
impl Default for Loaders { |
|||
fn default() -> Self { |
|||
let include = Arc::new(DefaultBytesLoader::default()); |
|||
Self { |
|||
bytes: vec![include.clone()], |
|||
image: Vec::new(), |
|||
// By default we only include `DefaultTextureLoader`.
|
|||
texture: vec![Arc::new(DefaultTextureLoader::default())], |
|||
include, |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,58 @@ |
|||
// TODO: automatic cache eviction
|
|||
|
|||
/// Installs the default set of loaders:
|
|||
/// - `file` loader on non-Wasm targets
|
|||
/// - `http` loader (with the `ehttp` feature)
|
|||
/// - `image` loader (with the `image` feature)
|
|||
/// - `svg` loader with the `svg` feature
|
|||
///
|
|||
/// ⚠ This will do nothing and you won't see any images unless you enable some features!
|
|||
/// If you just want to be able to load `file://` and `http://` images, enable the `all-loaders` feature.
|
|||
///
|
|||
/// ⚠ The supported set of image formats is configured by adding the [`image`](https://crates.io/crates/image)
|
|||
/// crate as your direct dependency, and enabling features on it:
|
|||
///
|
|||
/// ```toml,ignore
|
|||
/// image = { version = "0.24", features = ["jpeg", "png"] }
|
|||
/// ```
|
|||
///
|
|||
/// See [`egui::load`] for more information about how loaders work.
|
|||
pub fn install(ctx: &egui::Context) { |
|||
#[cfg(not(target_arch = "wasm32"))] |
|||
ctx.add_bytes_loader(std::sync::Arc::new(self::file_loader::FileLoader::default())); |
|||
|
|||
#[cfg(feature = "http")] |
|||
ctx.add_bytes_loader(std::sync::Arc::new( |
|||
self::ehttp_loader::EhttpLoader::default(), |
|||
)); |
|||
|
|||
#[cfg(feature = "image")] |
|||
ctx.add_image_loader(std::sync::Arc::new( |
|||
self::image_loader::ImageCrateLoader::default(), |
|||
)); |
|||
|
|||
#[cfg(feature = "svg")] |
|||
ctx.add_image_loader(std::sync::Arc::new(self::svg_loader::SvgLoader::default())); |
|||
|
|||
#[cfg(all(
|
|||
target_arch = "wasm32", |
|||
not(feature = "http"), |
|||
not(feature = "image"), |
|||
not(feature = "svg") |
|||
))] |
|||
crate::log_warn!("`loaders::install` was called, but no loaders are enabled"); |
|||
|
|||
let _ = ctx; |
|||
} |
|||
|
|||
#[cfg(not(target_arch = "wasm32"))] |
|||
mod file_loader; |
|||
|
|||
#[cfg(feature = "http")] |
|||
mod ehttp_loader; |
|||
|
|||
#[cfg(feature = "image")] |
|||
mod image_loader; |
|||
|
|||
#[cfg(feature = "svg")] |
|||
mod svg_loader; |
|||
@ -0,0 +1,107 @@ |
|||
use egui::{ |
|||
ahash::HashMap, |
|||
load::{Bytes, BytesLoadResult, BytesLoader, BytesPoll, LoadError}, |
|||
mutex::Mutex, |
|||
}; |
|||
use std::{sync::Arc, task::Poll}; |
|||
|
|||
type Entry = Poll<Result<Arc<[u8]>, String>>; |
|||
|
|||
#[derive(Default)] |
|||
pub struct EhttpLoader { |
|||
cache: Arc<Mutex<HashMap<String, Entry>>>, |
|||
} |
|||
|
|||
const PROTOCOLS: &[&str] = &["http://", "https://"]; |
|||
|
|||
fn starts_with_one_of(s: &str, prefixes: &[&str]) -> bool { |
|||
prefixes.iter().any(|prefix| s.starts_with(prefix)) |
|||
} |
|||
|
|||
fn get_image_bytes( |
|||
uri: &str, |
|||
response: Result<ehttp::Response, String>, |
|||
) -> Result<Arc<[u8]>, String> { |
|||
let response = response?; |
|||
if !response.ok { |
|||
match response.text() { |
|||
Some(response_text) => { |
|||
return Err(format!( |
|||
"failed to load {uri:?}: {} {} {response_text}", |
|||
response.status, response.status_text |
|||
)) |
|||
} |
|||
None => { |
|||
return Err(format!( |
|||
"failed to load {uri:?}: {} {}", |
|||
response.status, response.status_text |
|||
)) |
|||
} |
|||
} |
|||
} |
|||
|
|||
let Some(content_type) = response.content_type() else { |
|||
return Err(format!("failed to load {uri:?}: no content-type header found")); |
|||
}; |
|||
if !content_type.starts_with("image/") { |
|||
return Err(format!("failed to load {uri:?}: expected content-type starting with \"image/\", found {content_type:?}")); |
|||
} |
|||
|
|||
Ok(response.bytes.into()) |
|||
} |
|||
|
|||
impl BytesLoader for EhttpLoader { |
|||
fn load(&self, ctx: &egui::Context, uri: &str) -> BytesLoadResult { |
|||
if !starts_with_one_of(uri, PROTOCOLS) { |
|||
return Err(LoadError::NotSupported); |
|||
} |
|||
|
|||
let mut cache = self.cache.lock(); |
|||
if let Some(entry) = cache.get(uri).cloned() { |
|||
match entry { |
|||
Poll::Ready(Ok(bytes)) => Ok(BytesPoll::Ready { |
|||
size: None, |
|||
bytes: Bytes::Shared(bytes), |
|||
}), |
|||
Poll::Ready(Err(err)) => Err(LoadError::Custom(err)), |
|||
Poll::Pending => Ok(BytesPoll::Pending { size: None }), |
|||
} |
|||
} else { |
|||
crate::log_trace!("started loading {uri:?}"); |
|||
|
|||
let uri = uri.to_owned(); |
|||
cache.insert(uri.clone(), Poll::Pending); |
|||
drop(cache); |
|||
|
|||
ehttp::fetch(ehttp::Request::get(uri.clone()), { |
|||
let ctx = ctx.clone(); |
|||
let cache = self.cache.clone(); |
|||
move |response| { |
|||
let result = get_image_bytes(&uri, response); |
|||
crate::log_trace!("finished loading {uri:?}"); |
|||
let prev = cache.lock().insert(uri, Poll::Ready(result)); |
|||
assert!(matches!(prev, Some(Poll::Pending))); |
|||
ctx.request_repaint(); |
|||
} |
|||
}); |
|||
|
|||
Ok(BytesPoll::Pending { size: None }) |
|||
} |
|||
} |
|||
|
|||
fn forget(&self, uri: &str) { |
|||
let _ = self.cache.lock().remove(uri); |
|||
} |
|||
|
|||
fn byte_size(&self) -> usize { |
|||
self.cache |
|||
.lock() |
|||
.values() |
|||
.map(|entry| match entry { |
|||
Poll::Ready(Ok(bytes)) => bytes.len(), |
|||
Poll::Ready(Err(err)) => err.len(), |
|||
_ => 0, |
|||
}) |
|||
.sum() |
|||
} |
|||
} |
|||
@ -0,0 +1,84 @@ |
|||
use egui::{ |
|||
ahash::HashMap, |
|||
load::{Bytes, BytesLoadResult, BytesLoader, BytesPoll, LoadError}, |
|||
mutex::Mutex, |
|||
}; |
|||
use std::{sync::Arc, task::Poll, thread}; |
|||
|
|||
type Entry = Poll<Result<Arc<[u8]>, String>>; |
|||
|
|||
#[derive(Default)] |
|||
pub struct FileLoader { |
|||
/// Cache for loaded files
|
|||
cache: Arc<Mutex<HashMap<String, Entry>>>, |
|||
} |
|||
|
|||
const PROTOCOL: &str = "file://"; |
|||
|
|||
impl BytesLoader for FileLoader { |
|||
fn load(&self, ctx: &egui::Context, uri: &str) -> BytesLoadResult { |
|||
// File loader only supports the `file` protocol.
|
|||
let Some(path) = uri.strip_prefix(PROTOCOL) else { |
|||
return Err(LoadError::NotSupported); |
|||
}; |
|||
|
|||
let mut cache = self.cache.lock(); |
|||
if let Some(entry) = cache.get(path).cloned() { |
|||
// `path` has either begun loading, is loaded, or has failed to load.
|
|||
match entry { |
|||
Poll::Ready(Ok(bytes)) => Ok(BytesPoll::Ready { |
|||
size: None, |
|||
bytes: Bytes::Shared(bytes), |
|||
}), |
|||
Poll::Ready(Err(err)) => Err(LoadError::Custom(err)), |
|||
Poll::Pending => Ok(BytesPoll::Pending { size: None }), |
|||
} |
|||
} else { |
|||
crate::log_trace!("started loading {uri:?}"); |
|||
// We need to load the file at `path`.
|
|||
|
|||
// Set the file to `pending` until we finish loading it.
|
|||
let path = path.to_owned(); |
|||
cache.insert(path.clone(), Poll::Pending); |
|||
drop(cache); |
|||
|
|||
// Spawn a thread to read the file, so that we don't block the render for too long.
|
|||
thread::Builder::new() |
|||
.name(format!("egui_extras::FileLoader::load({uri:?})")) |
|||
.spawn({ |
|||
let ctx = ctx.clone(); |
|||
let cache = self.cache.clone(); |
|||
let uri = uri.to_owned(); |
|||
move || { |
|||
let result = match std::fs::read(&path) { |
|||
Ok(bytes) => Ok(bytes.into()), |
|||
Err(err) => Err(err.to_string()), |
|||
}; |
|||
let prev = cache.lock().insert(path, Poll::Ready(result)); |
|||
assert!(matches!(prev, Some(Poll::Pending))); |
|||
ctx.request_repaint(); |
|||
crate::log_trace!("finished loading {uri:?}"); |
|||
} |
|||
}) |
|||
.expect("failed to spawn thread"); |
|||
|
|||
Ok(BytesPoll::Pending { size: None }) |
|||
} |
|||
} |
|||
|
|||
fn forget(&self, uri: &str) { |
|||
let _ = self.cache.lock().remove(uri); |
|||
} |
|||
|
|||
fn byte_size(&self) -> usize { |
|||
self.cache |
|||
.lock() |
|||
.values() |
|||
.map(|entry| match entry { |
|||
Poll::Ready(Ok(bytes)) => bytes.len(), |
|||
Poll::Ready(Err(err)) => err.len(), |
|||
_ => 0, |
|||
}) |
|||
.sum() |
|||
} |
|||
} |
|||
@ -0,0 +1,84 @@ |
|||
use egui::{ |
|||
ahash::HashMap, |
|||
load::{BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint}, |
|||
mutex::Mutex, |
|||
ColorImage, |
|||
}; |
|||
use std::{mem::size_of, path::Path, sync::Arc}; |
|||
|
|||
type Entry = Result<Arc<ColorImage>, String>; |
|||
|
|||
#[derive(Default)] |
|||
pub struct ImageCrateLoader { |
|||
cache: Mutex<HashMap<String, Entry>>, |
|||
} |
|||
|
|||
fn is_supported(uri: &str) -> bool { |
|||
let Some(ext) = Path::new(uri).extension().and_then(|ext| ext.to_str()) else { |
|||
// `true` because if there's no extension, assume that we support it
|
|||
return true |
|||
}; |
|||
|
|||
ext != "svg" |
|||
} |
|||
|
|||
impl ImageLoader for ImageCrateLoader { |
|||
fn load(&self, ctx: &egui::Context, uri: &str, _: SizeHint) -> ImageLoadResult { |
|||
if !is_supported(uri) { |
|||
return Err(LoadError::NotSupported); |
|||
} |
|||
|
|||
let mut cache = self.cache.lock(); |
|||
if let Some(entry) = cache.get(uri).cloned() { |
|||
match entry { |
|||
Ok(image) => Ok(ImagePoll::Ready { image }), |
|||
Err(err) => Err(LoadError::Custom(err)), |
|||
} |
|||
} else { |
|||
match ctx.try_load_bytes(uri) { |
|||
Ok(BytesPoll::Ready { bytes, .. }) => { |
|||
crate::log_trace!("started loading {uri:?}"); |
|||
let result = crate::image::load_image_bytes(&bytes).map(Arc::new); |
|||
crate::log_trace!("finished loading {uri:?}"); |
|||
cache.insert(uri.into(), result.clone()); |
|||
match result { |
|||
Ok(image) => Ok(ImagePoll::Ready { image }), |
|||
Err(err) => Err(LoadError::Custom(err)), |
|||
} |
|||
} |
|||
Ok(BytesPoll::Pending { size }) => Ok(ImagePoll::Pending { size }), |
|||
Err(err) => Err(err), |
|||
} |
|||
} |
|||
} |
|||
|
|||
fn forget(&self, uri: &str) { |
|||
let _ = self.cache.lock().remove(uri); |
|||
} |
|||
|
|||
fn byte_size(&self) -> usize { |
|||
self.cache |
|||
.lock() |
|||
.values() |
|||
.map(|result| match result { |
|||
Ok(image) => image.pixels.len() * size_of::<egui::Color32>(), |
|||
Err(err) => err.len(), |
|||
}) |
|||
.sum() |
|||
} |
|||
} |
|||
|
|||
#[cfg(test)] |
|||
mod tests { |
|||
use super::*; |
|||
|
|||
#[test] |
|||
fn check_support() { |
|||
assert!(is_supported("https://test.png")); |
|||
assert!(is_supported("test.jpeg")); |
|||
assert!(is_supported("http://test.gif")); |
|||
assert!(is_supported("test.webp")); |
|||
assert!(is_supported("file://test")); |
|||
assert!(!is_supported("test.svg")); |
|||
} |
|||
} |
|||
@ -0,0 +1,92 @@ |
|||
use egui::{ |
|||
ahash::HashMap, |
|||
load::{BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint}, |
|||
mutex::Mutex, |
|||
ColorImage, |
|||
}; |
|||
use std::{mem::size_of, path::Path, sync::Arc}; |
|||
|
|||
type Entry = Result<Arc<ColorImage>, String>; |
|||
|
|||
#[derive(Default)] |
|||
pub struct SvgLoader { |
|||
cache: Mutex<HashMap<(String, SizeHint), Entry>>, |
|||
} |
|||
|
|||
fn is_supported(uri: &str) -> bool { |
|||
let Some(ext) = Path::new(uri).extension().and_then(|ext| ext.to_str()) else { return false }; |
|||
|
|||
ext == "svg" |
|||
} |
|||
|
|||
impl ImageLoader for SvgLoader { |
|||
fn load(&self, ctx: &egui::Context, uri: &str, size_hint: SizeHint) -> ImageLoadResult { |
|||
if !is_supported(uri) { |
|||
return Err(LoadError::NotSupported); |
|||
} |
|||
|
|||
let uri = uri.to_owned(); |
|||
|
|||
let mut cache = self.cache.lock(); |
|||
// We can't avoid the `uri` clone here without unsafe code.
|
|||
if let Some(entry) = cache.get(&(uri.clone(), size_hint)).cloned() { |
|||
match entry { |
|||
Ok(image) => Ok(ImagePoll::Ready { image }), |
|||
Err(err) => Err(LoadError::Custom(err)), |
|||
} |
|||
} else { |
|||
match ctx.try_load_bytes(&uri) { |
|||
Ok(BytesPoll::Ready { bytes, .. }) => { |
|||
crate::log_trace!("started loading {uri:?}"); |
|||
let fit_to = match size_hint { |
|||
SizeHint::Original => usvg::FitTo::Original, |
|||
SizeHint::Width(w) => usvg::FitTo::Width(w), |
|||
SizeHint::Height(h) => usvg::FitTo::Height(h), |
|||
SizeHint::Size(w, h) => usvg::FitTo::Size(w, h), |
|||
}; |
|||
let result = |
|||
crate::image::load_svg_bytes_with_size(&bytes, fit_to).map(Arc::new); |
|||
crate::log_trace!("finished loading {uri:?}"); |
|||
cache.insert((uri, size_hint), result.clone()); |
|||
match result { |
|||
Ok(image) => Ok(ImagePoll::Ready { image }), |
|||
Err(err) => Err(LoadError::Custom(err)), |
|||
} |
|||
} |
|||
Ok(BytesPoll::Pending { size }) => Ok(ImagePoll::Pending { size }), |
|||
Err(err) => Err(err), |
|||
} |
|||
} |
|||
} |
|||
|
|||
fn forget(&self, uri: &str) { |
|||
self.cache.lock().retain(|(u, _), _| u != uri); |
|||
} |
|||
|
|||
fn byte_size(&self) -> usize { |
|||
self.cache |
|||
.lock() |
|||
.values() |
|||
.map(|result| match result { |
|||
Ok(image) => image.pixels.len() * size_of::<egui::Color32>(), |
|||
Err(err) => err.len(), |
|||
}) |
|||
.sum() |
|||
} |
|||
} |
|||
|
|||
#[cfg(test)] |
|||
mod tests { |
|||
use super::*; |
|||
|
|||
#[test] |
|||
fn check_support() { |
|||
// inverse of same test in `image_loader.rs`
|
|||
assert!(!is_supported("https://test.png")); |
|||
assert!(!is_supported("test.jpeg")); |
|||
assert!(!is_supported("http://test.gif")); |
|||
assert!(!is_supported("test.webp")); |
|||
assert!(!is_supported("file://test")); |
|||
assert!(is_supported("test.svg")); |
|||
} |
|||
} |
|||
Loading…
Reference in new issue