djkato/egui
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename Triangles to Mesh

Browse source
This commit is contained in:
Emil Ernerfeldt 2021-01-25 21:23:24 +01:00
parent 38ca36724a
commit 75fa77e040
18 changed files with 139 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CHANGELOG.md
View file

@ -22,6 +22,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
* `Response::active` is now gone. You can use `response.dragged()` or `response.clicked()` instead.
* Backend: pointer (mouse/touch) position and buttons are now passed to egui in the event stream.
* `DragValue::range` is now called `clamp_range` and also clamps incoming values.
* Renamed `Triangles` to `Mesh`.
### Fixed 🐛

2
egui/src/containers/frame.rs
View file

@ -160,7 +160,7 @@ impl Frame {
frame_shape
} else {
let shadow = shadow.tessellate(outer_rect, corner_radius);
let shadow = Shape::Triangles(shadow);
let shadow = Shape::Mesh(shadow);
Shape::Vec(vec![shadow, frame_shape])
}
}

14
egui/src/introspection.rs
View file

@ -3,7 +3,7 @@ use crate::*;
impl Widget for &epaint::Texture {
fn ui(self, ui: &mut Ui) -> Response {
use epaint::Triangles;
use epaint::Mesh;
ui.vertical(|ui| {
// Show font texture in demo Ui
@ -19,13 +19,13 @@ impl Widget for &epaint::Texture {
size *= ui.available_width() / size.x;
}
let (rect, response) = ui.allocate_at_least(size, Sense::hover());
let mut triangles = Triangles::default();
triangles.add_rect_with_uv(
let mut mesh = Mesh::default();
mesh.add_rect_with_uv(
rect,
[pos2(0.0, 0.0), pos2(1.0, 1.0)].into(),
Color32::WHITE,
);
ui.painter().add(Shape::triangles(triangles));
ui.painter().add(Shape::mesh(mesh));
let (tex_w, tex_h) = (self.width as f32, self.height as f32);
@ -45,9 +45,9 @@ impl Widget for &epaint::Texture {
pos2((u - texel_radius) / tex_w, (v - texel_radius) / tex_h),
pos2((u + texel_radius) / tex_w, (v + texel_radius) / tex_h),
);
let mut triangles = Triangles::default();
triangles.add_rect_with_uv(zoom_rect, uv_rect, Color32::WHITE);
ui.painter().add(Shape::triangles(triangles));
let mut mesh = Mesh::default();
mesh.add_rect_with_uv(zoom_rect, uv_rect, Color32::WHITE);
ui.painter().add(Shape::mesh(mesh));
});
})
.1

30
egui/src/widgets/color_picker.rs
View file

@ -26,20 +26,20 @@ fn background_checkers(painter: &Painter, rect: Rect) {
let checker_size = Vec2::splat(rect.height() / 2.0);
let n = (rect.width() / checker_size.x).round() as u32;
let mut triangles = Triangles::default();
let mut mesh = Mesh::default();
for i in 0..n {
let x = lerp(rect.left()..=rect.right(), i as f32 / (n as f32));
triangles.add_colored_rect(
mesh.add_colored_rect(
Rect::from_min_size(pos2(x, rect.top()), checker_size),
top_color,
);
triangles.add_colored_rect(
mesh.add_colored_rect(
Rect::from_min_size(pos2(x, rect.center().y), checker_size),
bottom_color,
);
std::mem::swap(&mut top_color, &mut bottom_color);
}
painter.add(Shape::triangles(triangles));
painter.add(Shape::mesh(mesh));
}
pub fn show_color(ui: &mut Ui, color: impl Into<Hsva>, desired_size: Vec2) -> Response {
@ -104,19 +104,19 @@ fn color_slider_1d(ui: &mut Ui, value: &mut f32, color_at: impl Fn(f32) -> Color
{
// fill color:
let mut triangles = Triangles::default();
let mut mesh = Mesh::default();
for i in 0..=N {
let t = i as f32 / (N as f32);
let color = color_at(t);
let x = lerp(rect.left()..=rect.right(), t);
triangles.colored_vertex(pos2(x, rect.top()), color);
triangles.colored_vertex(pos2(x, rect.bottom()), color);
mesh.colored_vertex(pos2(x, rect.top()), color);
mesh.colored_vertex(pos2(x, rect.bottom()), color);
if i < N {
triangles.add_triangle(2 * i + 0, 2 * i + 1, 2 * i + 2);
triangles.add_triangle(2 * i + 1, 2 * i + 2, 2 * i + 3);
mesh.add_triangle(2 * i + 0, 2 * i + 1, 2 * i + 2);
mesh.add_triangle(2 * i + 1, 2 * i + 2, 2 * i + 3);
}
}
ui.painter().add(Shape::triangles(triangles));
ui.painter().add(Shape::mesh(mesh));
}
ui.painter().rect_stroke(rect, 0.0, visuals.bg_stroke); // outline
@ -155,7 +155,7 @@ fn color_slider_2d(
}
let visuals = ui.style().interact(&response);
let mut triangles = Triangles::default();
let mut mesh = Mesh::default();
for xi in 0..=N {
for yi in 0..=N {
@ -164,18 +164,18 @@ fn color_slider_2d(
let color = color_at(xt, yt);
let x = lerp(rect.left()..=rect.right(), xt);
let y = lerp(rect.bottom()..=rect.top(), yt);
triangles.colored_vertex(pos2(x, y), color);
mesh.colored_vertex(pos2(x, y), color);
if xi < N && yi < N {
let x_offset = 1;
let y_offset = N + 1;
let tl = yi * y_offset + xi;
triangles.add_triangle(tl, tl + x_offset, tl + y_offset);
triangles.add_triangle(tl + x_offset, tl + y_offset, tl + y_offset + x_offset);
mesh.add_triangle(tl, tl + x_offset, tl + y_offset);
mesh.add_triangle(tl + x_offset, tl + y_offset, tl + y_offset + x_offset);
}
}
}
ui.painter().add(Shape::triangles(triangles)); // fill
ui.painter().add(Shape::mesh(mesh)); // fill
ui.painter().rect_stroke(rect, 0.0, visuals.bg_stroke); // outline

14
egui/src/widgets/image.rs
View file

@ -57,16 +57,16 @@ impl Image {
} = self;
if *bg_fill != Default::default() {
let mut triangles = Triangles::default();
triangles.add_colored_rect(rect, *bg_fill);
ui.painter().add(Shape::triangles(triangles));
let mut mesh = Mesh::default();
mesh.add_colored_rect(rect, *bg_fill);
ui.painter().add(Shape::mesh(mesh));
}
{
// TODO: builder pattern for Triangles
let mut triangles = Triangles::with_texture(*texture_id);
triangles.add_rect_with_uv(rect, *uv, *tint);
ui.painter().add(Shape::triangles(triangles));
// TODO: builder pattern for Mesh
let mut mesh = Mesh::with_texture(*texture_id);
mesh.add_rect_with_uv(rect, *uv, *tint);
ui.painter().add(Shape::mesh(mesh));
}
}
}

18
egui_demo_lib/src/apps/color_test.rs
View file

@ -302,26 +302,26 @@ fn vertex_gradient(ui: &mut Ui, bg_fill: Color32, gradient: &Gradient) -> Respon
use egui::paint::*;
let (rect, response) = ui.allocate_at_least(GRADIENT_SIZE, Sense::hover());
if bg_fill != Default::default() {
let mut triangles = Triangles::default();
triangles.add_colored_rect(rect, bg_fill);
ui.painter().add(Shape::triangles(triangles));
let mut mesh = Mesh::default();
mesh.add_colored_rect(rect, bg_fill);
ui.painter().add(Shape::mesh(mesh));
}
{
let n = gradient.0.len();
assert!(n >= 2);
let mut triangles = Triangles::default();
let mut mesh = Mesh::default();
for (i, &color) in gradient.0.iter().enumerate() {
let t = i as f32 / (n as f32 - 1.0);
let x = lerp(rect.x_range(), t);
triangles.colored_vertex(pos2(x, rect.top()), color);
triangles.colored_vertex(pos2(x, rect.bottom()), color);
mesh.colored_vertex(pos2(x, rect.top()), color);
mesh.colored_vertex(pos2(x, rect.bottom()), color);
if i < n - 1 {
let i = i as u32;
triangles.add_triangle(2 * i, 2 * i + 1, 2 * i + 2);
triangles.add_triangle(2 * i + 1, 2 * i + 2, 2 * i + 3);
mesh.add_triangle(2 * i, 2 * i + 1, 2 * i + 2);
mesh.add_triangle(2 * i + 1, 2 * i + 2, 2 * i + 3);
}
}
ui.painter().add(Shape::triangles(triangles));
ui.painter().add(Shape::mesh(mesh));
}
response
}

2
egui_glium/src/backend.rs
View file

@ -216,7 +216,7 @@ pub fn run(mut app: Box<dyn epi::App>) -> ! {
let frame_time = (Instant::now() - frame_start).as_secs_f64() as f32;
previous_frame_time = Some(frame_time);
painter.paint_jobs(
painter.paint_meshes(
&display,
ctx.pixels_per_point(),
app.clear_color(),

28
egui_glium/src/painter.rs
View file

@ -3,7 +3,7 @@
use {
egui::{
math::clamp,
paint::{PaintJobs, Triangles},
paint::{Mesh, PaintJobs},
Color32, Rect,
},
glium::{
@ -123,7 +123,7 @@ impl Painter {
}
/// Main entry-point for painting a frame
pub fn paint_jobs(
pub fn paint_meshes(
&mut self,
display: &glium::Display,
pixels_per_point: f32,
@ -142,28 +142,22 @@ impl Painter {
clear_color[2],
clear_color[3],
);
for (clip_rect, triangles) in jobs {
self.paint_job(
&mut target,
display,
pixels_per_point,
clip_rect,
&triangles,
)
for (clip_rect, mesh) in jobs {
self.paint_mesh(&mut target, display, pixels_per_point, clip_rect, &mesh)
}
target.finish().unwrap();
}
#[inline(never)] // Easier profiling
pub fn paint_job(
pub fn paint_mesh(
&mut self,
target: &mut Frame,
display: &glium::Display,
pixels_per_point: f32,
clip_rect: Rect,
triangles: &Triangles,
mesh: &Mesh,
) {
debug_assert!(triangles.is_valid());
debug_assert!(mesh.is_valid());
let vertex_buffer = {
#[derive(Copy, Clone)]
@ -174,7 +168,7 @@ impl Painter {
}
implement_vertex!(Vertex, a_pos, a_tc, a_srgba);
let vertices: Vec<Vertex> = triangles
let vertices: Vec<Vertex> = mesh
.vertices
.iter()
.map(|v| Vertex {
@ -188,7 +182,7 @@ impl Painter {
glium::VertexBuffer::new(display, &vertices).unwrap()
};
let indices: Vec<u32> = triangles.indices.iter().map(|idx| *idx as u32).collect();
let indices: Vec<u32> = mesh.indices.iter().map(|idx| *idx as u32).collect();
// TODO: we should probably reuse the `IndexBuffer` instead of allocating a new one each frame.
let index_buffer =
@ -198,7 +192,7 @@ impl Painter {
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.get_texture(triangles.texture_id) {
if let Some(texture) = self.get_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;
@ -227,7 +221,7 @@ impl Painter {
..Default::default()
};
// egui outputs triangles in both winding orders:
// egui outputs mesh in both winding orders:
let backface_culling = glium::BackfaceCullingMode::CullingDisabled;
// Transform clip rect to physical pixels:

2
egui_web/src/backend.rs
View file

@ -65,7 +65,7 @@ impl WebBackend {
self.painter.upload_egui_texture(&self.ctx.texture());
self.painter.clear(clear_color);
self.painter
.paint_jobs(paint_jobs, self.ctx.pixels_per_point())
.paint_meshes(paint_jobs, self.ctx.pixels_per_point())
}
pub fn painter_debug_info(&self) -> String {

3
egui_web/src/painter.rs
View file

@ -12,5 +12,6 @@ pub trait Painter {
fn clear(&mut self, lear_color: egui::Rgba);
fn paint_jobs(&mut self, jobs: egui::PaintJobs, pixels_per_point: f32) -> Result<(), JsValue>;
fn paint_meshes(&mut self, jobs: egui::PaintJobs, pixels_per_point: f32)
-> Result<(), JsValue>;
}

30
egui_web/src/webgl1.rs
View file

@ -6,7 +6,7 @@ use {
use egui::{
math::clamp,
paint::{Color32, PaintJobs, Texture, Triangles},
paint::{Color32, Mesh, PaintJobs, Texture},
vec2,
};
@ -265,21 +265,21 @@ impl WebGlPainter {
}
}
fn paint_triangles(&self, triangles: &Triangles) -> Result<(), JsValue> {
debug_assert!(triangles.is_valid());
let indices: Vec<u16> = triangles.indices.iter().map(|idx| *idx as u16).collect();
fn paint_mesh(&self, mesh: &Mesh) -> Result<(), JsValue> {
debug_assert!(mesh.is_valid());
let indices: Vec<u16> = mesh.indices.iter().map(|idx| *idx as u16).collect();
let mut positions: Vec<f32> = Vec::with_capacity(2 * triangles.vertices.len());
let mut tex_coords: Vec<f32> = Vec::with_capacity(2 * triangles.vertices.len());
for v in &triangles.vertices {
let mut positions: Vec<f32> = Vec::with_capacity(2 * mesh.vertices.len());
let mut tex_coords: Vec<f32> = Vec::with_capacity(2 * mesh.vertices.len());
for v in &mesh.vertices {
positions.push(v.pos.x);
positions.push(v.pos.y);
tex_coords.push(v.uv.x);
tex_coords.push(v.uv.y);
}
let mut colors: Vec<u8> = Vec::with_capacity(4 * triangles.vertices.len());
for v in &triangles.vertices {
let mut colors: Vec<u8> = Vec::with_capacity(4 * mesh.vertices.len());
for v in &mesh.vertices {
colors.push(v.color[0]);
colors.push(v.color[1]);
colors.push(v.color[2]);
@ -478,7 +478,7 @@ impl crate::Painter for WebGlPainter {
gl.clear(Gl::COLOR_BUFFER_BIT);
}
fn paint_jobs(&mut self, jobs: PaintJobs, pixels_per_point: f32) -> Result<(), JsValue> {
fn paint_meshes(&mut self, jobs: PaintJobs, pixels_per_point: f32) -> Result<(), JsValue> {
self.upload_user_textures();
let gl = &self.gl;
@ -504,8 +504,8 @@ impl crate::Painter for WebGlPainter {
let u_sampler_loc = gl.get_uniform_location(&self.program, "u_sampler").unwrap();
gl.uniform1i(Some(&u_sampler_loc), 0);
for (clip_rect, triangles) in jobs {
if let Some(gl_texture) = self.get_texture(triangles.texture_id) {
for (clip_rect, mesh) in jobs {
if let Some(gl_texture) = self.get_texture(mesh.texture_id) {
gl.bind_texture(Gl::TEXTURE_2D, Some(gl_texture));
let clip_min_x = pixels_per_point * clip_rect.min.x;
@ -529,13 +529,13 @@ impl crate::Painter for WebGlPainter {
clip_max_y - clip_min_y,
);
for triangles in triangles.split_to_u16() {
self.paint_triangles(&triangles)?;
for mesh in mesh.split_to_u16() {
self.paint_mesh(&mesh)?;
}
} else {
crate::console_warn(format!(
"WebGL: Failed to find texture {:?}",
triangles.texture_id
mesh.texture_id
));
}
}

30
egui_web/src/webgl2.rs
View file

@ -8,7 +8,7 @@ use {
use egui::{
math::clamp,
paint::{Color32, PaintJobs, Texture, Triangles},
paint::{Color32, Mesh, PaintJobs, Texture},
vec2,
};
@ -255,21 +255,21 @@ impl WebGl2Painter {
}
}
fn paint_triangles(&self, triangles: &Triangles) -> Result<(), JsValue> {
debug_assert!(triangles.is_valid());
let indices: Vec<u16> = triangles.indices.iter().map(|idx| *idx as u16).collect();
fn paint_mesh(&self, mesh: &Mesh) -> Result<(), JsValue> {
debug_assert!(mesh.is_valid());
let indices: Vec<u16> = mesh.indices.iter().map(|idx| *idx as u16).collect();
let mut positions: Vec<f32> = Vec::with_capacity(2 * triangles.vertices.len());
let mut tex_coords: Vec<f32> = Vec::with_capacity(2 * triangles.vertices.len());
for v in &triangles.vertices {
let mut positions: Vec<f32> = Vec::with_capacity(2 * mesh.vertices.len());
let mut tex_coords: Vec<f32> = Vec::with_capacity(2 * mesh.vertices.len());
for v in &mesh.vertices {
positions.push(v.pos.x);
positions.push(v.pos.y);
tex_coords.push(v.uv.x);
tex_coords.push(v.uv.y);
}
let mut colors: Vec<u8> = Vec::with_capacity(4 * triangles.vertices.len());
for v in &triangles.vertices {
let mut colors: Vec<u8> = Vec::with_capacity(4 * mesh.vertices.len());
for v in &mesh.vertices {
colors.push(v.color[0]);
colors.push(v.color[1]);
colors.push(v.color[2]);
@ -467,7 +467,7 @@ impl crate::Painter for WebGl2Painter {
gl.clear(Gl::COLOR_BUFFER_BIT);
}
fn paint_jobs(&mut self, jobs: PaintJobs, pixels_per_point: f32) -> Result<(), JsValue> {
fn paint_meshes(&mut self, jobs: PaintJobs, pixels_per_point: f32) -> Result<(), JsValue> {
self.upload_user_textures();
let gl = &self.gl;
@ -493,8 +493,8 @@ impl crate::Painter for WebGl2Painter {
let u_sampler_loc = gl.get_uniform_location(&self.program, "u_sampler").unwrap();
gl.uniform1i(Some(&u_sampler_loc), 0);
for (clip_rect, triangles) in jobs {
if let Some(gl_texture) = self.get_texture(triangles.texture_id) {
for (clip_rect, mesh) in jobs {
if let Some(gl_texture) = self.get_texture(mesh.texture_id) {
gl.bind_texture(Gl::TEXTURE_2D, Some(gl_texture));
let clip_min_x = pixels_per_point * clip_rect.min.x;
@ -518,13 +518,13 @@ impl crate::Painter for WebGl2Painter {
clip_max_y - clip_min_y,
);
for triangles in triangles.split_to_u16() {
self.paint_triangles(&triangles)?;
for mesh in mesh.split_to_u16() {
self.paint_mesh(&mesh)?;
}
} else {
crate::console_warn(format!(
"WebGL: Failed to find texture {:?}",
triangles.texture_id
mesh.texture_id
));
}
}

8
epaint/src/lib.rs
View file

@ -45,6 +45,7 @@
#![allow(clippy::manual_range_contains)]
pub mod color;
mod mesh;
pub mod mutex;
mod shadow;
mod shape;
@ -53,10 +54,10 @@ mod stroke;
pub mod tessellator;
pub mod text;
mod texture_atlas;
mod triangles;
pub use {
color::{Color32, Rgba},
mesh::{Mesh, Vertex},
shadow::Shadow,
shape::Shape,
stats::PaintStats,
@ -64,7 +65,6 @@ pub use {
tessellator::TessellationOptions,
text::{Galley, TextStyle},
texture_atlas::{Texture, TextureAtlas},
triangles::{Triangles, Vertex},
};
pub use ahash;
@ -76,7 +76,7 @@ pub use emath;
/// (so it doesn't do bilinear blending with bottom right corner).
pub const WHITE_UV: emath::Pos2 = emath::pos2(0.0, 0.0);
/// What texture to use in a [`Triangles`] mesh.
/// What texture to use in a [`Mesh`] mesh.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TextureId {
/// The egui font texture.
@ -115,7 +115,7 @@ pub struct ClippedShape(
);
/// A clip triangle and some textured triangles, all in points (logical pixels).
pub type PaintJob = (emath::Rect, Triangles);
pub type PaintJob = (emath::Rect, Mesh);
/// Grouped by clip rectangles, in points (logical pixels).
pub type PaintJobs = Vec<PaintJob>;

16
epaint/src/triangles.rs → epaint/src/mesh.rs
View file

@ -1,7 +1,7 @@
use crate::*;
use emath::*;
/// The vertex type.
/// The 2D vertex type.
///
/// Should be friendly to send to GPU as is.
#[repr(C)]
@ -20,9 +20,9 @@ pub struct Vertex {
pub color: Color32, // 32 bit
}
/// Textured triangles.
/// Textured triangles in two dimensions.
#[derive(Clone, Debug, Default)]
pub struct Triangles {
pub struct Mesh {
/// Draw as triangles (i.e. the length is always multiple of three).
///
/// egui is NOT consistent with what winding order it uses, so turn off backface culling.
@ -35,7 +35,7 @@ pub struct Triangles {
pub texture_id: TextureId,
}
impl Triangles {
impl Mesh {
pub fn with_texture(texture_id: TextureId) -> Self {
Self {
texture_id,
@ -60,7 +60,7 @@ impl Triangles {
}
/// Append all the indices and vertices of `other` to `self`.
pub fn append(&mut self, other: Triangles) {
pub fn append(&mut self, other: Mesh) {
debug_assert!(other.is_valid());
if self.is_empty() {
@ -68,7 +68,7 @@ impl Triangles {
} else {
assert_eq!(
self.texture_id, other.texture_id,
"Can't merge Triangles using different textures"
"Can't merge Mesh using different textures"
);
let index_offset = self.vertices.len() as u32;
@ -151,7 +151,7 @@ impl Triangles {
///
/// Splits this mesh into many smaller meshes (if needed).
/// All the returned meshes will have indices that fit into a `u16`.
pub fn split_to_u16(self) -> Vec<Triangles> {
pub fn split_to_u16(self) -> Vec<Mesh> {
const MAX_SIZE: u32 = 1 << 16;
if self.vertices.len() < MAX_SIZE as usize {
@ -190,7 +190,7 @@ impl Triangles {
MAX_SIZE
);
output.push(Triangles {
output.push(Mesh {
indices: self.indices[span_start..index_cursor]
.iter()
.map(|vi| vi - min_vindex)

8
epaint/src/shadow.rs
View file

@ -30,7 +30,7 @@ impl Shadow {
}
}
pub fn tessellate(&self, rect: emath::Rect, corner_radius: f32) -> Triangles {
pub fn tessellate(&self, rect: emath::Rect, corner_radius: f32) -> Mesh {
// tessellator.clip_rect = clip_rect; // TODO: culling
let Self { extrusion, color } = *self;
@ -47,8 +47,8 @@ impl Shadow {
anti_alias: true,
..Default::default()
});
let mut triangles = Triangles::default();
tessellator.tessellate_rect(&rect, &mut triangles);
triangles
let mut mesh = Mesh::default();
tessellator.tessellate_rect(&rect, &mut mesh);
mesh
}
}

23
epaint/src/shape.rs
View file

@ -1,6 +1,6 @@
use crate::{
text::{Fonts, Galley, TextStyle},
Color32, Stroke, Triangles,
Color32, Mesh, Stroke,
};
use emath::*;
@ -47,7 +47,7 @@ pub enum Shape {
text_style: TextStyle, // TODO: Font?
color: Color32,
},
Triangles(Triangles),
Mesh(Mesh),
}
/// ## Constructors
@ -144,14 +144,19 @@ impl Shape {
/// ## Operations
impl Shape {
pub fn triangles(triangles: Triangles) -> Self {
debug_assert!(triangles.is_valid());
Self::Triangles(triangles)
pub fn mesh(mesh: Mesh) -> Self {
debug_assert!(mesh.is_valid());
Self::Mesh(mesh)
}
#[deprecated = "Renamed `mesh`"]
pub fn triangles(mesh: Mesh) -> Self {
Self::mesh(mesh)
}
pub fn texture_id(&self) -> super::TextureId {
if let Shape::Triangles(triangles) = self {
triangles.texture_id
if let Shape::Mesh(mesh) = self {
mesh.texture_id
} else {
super::TextureId::Egui
}
@ -185,8 +190,8 @@ impl Shape {
Shape::Text { pos, .. } => {
*pos += delta;
}
Shape::Triangles(triangles) => {
triangles.translate(delta);
Shape::Mesh(mesh) => {
mesh.translate(delta);
}
}
}

10
epaint/src/stats.rs
View file

@ -67,7 +67,7 @@ impl AllocInfo {
// | Shape::Rect { .. } => Self::default(),
// Shape::Path { points, .. } => Self::from_slice(points),
// Shape::Text { galley, .. } => Self::from_galley(galley),
// Shape::Triangles(triangles) => Self::from_triangles(triangles),
// Shape::Mesh(mesh) => Self::from_mesh(mesh),
// }
// }
@ -75,8 +75,8 @@ impl AllocInfo {
Self::from_slice(galley.text.as_bytes()) + Self::from_slice(&galley.rows)
}
pub fn from_triangles(triangles: &Triangles) -> Self {
Self::from_slice(&triangles.indices) + Self::from_slice(&triangles.vertices)
pub fn from_mesh(mesh: &Mesh) -> Self {
Self::from_slice(&mesh.indices) + Self::from_slice(&mesh.vertices)
}
pub fn from_slice<T>(slice: &[T]) -> Self {
@ -182,8 +182,8 @@ impl PaintStats {
Shape::Text { galley, .. } => {
self.shape_text += AllocInfo::from_galley(galley);
}
Shape::Triangles(triangles) => {
self.shape_mesh += AllocInfo::from_triangles(triangles);
Shape::Mesh(mesh) => {
self.shape_mesh += AllocInfo::from_mesh(mesh);
}
}
}

41
epaint/src/tessellator.rs
View file

@ -1,7 +1,7 @@
//! Converts graphics primitives into textured triangles.
//!
//! This module converts lines, circles, text and more represented by [`Shape`]
//! into textured triangles represented by [`Triangles`].
//! into textured triangles represented by [`Mesh`].
#![allow(clippy::identity_op)]
@ -239,7 +239,7 @@ fn fill_closed_path(
path: &[PathPoint],
color: Color32,
options: TessellationOptions,
out: &mut Triangles,
out: &mut Mesh,
) {
if color == Color32::TRANSPARENT {
return;
@ -285,7 +285,7 @@ fn stroke_path(
path_type: PathType,
stroke: Stroke,
options: TessellationOptions,
out: &mut Triangles,
out: &mut Mesh,
) {
if stroke.width <= 0.0 || stroke.color == Color32::TRANSPARENT {
return;
@ -427,7 +427,7 @@ fn mul_color(color: Color32, factor: f32) -> Color32 {
// ----------------------------------------------------------------------------
/// Converts [`Shape`]s into [`Triangles`].
/// Converts [`Shape`]s into [`Mesh`].
pub struct Tessellator {
options: TessellationOptions,
/// Only used for culling
@ -446,7 +446,7 @@ impl Tessellator {
}
}
/// Tessellate a single [`Shape`] into a [`Triangles`].
/// Tessellate a single [`Shape`] into a [`Mesh`].
///
/// * `shape`: the shape to tessellate
/// * `options`: tessellation quality
@ -454,7 +454,7 @@ impl Tessellator {
/// * `out`: where the triangles are put
/// * `scratchpad_path`: if you plan to run `tessellate_shape`
/// many times, pass it a reference to the same `Path` to avoid excessive allocations.
pub fn tessellate_shape(&mut self, fonts: &Fonts, shape: Shape, out: &mut Triangles) {
pub fn tessellate_shape(&mut self, fonts: &Fonts, shape: Shape, out: &mut Mesh) {
let clip_rect = self.clip_rect;
let options = self.options;
@ -487,11 +487,11 @@ impl Tessellator {
fill_closed_path(&path.0, fill, options, out);
stroke_path(&path.0, Closed, stroke, options, out);
}
Shape::Triangles(triangles) => {
if triangles.is_valid() {
out.append(triangles);
Shape::Mesh(mesh) => {
if mesh.is_valid() {
out.append(mesh);
} else {
debug_assert!(false, "Invalid Triangles in Shape::Triangles");
debug_assert!(false, "Invalid Mesh in Shape::Mesh");
}
}
Shape::LineSegment { points, stroke } => {
@ -562,7 +562,7 @@ impl Tessellator {
}
}
pub(crate) fn tessellate_rect(&mut self, rect: &PaintRect, out: &mut Triangles) {
pub(crate) fn tessellate_rect(&mut self, rect: &PaintRect, out: &mut Mesh) {
let PaintRect {
mut rect,
corner_radius,
@ -599,7 +599,7 @@ impl Tessellator {
galley: &super::Galley,
text_style: super::TextStyle,
color: Color32,
out: &mut Triangles,
out: &mut Mesh,
) {
if color == Color32::TRANSPARENT {
return;
@ -663,12 +663,12 @@ impl Tessellator {
/// * `fonts`: font source when tessellating text
///
/// ## Returns
/// A list of clip rectangles with matching [`Triangles`].
/// A list of clip rectangles with matching [`Mesh`].
pub fn tessellate_shapes(
shapes: Vec<ClippedShape>,
options: TessellationOptions,
fonts: &Fonts,
) -> Vec<(Rect, Triangles)> {
) -> Vec<(Rect, Mesh)> {
let mut tessellator = Tessellator::from_options(options);
let mut jobs = PaintJobs::default();
@ -679,7 +679,7 @@ pub fn tessellate_shapes(
};
if start_new_job {
jobs.push((clip_rect, Triangles::default()));
jobs.push((clip_rect, Mesh::default()));
}
let out = &mut jobs.last_mut().unwrap().1;
@ -688,7 +688,7 @@ pub fn tessellate_shapes(
}
if options.debug_paint_clip_rects {
for (clip_rect, triangles) in &mut jobs {
for (clip_rect, mesh) in &mut jobs {
tessellator.clip_rect = Rect::everything();
tessellator.tessellate_shape(
fonts,
@ -698,7 +698,7 @@ pub fn tessellate_shapes(
fill: Default::default(),
stroke: Stroke::new(2.0, Color32::from_rgb(150, 255, 150)),
},
triangles,
mesh,
)
}
}
@ -709,11 +709,8 @@ pub fn tessellate_shapes(
}
}
for (_, triangles) in &jobs {
debug_assert!(
triangles.is_valid(),
"Tessellator generated invalid Triangles"
);
for (_, mesh) in &jobs {
debug_assert!(mesh.is_valid(), "Tessellator generated invalid Mesh");
}
jobs