mirror of
https://github.com/emilk/egui.git
synced 2026-09-01 06:10:06 -04:00
Move all crates into a crates directory (#1940)
This commit is contained in:
Emil Ernerfeldt
GitHub
290
crates/egui_glium/src/painter.rs
Normal file
290
crates/egui_glium/src/painter.rs
Normal file
@@ -0,0 +1,290 @@
|
||||
#![allow(deprecated)] // legacy implement_vertex macro
|
||||
#![allow(semicolon_in_expressions_from_macros)] // glium::program! macro
|
||||
|
||||
use egui::epaint::Primitive;
|
||||
|
||||
use {
|
||||
egui::{emath::Rect, epaint::Mesh},
|
||||
glium::{
|
||||
implement_vertex,
|
||||
index::PrimitiveType,
|
||||
program,
|
||||
texture::{self, srgb_texture2d::SrgbTexture2d},
|
||||
uniform,
|
||||
uniforms::{MagnifySamplerFilter, SamplerWrapFunction},
|
||||
},
|
||||
std::rc::Rc,
|
||||
};
|
||||
|
||||
pub struct Painter {
|
||||
max_texture_side: usize,
|
||||
program: glium::Program,
|
||||
|
||||
textures: ahash::HashMap<egui::TextureId, Rc<SrgbTexture2d>>,
|
||||
|
||||
/// [`egui::TextureId::User`] index
|
||||
next_native_tex_id: u64,
|
||||
}
|
||||
|
||||
impl Painter {
|
||||
pub fn new(facade: &dyn glium::backend::Facade) -> Painter {
|
||||
use glium::CapabilitiesSource as _;
|
||||
let max_texture_side = facade.get_capabilities().max_texture_size as _;
|
||||
|
||||
let program = program! {
|
||||
facade,
|
||||
120 => {
|
||||
vertex: include_str!("shader/vertex_120.glsl"),
|
||||
fragment: include_str!("shader/fragment_120.glsl"),
|
||||
},
|
||||
140 => {
|
||||
vertex: include_str!("shader/vertex_140.glsl"),
|
||||
fragment: include_str!("shader/fragment_140.glsl"),
|
||||
},
|
||||
100 es => {
|
||||
vertex: include_str!("shader/vertex_100es.glsl"),
|
||||
fragment: include_str!("shader/fragment_100es.glsl"),
|
||||
},
|
||||
300 es => {
|
||||
vertex: include_str!("shader/vertex_300es.glsl"),
|
||||
fragment: include_str!("shader/fragment_300es.glsl"),
|
||||
},
|
||||
}
|
||||
.expect("Failed to compile shader");
|
||||
|
||||
Painter {
|
||||
max_texture_side,
|
||||
program,
|
||||
textures: Default::default(),
|
||||
next_native_tex_id: 0,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn max_texture_side(&self) -> usize {
|
||||
self.max_texture_side
|
||||
}
|
||||
|
||||
pub fn paint_and_update_textures<T: glium::Surface>(
|
||||
&mut self,
|
||||
display: &glium::Display,
|
||||
target: &mut T,
|
||||
pixels_per_point: f32,
|
||||
clipped_primitives: &[egui::ClippedPrimitive],
|
||||
textures_delta: &egui::TexturesDelta,
|
||||
) {
|
||||
for (id, image_delta) in &textures_delta.set {
|
||||
self.set_texture(display, *id, image_delta);
|
||||
}
|
||||
|
||||
self.paint_primitives(display, target, pixels_per_point, clipped_primitives);
|
||||
|
||||
for &id in &textures_delta.free {
|
||||
self.free_texture(id);
|
||||
}
|
||||
}
|
||||
|
||||
/// Main entry-point for painting a frame.
|
||||
/// You should call `target.clear_color(..)` before
|
||||
/// and `target.finish()` after this.
|
||||
pub fn paint_primitives<T: glium::Surface>(
|
||||
&mut self,
|
||||
display: &glium::Display,
|
||||
target: &mut T,
|
||||
pixels_per_point: f32,
|
||||
clipped_primitives: &[egui::ClippedPrimitive],
|
||||
) {
|
||||
for egui::ClippedPrimitive {
|
||||
clip_rect,
|
||||
primitive,
|
||||
} in clipped_primitives
|
||||
{
|
||||
match primitive {
|
||||
Primitive::Mesh(mesh) => {
|
||||
self.paint_mesh(target, display, pixels_per_point, clip_rect, mesh);
|
||||
}
|
||||
Primitive::Callback(_) => {
|
||||
panic!("Custom rendering callbacks are not implemented in egui_glium");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(never)] // Easier profiling
|
||||
fn paint_mesh<T: glium::Surface>(
|
||||
&mut self,
|
||||
target: &mut T,
|
||||
display: &glium::Display,
|
||||
pixels_per_point: f32,
|
||||
clip_rect: &Rect,
|
||||
mesh: &Mesh,
|
||||
) {
|
||||
debug_assert!(mesh.is_valid());
|
||||
|
||||
let vertex_buffer = {
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
struct Vertex {
|
||||
a_pos: [f32; 2],
|
||||
a_tc: [f32; 2],
|
||||
a_srgba: [u8; 4],
|
||||
}
|
||||
implement_vertex!(Vertex, a_pos, a_tc, a_srgba);
|
||||
|
||||
let vertices: &[Vertex] = bytemuck::cast_slice(&mesh.vertices);
|
||||
|
||||
// TODO(emilk): we should probably reuse the [`VertexBuffer`] instead of allocating a new one each frame.
|
||||
glium::VertexBuffer::new(display, vertices).unwrap()
|
||||
};
|
||||
|
||||
// TODO(emilk): we should probably reuse the [`IndexBuffer`] instead of allocating a new one each frame.
|
||||
let index_buffer =
|
||||
glium::IndexBuffer::new(display, PrimitiveType::TrianglesList, &mesh.indices).unwrap();
|
||||
|
||||
let (width_in_pixels, height_in_pixels) = display.get_framebuffer_dimensions();
|
||||
let width_in_points = width_in_pixels as f32 / pixels_per_point;
|
||||
let height_in_points = height_in_pixels as f32 / pixels_per_point;
|
||||
|
||||
if let Some(texture) = self.texture(mesh.texture_id) {
|
||||
// The texture coordinates for text are so that both nearest and linear should work with the egui font texture.
|
||||
// For user textures linear sampling is more likely to be the right choice.
|
||||
let filter = MagnifySamplerFilter::Linear;
|
||||
|
||||
let uniforms = uniform! {
|
||||
u_screen_size: [width_in_points, height_in_points],
|
||||
u_sampler: texture.sampled().magnify_filter(filter).wrap_function(SamplerWrapFunction::Clamp),
|
||||
};
|
||||
|
||||
// egui outputs colors with premultiplied alpha:
|
||||
let color_blend_func = glium::BlendingFunction::Addition {
|
||||
source: glium::LinearBlendingFactor::One,
|
||||
destination: glium::LinearBlendingFactor::OneMinusSourceAlpha,
|
||||
};
|
||||
|
||||
// Less important, but this is technically the correct alpha blend function
|
||||
// when you want to make use of the framebuffer alpha (for screenshots, compositing, etc).
|
||||
let alpha_blend_func = glium::BlendingFunction::Addition {
|
||||
source: glium::LinearBlendingFactor::OneMinusDestinationAlpha,
|
||||
destination: glium::LinearBlendingFactor::One,
|
||||
};
|
||||
|
||||
let blend = glium::Blend {
|
||||
color: color_blend_func,
|
||||
alpha: alpha_blend_func,
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
// egui outputs mesh in both winding orders:
|
||||
let backface_culling = glium::BackfaceCullingMode::CullingDisabled;
|
||||
|
||||
// Transform clip rect to physical pixels:
|
||||
let clip_min_x = pixels_per_point * clip_rect.min.x;
|
||||
let clip_min_y = pixels_per_point * clip_rect.min.y;
|
||||
let clip_max_x = pixels_per_point * clip_rect.max.x;
|
||||
let clip_max_y = pixels_per_point * clip_rect.max.y;
|
||||
|
||||
// Make sure clip rect can fit within a `u32`:
|
||||
let clip_min_x = clip_min_x.clamp(0.0, width_in_pixels as f32);
|
||||
let clip_min_y = clip_min_y.clamp(0.0, height_in_pixels as f32);
|
||||
let clip_max_x = clip_max_x.clamp(clip_min_x, width_in_pixels as f32);
|
||||
let clip_max_y = clip_max_y.clamp(clip_min_y, height_in_pixels as f32);
|
||||
|
||||
let clip_min_x = clip_min_x.round() as u32;
|
||||
let clip_min_y = clip_min_y.round() as u32;
|
||||
let clip_max_x = clip_max_x.round() as u32;
|
||||
let clip_max_y = clip_max_y.round() as u32;
|
||||
|
||||
let params = glium::DrawParameters {
|
||||
blend,
|
||||
backface_culling,
|
||||
scissor: Some(glium::Rect {
|
||||
left: clip_min_x,
|
||||
bottom: height_in_pixels - clip_max_y,
|
||||
width: clip_max_x - clip_min_x,
|
||||
height: clip_max_y - clip_min_y,
|
||||
}),
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
target
|
||||
.draw(
|
||||
&vertex_buffer,
|
||||
&index_buffer,
|
||||
&self.program,
|
||||
&uniforms,
|
||||
¶ms,
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
pub fn set_texture(
|
||||
&mut self,
|
||||
facade: &dyn glium::backend::Facade,
|
||||
tex_id: egui::TextureId,
|
||||
delta: &egui::epaint::ImageDelta,
|
||||
) {
|
||||
let pixels: Vec<(u8, u8, u8, u8)> = match &delta.image {
|
||||
egui::ImageData::Color(image) => {
|
||||
assert_eq!(
|
||||
image.width() * image.height(),
|
||||
image.pixels.len(),
|
||||
"Mismatch between texture size and texel count"
|
||||
);
|
||||
image.pixels.iter().map(|color| color.to_tuple()).collect()
|
||||
}
|
||||
egui::ImageData::Font(image) => {
|
||||
let gamma = 1.0;
|
||||
image
|
||||
.srgba_pixels(gamma)
|
||||
.map(|color| color.to_tuple())
|
||||
.collect()
|
||||
}
|
||||
};
|
||||
let glium_image = glium::texture::RawImage2d {
|
||||
data: std::borrow::Cow::Owned(pixels),
|
||||
width: delta.image.width() as _,
|
||||
height: delta.image.height() as _,
|
||||
format: glium::texture::ClientFormat::U8U8U8U8,
|
||||
};
|
||||
let format = texture::SrgbFormat::U8U8U8U8;
|
||||
let mipmaps = texture::MipmapsOption::NoMipmap;
|
||||
|
||||
if let Some(pos) = delta.pos {
|
||||
// update a sub-region
|
||||
if let Some(gl_texture) = self.textures.get(&tex_id) {
|
||||
let rect = glium::Rect {
|
||||
left: pos[0] as _,
|
||||
bottom: pos[1] as _,
|
||||
width: glium_image.width,
|
||||
height: glium_image.height,
|
||||
};
|
||||
gl_texture.main_level().write(rect, glium_image);
|
||||
}
|
||||
} else {
|
||||
let gl_texture =
|
||||
SrgbTexture2d::with_format(facade, glium_image, format, mipmaps).unwrap();
|
||||
self.textures.insert(tex_id, gl_texture.into());
|
||||
}
|
||||
}
|
||||
|
||||
pub fn free_texture(&mut self, tex_id: egui::TextureId) {
|
||||
self.textures.remove(&tex_id);
|
||||
}
|
||||
|
||||
fn texture(&self, texture_id: egui::TextureId) -> Option<&SrgbTexture2d> {
|
||||
self.textures.get(&texture_id).map(|rc| rc.as_ref())
|
||||
}
|
||||
|
||||
pub fn register_native_texture(&mut self, native: Rc<SrgbTexture2d>) -> egui::TextureId {
|
||||
let id = egui::TextureId::User(self.next_native_tex_id);
|
||||
self.next_native_tex_id += 1;
|
||||
self.textures.insert(id, native);
|
||||
id
|
||||
}
|
||||
|
||||
pub fn replace_native_texture(&mut self, id: egui::TextureId, replacing: Rc<SrgbTexture2d>) {
|
||||
self.textures.insert(id, replacing);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user