ggez-egui 0.2.0

A simple implementation of egui for ggez
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::collections::{HashMap, LinkedList};

use ggez::graphics;

#[derive(Default, Clone)]
pub struct Painter {
	pub(crate) paint_jobs: Vec<egui::ClippedPrimitive>,
	pub(crate) textures_delta: LinkedList<egui::TexturesDelta>,
	textures: HashMap<egui::TextureId, graphics::Image>,
}

impl Painter {
	pub fn draw(&mut self, ctx: &mut ggez::Context, scale_factor: f32) -> ggez::GameResult {
		// Create and free textures
		if let Some(textures_delta) = self.textures_delta.pop_front() {
			self.update_textures(ctx, textures_delta)?;
		}
		// drawing meshes
		for egui::ClippedPrimitive { primitive, .. } in self.paint_jobs.as_slice() {
			match primitive {
				egui::epaint::Primitive::Mesh(mesh) => {

					let vertices = mesh.vertices.iter().map(|v| graphics::Vertex {
						pos: [v.pos.x, v.pos.y],
						uv: [v.uv.x, v.uv.y],
						color: egui::Rgba::from(v.color).to_array(),
					}).collect::<Vec<_>>();

					let ggez_mesh = graphics::Mesh::from_raw(
						ctx,
						vertices.as_slice(),
						mesh.indices.as_slice(),
						self.textures.get(&mesh.texture_id).map(|t| t.clone())
					)?;

					graphics::draw(
						ctx, &ggez_mesh,
						graphics::DrawParam::default().scale([scale_factor, scale_factor])
					)?;
				}
				egui::epaint::Primitive::Callback(_) => {
					panic!("Custom rendering callbacks are not implemented yet");
				}
			}

		}

		Ok(())
	}

	pub fn update_textures(&mut self, ctx: &mut ggez::Context, textures_delta: egui::TexturesDelta) -> ggez::GameResult {
		// set textures
		for (id, delta) in &textures_delta.set {
			let image = match &delta.image {
				egui::ImageData::Color(image) => {
					image.into_image(ctx)
				}
				egui::ImageData::Font(image) => {
					image.into_image(ctx)
				}
			}?;

			self.textures.insert(*id, image);
		}

		// free textures
		for id in &textures_delta.free {
			self.textures.remove(id);
		}

		Ok(())
	}
}

// Generate ggez Image from egui Texture
trait Image {
	fn into_image(&self, ctx: &mut ggez::Context) -> ggez::GameResult<graphics::Image>;
}

impl Image for egui::ColorImage {
	fn into_image(&self, ctx: &mut ggez::Context) -> ggez::GameResult<graphics::Image> {
		assert_eq!(
			self.width() * self.height(),
			self.pixels.len(),
			"Mismatch between texture size and texel count"
		);

		let mut pixels: Vec<u8> = Vec::with_capacity(self.pixels.len() * 4);

		for pixel in &self.pixels {
			pixels.extend(pixel.to_array());
		}

		graphics::Image::from_rgba8(
			ctx,
			self.width() as u16,
			self.height() as u16,
			pixels.as_slice()
		)
	}
}

impl Image for egui::FontImage {
	fn into_image(&self, ctx: &mut ggez::Context) -> ggez::GameResult<graphics::Image> {
		assert_eq!(
			self.width() * self.height(),
			self.pixels.len(),
			"Mismatch between texture size and texel count"
		);

		let mut pixels: Vec<u8> = Vec::with_capacity(self.pixels.len() * 4);

		let gamma = 1.0;
		for pixel in self.srgba_pixels(gamma) {
			pixels.extend(pixel.to_array());
		}

		graphics::Image::from_rgba8(
			ctx, 
			self.width()  as u16,
			self.height() as u16,
			pixels.as_slice()
		)
	}
}