,
5 | elapsed: Duration,
6 | }
7 |
8 | impl Stopwatch {
9 | pub const fn new() -> Self {
10 | Self {
11 | start: None,
12 | elapsed: Duration::ZERO,
13 | }
14 | }
15 |
16 | pub fn new_and_start() -> Self {
17 | let mut sw = Self::new();
18 | sw.start();
19 | sw
20 | }
21 |
22 | pub fn start(&mut self) {
23 | self.start = Some(Instant::now());
24 | }
25 |
26 | pub fn stop(&mut self) {
27 | self.start = None;
28 | }
29 |
30 | pub fn elapsed(&self) -> Duration {
31 | match self.start {
32 | Some(t1) => t1.elapsed() + self.elapsed,
33 | None => self.elapsed,
34 | }
35 | }
36 |
37 | pub fn elapsed_ms(&self) -> u64 {
38 | let dur = self.elapsed();
39 | dur.as_secs() * 1000 + dur.subsec_millis() as u64
40 | }
41 | }
42 |
43 | impl Default for Stopwatch {
44 | fn default() -> Self {
45 | Self::new()
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/crates/vent-ui/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "vent-ui"
3 | version.workspace = true
4 | edition.workspace = true
5 |
6 | [dependencies]
7 | vent-assets = { path = "../vent-assets"}
8 | vent-rendering = { path = "../vent-rendering"}
9 | vent-math = { path = "../vent-math"}
10 | ash = { version= "0.38", default-features = false }
11 |
12 | log = "0.4"
13 |
14 | ab_glyph = { version = "0.2.28" }
15 | # cosmic-text = "0.12"
16 | image = "0.25"
17 |
18 |
--------------------------------------------------------------------------------
/crates/vent-ui/src/font/ab_glyph.rs:
--------------------------------------------------------------------------------
1 | use std::{collections::HashMap, path::Path};
2 |
3 | use ab_glyph::{point, Font, FontVec, Glyph, PxScale, ScaleFont};
4 | use ash::vk::{self};
5 | use image::{DynamicImage, Rgba};
6 | use vent_math::vec::vec2::Vec2;
7 | use vent_rendering::{image::VulkanImage, instance::VulkanInstance};
8 |
9 | use super::Character;
10 |
11 | pub struct AbGlyphLoader {}
12 |
13 | pub const CHARACTERS_SIZE: u32 = 256; // UTF-8
14 |
15 | impl AbGlyphLoader {
16 | // Loads an new Font
17 | pub fn load(
18 | path: P,
19 | descriptor_set_layout: vk::DescriptorSetLayout,
20 | descriptor_pool: vk::DescriptorPool,
21 | instance: &mut VulkanInstance,
22 | ) -> super::Font
23 | where
24 | P: AsRef,
25 | {
26 | log::debug!(target: "ui","Loading new Font using Ab-Glyph");
27 | let font = FontVec::try_from_vec(std::fs::read(path).unwrap()).unwrap();
28 | let scale = PxScale::from(48.0);
29 | let scaled_font = font.as_scaled(scale);
30 |
31 | let mut characters = Vec::with_capacity(CHARACTERS_SIZE as usize);
32 | let mut glyphs = Vec::new();
33 | let position = point(20.0, 20.0);
34 | let max_width = 9999_f32;
35 |
36 | let v_advance = scaled_font.height() + scaled_font.line_gap();
37 | let mut caret = position + point(0.0, scaled_font.ascent());
38 | let mut last_glyph: Option = None;
39 | for charr in 0..CHARACTERS_SIZE {
40 | let char = char::from_u32(charr).unwrap();
41 |
42 | if char.is_control() {
43 | if char == '\n' {
44 | caret = point(position.x, caret.y + v_advance);
45 | last_glyph = None;
46 | }
47 | continue;
48 | }
49 | let mut glyph = scaled_font.scaled_glyph(char);
50 | if let Some(previous) = last_glyph.take() {
51 | caret.x += scaled_font.kern(previous.id, glyph.id);
52 | }
53 | glyph.position = caret;
54 |
55 | last_glyph = Some(glyph.clone());
56 | caret.x += scaled_font.h_advance(glyph.id);
57 |
58 | if !char.is_whitespace() && caret.x > position.x + max_width {
59 | caret = point(position.x, caret.y + v_advance);
60 | glyph.position = caret;
61 | last_glyph = None;
62 | }
63 |
64 | let character = Character {
65 | size: Vec2::new(scaled_font.h_advance(glyph.id), v_advance),
66 | bearing: Vec2::new(
67 | scaled_font.h_side_bearing(glyph.id),
68 | scaled_font.v_side_bearing(glyph.id),
69 | ),
70 | v_advance,
71 | };
72 | glyphs.push(glyph);
73 | characters.push(character);
74 | }
75 | log::debug!("Loaded Charaters: {}", characters.len());
76 |
77 | let outlined: Vec<_> = glyphs
78 | .into_iter()
79 | // Note: not all layout glyphs have outlines (e.g. " ")
80 | .filter_map(|g| font.outline_glyph(g))
81 | .collect();
82 |
83 | let Some(all_px_bounds) = outlined
84 | .iter()
85 | .map(|g| g.px_bounds())
86 | .reduce(|mut b, next| {
87 | b.min.x = b.min.x.min(next.min.x);
88 | b.max.x = b.max.x.max(next.max.x);
89 | b.min.y = b.min.y.min(next.min.y);
90 | b.max.y = b.max.y.max(next.max.y);
91 | b
92 | })
93 | else {
94 | panic!("No outlined glyphs?");
95 | };
96 | let mut image =
97 | DynamicImage::new_rgba8(all_px_bounds.width() as _, all_px_bounds.height() as _)
98 | .to_rgba8();
99 | const COLOUR: (u8, u8, u8) = (255, 255, 255);
100 | // Loop through the glyphs in the text, positing each one on a line
101 | for glyph in outlined {
102 | let bounds = glyph.px_bounds();
103 | // calc top/left ords in "image space"
104 | // image-x=0 means the *left most pixel*, equivalent to
105 | // px_bounds.min.x which *may be non-zero* (and similarly with y)
106 | // so `- px_bounds.min` converts the left-most/top-most to 0
107 | let img_left = bounds.min.x as u32 - all_px_bounds.min.x as u32;
108 | let img_top = bounds.min.y as u32 - all_px_bounds.min.y as u32;
109 | // Draw the glyph into the image per-pixel by using the draw closure
110 | glyph.draw(|x, y, v| {
111 | // Offset the position by the glyph bounding box
112 | let px = image.get_pixel_mut(img_left + x, img_top + y);
113 | // Turn the coverage into an alpha value (blended with any previous)
114 | *px = Rgba([
115 | COLOUR.0,
116 | COLOUR.1,
117 | COLOUR.2,
118 | px.0[3].saturating_add((v * 255.0) as u8),
119 | ]);
120 | });
121 | }
122 | // image.save("test.png").unwrap();
123 |
124 | // let image_size = Extent2D {
125 | // width: all_px_bounds.width() as u32,
126 | // height: all_px_bounds.height() as u32,
127 | // };
128 |
129 | let dimensions = image.dimensions();
130 | let mut texture =
131 | VulkanImage::from_image(instance, DynamicImage::ImageRgba8(image), false, None, None);
132 |
133 | // TODO: store everything in an Texture Atlas
134 | let descriptor_sets = VulkanInstance::allocate_descriptor_sets(
135 | &instance.device,
136 | descriptor_pool,
137 | descriptor_set_layout,
138 | instance.swapchain_images.len(),
139 | );
140 |
141 | for &descriptor_set in descriptor_sets.iter() {
142 | let image_info = vk::DescriptorImageInfo::default()
143 | .image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
144 | .image_view(texture.image_view)
145 | .sampler(texture.sampler);
146 |
147 | let desc_sets = [vk::WriteDescriptorSet {
148 | dst_set: descriptor_set,
149 | dst_binding: 0, // From DescriptorSetLayoutBinding
150 | descriptor_count: 1,
151 | descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
152 | p_image_info: &image_info,
153 | ..Default::default()
154 | }];
155 | unsafe {
156 | instance.device.update_descriptor_sets(&desc_sets, &[]);
157 | }
158 | }
159 | texture.destroy(&instance.device);
160 | super::Font {
161 | font_atlas: descriptor_sets,
162 | characters,
163 | buffer_cache: HashMap::new(),
164 | atlas_width: dimensions.0,
165 | atlas_height: dimensions.1,
166 | }
167 | }
168 | }
169 |
--------------------------------------------------------------------------------
/crates/vent-ui/src/font/loader.rs:
--------------------------------------------------------------------------------
1 | use std::{collections::HashMap, path::Path};
2 |
3 | use ab_glyph::{point, Font, FontVec, Glyph, PxScale, ScaleFont};
4 | use ash::vk::{self};
5 | use image::{DynamicImage, Rgba};
6 | use vent_math::vec::vec2::Vec2;
7 | use vent_rendering::{image::VulkanImage, instance::VulkanInstance};
8 |
9 | pub struct AbGlyphLoader {}
10 |
11 | pub const CHARACTERS_SIZE: u32 = 256; // UTF-8
12 |
13 | impl AbGlyphLoader {
14 | // Loads an new Font
15 | pub fn load(
16 | path: P,
17 | descriptor_set_layout: vk::DescriptorSetLayout,
18 | descriptor_pool: vk::DescriptorPool,
19 | instance: &mut VulkanInstance,
20 | ) -> super::Font
21 | where
22 | P: AsRef,
23 | {
24 | log::debug!(target: "ui","Loading new Font using Ab-Glyph");
25 | let font = FontVec::try_from_vec(std::fs::read(path).unwrap()).unwrap();
26 | let scale = PxScale::from(48.0);
27 | let scaled_font = font.as_scaled(scale);
28 |
29 | let mut characters = Vec::with_capacity(CHARACTERS_SIZE as usize);
30 | let mut glyphs = Vec::new();
31 | let position = point(20.0, 20.0);
32 | let max_width = 9999_f32;
33 |
34 | let v_advance = scaled_font.height() + scaled_font.line_gap();
35 | let mut caret = position + point(0.0, scaled_font.ascent());
36 | let mut last_glyph: Option = None;
37 | for charr in 0..CHARACTERS_SIZE {
38 | let char = char::from_u32(charr).unwrap();
39 |
40 | if char.is_control() {
41 | if char.is_whitespace() {
42 | caret = point(position.x, caret.y + v_advance);
43 | last_glyph = None;
44 | }
45 | continue;
46 | }
47 | let mut glyph = scaled_font.scaled_glyph(char);
48 | if let Some(previous) = last_glyph.take() {
49 | caret.x += scaled_font.kern(previous.id, glyph.id);
50 | }
51 | glyph.position = caret;
52 |
53 | last_glyph = Some(glyph.clone());
54 | caret.x += scaled_font.h_advance(glyph.id);
55 |
56 | if !char.is_whitespace() && caret.x > position.x + max_width {
57 | caret = point(position.x, caret.y + v_advance);
58 | glyph.position = caret;
59 | last_glyph = None;
60 | }
61 |
62 | let character = Character {
63 | size: Vec2::new(scaled_font.h_advance(glyph.id), v_advance),
64 | bearing: Vec2::new(
65 | scaled_font.h_side_bearing(glyph.id),
66 | scaled_font.v_side_bearing(glyph.id),
67 | ),
68 | v_advance,
69 | };
70 | glyphs.push(glyph);
71 | characters.push(character);
72 | }
73 | log::debug!("Loaded Charaters: {}", characters.len());
74 |
75 | let outlined: Vec<_> = glyphs
76 | .into_iter()
77 | // Note: not all layout glyphs have outlines (e.g. " ")
78 | .filter_map(|g| font.outline_glyph(g))
79 | .collect();
80 |
81 | let Some(all_px_bounds) = outlined
82 | .iter()
83 | .map(|g| g.px_bounds())
84 | .reduce(|mut b, next| {
85 | b.min.x = b.min.x.min(next.min.x);
86 | b.max.x = b.max.x.max(next.max.x);
87 | b.min.y = b.min.y.min(next.min.y);
88 | b.max.y = b.max.y.max(next.max.y);
89 | b
90 | })
91 | else {
92 | panic!("No outlined glyphs?");
93 | };
94 | let mut image =
95 | DynamicImage::new_rgba8(all_px_bounds.width() as _, all_px_bounds.height() as _)
96 | .to_rgba8();
97 | const COLOUR: (u8, u8, u8) = (255, 255, 255);
98 | // Loop through the glyphs in the text, positing each one on a line
99 | for glyph in outlined {
100 | let bounds = glyph.px_bounds();
101 | // calc top/left ords in "image space"
102 | // image-x=0 means the *left most pixel*, equivalent to
103 | // px_bounds.min.x which *may be non-zero* (and similarly with y)
104 | // so `- px_bounds.min` converts the left-most/top-most to 0
105 | let img_left = bounds.min.x as u32 - all_px_bounds.min.x as u32;
106 | let img_top = bounds.min.y as u32 - all_px_bounds.min.y as u32;
107 | // Draw the glyph into the image per-pixel by using the draw closure
108 | glyph.draw(|x, y, v| {
109 | // Offset the position by the glyph bounding box
110 | let px = image.get_pixel_mut(img_left + x, img_top + y);
111 | // Turn the coverage into an alpha value (blended with any previous)
112 | *px = Rgba([
113 | COLOUR.0,
114 | COLOUR.1,
115 | COLOUR.2,
116 | px.0[3].saturating_add((v * 255.0) as u8),
117 | ]);
118 | });
119 | }
120 | // image.save("test.png").unwrap();
121 |
122 | // let image_size = Extent2D {
123 | // width: all_px_bounds.width() as u32,
124 | // height: all_px_bounds.height() as u32,
125 | // };
126 |
127 | let dimensions = image.dimensions();
128 | let sampler = vk::SamplerCreateInfo::default()
129 | .max_lod(1.0);
130 | let texture =
131 | VulkanImage::from_image(instance, DynamicImage::ImageRgba8(image), false, Some(sampler), Some("Font Atlas"));
132 |
133 | // TODO: store everything in an Texture Atlas
134 | let descriptor_sets = VulkanInstance::allocate_descriptor_sets(
135 | &instance.device,
136 | descriptor_pool,
137 | descriptor_set_layout,
138 | instance.swapchain_images.len(),
139 | );
140 |
141 | for &descriptor_set in descriptor_sets.iter() {
142 | let image_info = vk::DescriptorImageInfo::default()
143 | .image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
144 | .image_view(texture.image_view)
145 | .sampler(texture.sampler);
146 |
147 | let desc_sets = [vk::WriteDescriptorSet {
148 | dst_set: descriptor_set,
149 | dst_binding: 0, // From DescriptorSetLayoutBinding
150 | descriptor_count: 1,
151 | descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
152 | p_image_info: &image_info,
153 | ..Default::default()
154 | }];
155 | unsafe {
156 | instance.device.update_descriptor_sets(&desc_sets, &[]);
157 | }
158 | }
159 | super::Font {
160 | font_atlas: descriptor_sets,
161 | characters,
162 | font_texture: texture,
163 | buffer_cache: HashMap::new(),
164 | atlas_width: dimensions.0,
165 | atlas_height: dimensions.1,
166 | scale_in_pixels: 1
167 | }
168 | }
169 | }
170 |
--------------------------------------------------------------------------------
/crates/vent-ui/src/font/mod.rs:
--------------------------------------------------------------------------------
1 | use std::collections::HashMap;
2 |
3 | use ash::vk;
4 | use vent_math::vec::vec2::Vec2;
5 | use vent_rendering::{buffer::VulkanBuffer, instance::VulkanInstance, vertex::Vertex2D};
6 |
7 | pub mod ab_glyph;
8 |
9 | pub struct Character {
10 | size: Vec2,
11 | bearing: Vec2,
12 | v_advance: f32,
13 | }
14 |
15 | #[allow(dead_code)]
16 | pub struct Font {
17 | buffer_cache: HashMap,
18 | font_atlas: Vec,
19 | atlas_width: u32,
20 | atlas_height: u32,
21 | characters: Vec,
22 | }
23 |
24 | impl Font {
25 | // Bind Pipeline before
26 | #[allow(clippy::too_many_arguments)]
27 | pub fn render_text(
28 | &mut self,
29 | instance: &VulkanInstance,
30 | command_buffer: vk::CommandBuffer,
31 | pipeline_layout: vk::PipelineLayout,
32 | buffer_index: usize,
33 | text: String,
34 | x: f32,
35 | y: f32,
36 | scale: f32,
37 | color: u32,
38 | ) {
39 | unsafe {
40 | instance.device.cmd_bind_descriptor_sets(
41 | command_buffer,
42 | vk::PipelineBindPoint::GRAPHICS,
43 | pipeline_layout,
44 | 0,
45 | &self.font_atlas[buffer_index..=buffer_index],
46 | &[],
47 | )
48 | };
49 |
50 | let characters = &self.characters;
51 |
52 | if !self.buffer_cache.contains_key(&text) {
53 | // Todo, Support changing colors for same text
54 | let mut batched_vertices = Vec::new();
55 | // Loop through each character in the text
56 | let mut current_x = x;
57 | for character in text.chars() {
58 | let character_index = character as usize;
59 |
60 | // Check if the character is within the loaded characters
61 | if character_index < characters.len() {
62 | let character = &characters[character_index];
63 |
64 | let xpos = current_x + character.bearing.x * scale;
65 | let ypos = y - (character.size.y - character.bearing.y) * scale;
66 | let width = character.size.x * scale;
67 | let height = character.size.y * scale;
68 |
69 | let vertices: [Vertex2D; 6] = [
70 | Vertex2D {
71 | position: [xpos, ypos + height],
72 | tex_coord: [0.0, 0.0],
73 | color,
74 | },
75 | Vertex2D {
76 | position: [xpos, ypos],
77 | tex_coord: [0.0, 1.0],
78 | color,
79 | },
80 | Vertex2D {
81 | position: [xpos + width, ypos],
82 | tex_coord: [1.0, 1.0],
83 | color,
84 | },
85 | Vertex2D {
86 | position: [xpos, ypos + height],
87 | tex_coord: [0.0, 0.0],
88 | color,
89 | },
90 | Vertex2D {
91 | position: [xpos + width, ypos],
92 | tex_coord: [1.0, 1.0],
93 | color,
94 | },
95 | Vertex2D {
96 | position: [xpos + width, ypos + height],
97 | tex_coord: [1.0, 0.0],
98 | color,
99 | },
100 | ];
101 | for vertex in vertices {
102 | batched_vertices.push(vertex);
103 | }
104 | current_x += character.v_advance * scale;
105 | } else {
106 | log::warn!("Text Character is too big {}", character_index)
107 | }
108 | }
109 | Self::create_buffer(
110 | &mut self.buffer_cache,
111 | instance,
112 | text.clone(),
113 | &batched_vertices,
114 | );
115 | }
116 | let (vertex_count, buffer) = &self.buffer_cache[&text];
117 |
118 | let render_area = vk::Rect2D::default()
119 | .offset(vk::Offset2D::default())
120 | .extent(instance.surface_resolution);
121 |
122 | unsafe {
123 | instance
124 | .device
125 | .cmd_set_scissor(command_buffer, 0, &[render_area]);
126 | instance.device.cmd_bind_vertex_buffers2(
127 | command_buffer,
128 | 0,
129 | &[**buffer],
130 | &[0],
131 | None,
132 | None,
133 | );
134 | instance
135 | .device
136 | .cmd_draw(command_buffer, *vertex_count, 1, 0, 0)
137 | }
138 |
139 | // Update offset for the next character
140 | }
141 |
142 | fn create_buffer(
143 | buffer_cache: &mut HashMap,
144 | instance: &VulkanInstance,
145 | text: String,
146 | vertices: &[Vertex2D],
147 | ) {
148 | let vertex_size = std::mem::size_of_val(vertices) as vk::DeviceSize;
149 |
150 | let vulkan_buffer = VulkanBuffer::cpu_to_gpu(
151 | instance,
152 | vertices,
153 | vertex_size,
154 | vk::BufferUsageFlags::VERTEX_BUFFER,
155 | Some("Font Buffer"),
156 | );
157 | buffer_cache.insert(text, (vertices.len() as u32, vulkan_buffer));
158 | }
159 |
160 | pub fn destroy(&mut self, device: &ash::Device) {
161 | for mut buffer in self.buffer_cache.drain() {
162 | buffer.1 .1.destroy(device);
163 | }
164 | }
165 | }
166 |
--------------------------------------------------------------------------------
/crates/vent-ui/src/lib.rs:
--------------------------------------------------------------------------------
1 | pub mod font;
2 | pub mod renderer;
3 | pub mod widgets;
4 |
5 | pub trait GUI {
6 | fn update(&mut self);
7 | }
8 |
--------------------------------------------------------------------------------
/crates/vent-ui/src/renderer.rs:
--------------------------------------------------------------------------------
1 | use std::{mem::size_of, path::PathBuf};
2 |
3 | use ash::vk::{self};
4 | use vent_assets::io::file::FileAsset;
5 | use vent_math::vec::vec2::Vec2;
6 | use vent_rendering::{
7 | any_as_u8_slice, instance::VulkanInstance, pipeline::VulkanPipeline, vertex::Vertex2D,
8 | };
9 |
10 | use crate::font::{ab_glyph::AbGlyphLoader, Font};
11 |
12 | use super::GUI;
13 |
14 | #[allow(dead_code)]
15 | pub struct GuiRenderer {
16 | descriptor_pool: vk::DescriptorPool,
17 | pipeline: VulkanPipeline,
18 |
19 | // Font
20 | push_constant: PushConstant,
21 | font: Option,
22 |
23 | guis: Vec>,
24 | }
25 |
26 | #[repr(C)]
27 | pub struct PushConstant {
28 | scale: Vec2,
29 | translate: Vec2,
30 | }
31 |
32 | impl GuiRenderer {
33 | pub const DEFAULT_TEXTURE_FILTER: vk::Filter = vk::Filter::LINEAR;
34 |
35 | pub fn new(instance: &mut VulkanInstance) -> Self {
36 | log::debug!(target: "ui", "initialising UI Renderer");
37 |
38 | let pipeline = Self::create_pipeline(instance);
39 |
40 | let push_constant = PushConstant {
41 | scale: Vec2::ONE,
42 | translate: Vec2::ZERO,
43 | };
44 |
45 | let descriptor_pool = Self::create_descriptor_pool(
46 | 1, // 1 Font
47 | instance.swapchain_images.len() as u32,
48 | &instance.device,
49 | );
50 |
51 | let mut renderer = Self {
52 | descriptor_pool,
53 | pipeline,
54 | push_constant,
55 | font: None,
56 | guis: Vec::new(),
57 | };
58 | let path = FileAsset::new("assets/fonts/Arial.ttf");
59 | // Load default font
60 | renderer.load_font(instance, path.root_path());
61 | renderer
62 | }
63 |
64 | fn create_pipeline(instance: &VulkanInstance) -> VulkanPipeline {
65 | let vertex_shader = FileAsset::new("assets/shaders/app/2D/gui.vert.spv");
66 | let fragment_shader = FileAsset::new("assets/shaders/app/2D/gui.frag.spv");
67 |
68 | let desc_layout_bindings = [
69 | // Fragment
70 | vk::DescriptorSetLayoutBinding {
71 | binding: 0,
72 | descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
73 | descriptor_count: 1,
74 | stage_flags: vk::ShaderStageFlags::FRAGMENT,
75 | ..Default::default()
76 | },
77 | ];
78 |
79 | let push_constant_range = vk::PushConstantRange::default()
80 | .size(size_of::() as u32)
81 | .stage_flags(vk::ShaderStageFlags::VERTEX);
82 |
83 | VulkanPipeline::create_simple_pipeline(
84 | instance,
85 | vertex_shader.root_path(),
86 | fragment_shader.root_path(),
87 | &[Vertex2D::binding_description()],
88 | &Vertex2D::input_descriptions(),
89 | instance.surface_resolution,
90 | &[push_constant_range],
91 | &desc_layout_bindings,
92 | )
93 | }
94 |
95 | pub fn create_descriptor_pool(
96 | material_count: u32,
97 | swapchain_count: u32,
98 | device: &ash::Device,
99 | ) -> vk::DescriptorPool {
100 | let pool_sizes = [vk::DescriptorPoolSize {
101 | ty: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
102 | descriptor_count: material_count * swapchain_count,
103 | }];
104 |
105 | let create_info = vk::DescriptorPoolCreateInfo::default()
106 | .pool_sizes(&pool_sizes)
107 | .max_sets(material_count * swapchain_count);
108 |
109 | unsafe { device.create_descriptor_pool(&create_info, None) }.unwrap()
110 | }
111 |
112 | #[allow(clippy::too_many_arguments)]
113 | pub fn render_text(
114 | &mut self,
115 | instance: &VulkanInstance,
116 | command_buffer: vk::CommandBuffer,
117 | buffer_index: usize,
118 | text: String,
119 | x: f32,
120 | y: f32,
121 | scale: f32,
122 | color: u32,
123 | ) {
124 | if let Some(font) = &mut self.font {
125 | unsafe {
126 | instance.device.cmd_bind_pipeline(
127 | command_buffer,
128 | vk::PipelineBindPoint::GRAPHICS,
129 | self.pipeline.pipeline,
130 | )
131 | };
132 | let viewport = vk::Viewport::default()
133 | .width(instance.surface_resolution.width as f32)
134 | .height(instance.surface_resolution.height as f32)
135 | .max_depth(1.0);
136 | unsafe {
137 | instance
138 | .device
139 | .cmd_set_viewport(command_buffer, 0, &[viewport]);
140 | }
141 | let p_scale = Vec2::new(2.0, 2.0);
142 | let translate = Vec2::new(-1.0 - 0.0 * p_scale.x, -1.0 - 0.0 * p_scale.y);
143 |
144 | self.push_constant = PushConstant {
145 | scale: p_scale,
146 | translate,
147 | };
148 |
149 | unsafe {
150 | instance.device.cmd_push_constants(
151 | command_buffer,
152 | self.pipeline.pipeline_layout,
153 | vk::ShaderStageFlags::VERTEX,
154 | 0,
155 | any_as_u8_slice(&self.push_constant),
156 | )
157 | }
158 | font.render_text(
159 | instance,
160 | command_buffer,
161 | self.pipeline.pipeline_layout,
162 | buffer_index,
163 | text,
164 | x,
165 | y,
166 | scale,
167 | color,
168 | );
169 | }
170 | }
171 |
172 | pub fn load_font(&mut self, instance: &mut VulkanInstance, path: &PathBuf) {
173 | self.font = Some(AbGlyphLoader::load(
174 | path,
175 | self.pipeline.descriptor_set_layout,
176 | self.descriptor_pool,
177 | instance,
178 | ));
179 | }
180 |
181 | pub fn render(&mut self) {
182 | for gui in self.guis.iter_mut() {
183 | gui.update()
184 | }
185 | }
186 |
187 | pub fn add_gui(mut self, gui: Box) -> Self {
188 | self.guis.push(gui);
189 | self
190 | }
191 |
192 | #[inline]
193 | #[allow(dead_code)]
194 | pub fn register_texture(&mut self) {}
195 |
196 | pub fn destroy(&mut self, device: &ash::Device) {
197 | unsafe {
198 | if let Some(font) = &mut self.font {
199 | font.destroy(device);
200 | self.font = None
201 | }
202 | self.pipeline.destroy(device);
203 | device.destroy_descriptor_pool(self.descriptor_pool, None);
204 | }
205 | }
206 | }
207 |
--------------------------------------------------------------------------------
/crates/vent-ui/src/widgets/button.rs:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/crates/vent-ui/src/widgets/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod button;
2 |
--------------------------------------------------------------------------------
/crates/vent-window/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "vent-window"
3 | version.workspace = true
4 | edition.workspace = true
5 |
6 | targets = [
7 | # Windows
8 | "i686-pc-windows-msvc",
9 | "x86_64-pc-windows-msvc",
10 | # Unix Wayland
11 | "i686-unknown-linux-gnu",
12 | "x86_64-unknown-linux-gnu",
13 | ]
14 |
15 | [features]
16 |
17 | [dependencies]
18 | log = "0.4"
19 | raw-window-handle = { version = "0.6", features = [
20 | "std",
21 | ]}
22 |
23 | # serde
24 | serde = { version = "1.0", features = ["derive"] }
25 |
26 | [target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
27 | wayland-backend = { version = "0.3", features = ["client_system"] }
28 | wayland-client = { version = "0.31" }
29 | wayland-protocols = { version = "0.32", features = [
30 | "client", "staging", "unstable",
31 | ] }
32 | wayland-protocols-plasma = { version = "0.3.1", features = [
33 | "client",
34 | ] }
35 | wayland-protocols-wlr = { version = "0.3.1", features = ["client"] }
36 | wayland-scanner = {version= "0.31" }
37 | wayland-csd-frame = { version= "0.3.0" }
38 |
39 | # Decorations
40 | sctk = { package = "smithay-client-toolkit", version = "0.19.0" }
41 | sctk-adwaita = { version = "0.10.1", default-features = false }
42 |
43 | # For keys
44 | xkbcommon = { version = "0.8.0", features = ["wayland"] }
45 | xkeysym = "0.2.0"
46 |
47 | [target.'cfg(target_os = "windows")'.dependencies.windows]
48 | version = "0.58.0"
49 | features = [
50 | "Win32_Devices_HumanInterfaceDevice",
51 | "Win32_Foundation",
52 | "Win32_Globalization",
53 | "Win32_Graphics_Dwm",
54 | "Win32_Graphics_Gdi",
55 | "Win32_Media",
56 | "Win32_System_Com_StructuredStorage",
57 | "Win32_System_Com",
58 | "Win32_System_LibraryLoader",
59 | "Win32_System_Ole",
60 | "Win32_System_SystemInformation",
61 | "Win32_System_SystemServices",
62 | "Win32_System_Threading",
63 | "Win32_System_WindowsProgramming",
64 | "Win32_UI_Accessibility",
65 | "Win32_UI_Controls",
66 | "Win32_UI_HiDpi",
67 | "Win32_UI_Input_Ime",
68 | "Win32_UI_Input_KeyboardAndMouse",
69 | "Win32_UI_Input_Pointer",
70 | "Win32_UI_Input_Touch",
71 | "Win32_UI_Shell",
72 | "Win32_UI_TextServices",
73 | "Win32_UI_WindowsAndMessaging",
74 | ]
--------------------------------------------------------------------------------
/crates/vent-window/README.md:
--------------------------------------------------------------------------------
1 | ### Vent-Window
2 |
3 | A Window creation & management Library
4 |
5 | ## Supported Platforms
6 |
7 | - Desktop
8 | - [Windows](#windows)
9 | - [macOS](#macos-planned)
10 | - [Unix/Wayland](#unix-wayland)
11 | - [Unix/X11 Info](#unix-x11)
12 | - Mobile
13 | - [Android](#android-planned)
14 | - [IOS](#ios-planned)
15 |
16 | # Desktop
17 |
18 | ## Windows
19 |
20 | | Features | Status |
21 | | ------------------- | ------ |
22 | | Window Creation | ✅️ |
23 | | Window Decorations | ✅️ |
24 | | Event Handling | ✅️ |
25 | | Full-Screen | ❌ |
26 | | Window Minimization | ✅️ |
27 | | Window Maximization | ✅️ |
28 | | Window Resizing | ✅️ |
29 | | Vulkan Rendering | ✅️ |
30 | | Keyboard Support | ✅️ |
31 | | Mouse Support | ✅️ |
32 | | GamePad Support | ❌ |
33 | | Touch Support | ❌ |
34 | | Touch Support | ❌ |
35 | | Cursor Icon | ❌ |
36 | | Cursor Own Image | ❌ |
37 | | Drag&Drop | ❌ |
38 |
39 | ## macOS (planned)
40 |
41 | | Features | Status |
42 | | ------------------- | ------ |
43 | | Window Creation | ❌ |
44 | | Window Decorations | ❌ |
45 | | Event Handling | ❌ |
46 | | Full-Screen | ❌ |
47 | | Window Minimization | ❌ |
48 | | Window Maximization | ❌ |
49 | | Window Resizing | ❌ |
50 | | Vulkan Rendering | ❌ |
51 | | Keyboard Support | ❌ |
52 | | Mouse Support | ❌ |
53 | | GamePad Support | ❌ |
54 | | Touch Support | ❌ |
55 | | Touch Support | ❌ |
56 | | Cursor Icon | ❌ |
57 | | Cursor Own Image | ❌ |
58 | | Drag&Drop | ❌ |
59 |
60 | ## Unix (Wayland)
61 |
62 | | Features | Status |
63 | | ------------------- | ------ |
64 | | Window Creation | ✅️ |
65 | | Window Decorations | ✅️ |
66 | | Event Handling | ✅️ |
67 | | Full-Screen | ✅️ |
68 | | Window Minimization | ✅️ |
69 | | Window Maximization | ✅️ |
70 | | Window Resizing | ✅️ |
71 | | Vulkan Rendering | ✅️ |
72 | | Keyboard Support | ✅️ |
73 | | Mouse Support | ✅️ |
74 | | GamePad Support | ❌ |
75 | | Touch Support | ❌ |
76 | | Touch Support | ❌ |
77 | | Cursor Icon | ❌ |
78 | | Cursor Own Image | ❌ |
79 | | Drag&Drop | ❌ |
80 |
81 | ## Unix (X11)
82 | X11 is not planned
83 |
84 | # Mobile
85 |
86 | ## Android (planned)
87 |
88 | | Features | Status |
89 | | ------------------- | ------ |
90 | | Window Creation | ❌ |
91 | | Window Decorations | ❌ |
92 | | Event Handling | ❌ |
93 | | Full-Screen | ❌ |
94 | | Window Minimization | ❌ |
95 | | Window Maximization | ❌ |
96 | | Window Resizing | ❌ |
97 | | Vulkan Rendering | ❌ |
98 | | Keyboard Support | ❌ |
99 | | Mouse Support | ❌ |
100 | | GamePad Support | ❌ |
101 | | Touch Support | ❌ |
102 | | Touch Support | ❌ |
103 | | Cursor Icon | ❌ |
104 | | Cursor Own Image | ❌ |
105 | | Drag&Drop | ❌ |
106 |
107 | ## IOS (planned)
108 |
109 | | Features | Status |
110 | | ------------------- | ------ |
111 | | Window Creation | ❌ |
112 | | Window Decorations | ❌ |
113 | | Event Handling | ❌ |
114 | | Full-Screen | ❌ |
115 | | Window Minimization | ❌ |
116 | | Window Maximization | ❌ |
117 | | Window Resizing | ❌ |
118 | | Vulkan Rendering | ❌ |
119 | | Keyboard Support | ❌ |
120 | | Mouse Support | ❌ |
121 | | GamePad Support | ❌ |
122 | | Touch Support | ❌ |
123 | | Touch Support | ❌ |
124 | | Cursor Icon | ❌ |
125 | | Cursor Own Image | ❌ |
126 | | Drag&Drop | ❌ |
127 |
128 |
129 | ## Contributing
130 |
131 | See [Contributing](../../CONTRIBUTING.md)
132 |
133 | ## License
134 |
135 | Vent-Window is licensed under the [Apache 2.0 License](../../LICENSE)
136 |
--------------------------------------------------------------------------------
/crates/vent-window/src/keyboard.rs:
--------------------------------------------------------------------------------
1 | #[derive(PartialEq, Clone, Debug)]
2 | pub enum Key {
3 | A,
4 | B,
5 | C,
6 | D,
7 | E,
8 | F,
9 | G,
10 | H,
11 | I,
12 | J,
13 | K,
14 | L,
15 | M,
16 | N,
17 | O,
18 | P,
19 | Q,
20 | R,
21 | S,
22 | T,
23 | U,
24 | V,
25 | W,
26 | X,
27 | Y,
28 | Z,
29 | Space,
30 | ShiftL,
31 | ShiftR,
32 | Leftarrow,
33 | Uparrow,
34 | Rightarrow,
35 | Downarrow,
36 | Unknown,
37 | }
38 |
39 | #[derive(PartialEq, Clone)]
40 | pub enum KeyState {
41 | Pressed,
42 | Released,
43 | }
44 |
--------------------------------------------------------------------------------
/crates/vent-window/src/lib.rs:
--------------------------------------------------------------------------------
1 | use std::num::NonZeroU32;
2 |
3 | use raw_window_handle::{DisplayHandle, HasDisplayHandle, HasWindowHandle};
4 | use serde::{Deserialize, Serialize};
5 | pub mod keyboard;
6 | pub mod mouse;
7 | pub mod platform;
8 |
9 | type EventHandler = dyn FnMut(WindowEvent);
10 |
11 | #[derive(PartialEq, Clone)]
12 | pub enum WindowEvent {
13 | Close,
14 | Key {
15 | key: keyboard::Key,
16 | state: keyboard::KeyState,
17 | },
18 | MouseButton {
19 | button: mouse::Button,
20 | state: mouse::ButtonState,
21 | },
22 | MouseMotion {
23 | x: f64,
24 | y: f64,
25 | },
26 | Resize {
27 | new_width: u32,
28 | new_height: u32,
29 | },
30 | Draw,
31 | }
32 |
33 | #[derive(Serialize, Deserialize, PartialEq, Clone)]
34 | pub enum WindowMode {
35 | Default,
36 | FullScreen,
37 | Maximized,
38 | Minimized,
39 | }
40 |
41 | #[derive(Serialize, Deserialize, Clone)]
42 | pub struct WindowAttribs {
43 | title: String,
44 | app_id: String,
45 | width: NonZeroU32,
46 | height: NonZeroU32,
47 | mode: WindowMode,
48 | min_size: Option<(u32, u32)>,
49 | max_size: Option<(u32, u32)>,
50 | resizable: bool,
51 | closeable: bool,
52 | }
53 |
54 | impl WindowAttribs {
55 | pub fn with_title(mut self, title: String) -> Self {
56 | self.title = title;
57 | self
58 | }
59 | pub fn set_mode(mut self, mode: WindowMode) -> Self {
60 | self.mode = mode;
61 | self
62 | }
63 | }
64 |
65 | impl Default for WindowAttribs {
66 | fn default() -> Self {
67 | Self {
68 | title: "Vent Engine".to_string(),
69 | app_id: "com.ventengine.VentEngine".to_string(),
70 | width: unsafe { NonZeroU32::new_unchecked(800) },
71 | height: unsafe { NonZeroU32::new_unchecked(600) },
72 | mode: WindowMode::Default,
73 | max_size: None,
74 | min_size: None,
75 | resizable: true,
76 | closeable: true,
77 | }
78 | }
79 | }
80 |
81 | /**
82 | * Cross Platform window Wrapper
83 | */
84 | pub struct Window {
85 | window: platform::PlatformWindow,
86 | }
87 |
88 | impl Window {
89 | pub fn new(inital_attribs: WindowAttribs) -> Self {
90 | Self {
91 | window: platform::PlatformWindow::create_window(inital_attribs),
92 | }
93 | }
94 |
95 | pub fn poll(mut self, event_handler: F)
96 | where
97 | F: FnMut(WindowEvent) + 'static,
98 | {
99 | self.window.poll(event_handler);
100 | }
101 |
102 | pub fn set_cursor_visible(&mut self, visible: bool) {
103 | self.window.set_cursor_visible(visible)
104 | }
105 |
106 | pub fn close(&mut self) {
107 | self.window.close()
108 | }
109 |
110 | pub fn width(&self) -> u32 {
111 | self.window.width()
112 | }
113 |
114 | pub fn height(&self) -> u32 {
115 | self.window.height()
116 | }
117 |
118 | pub fn size(&self) -> (u32, u32) {
119 | (self.window.width(), self.window.height())
120 | }
121 | }
122 |
123 | impl HasDisplayHandle for Window {
124 | fn display_handle(&self) -> Result, raw_window_handle::HandleError> {
125 | let raw = self.window.raw_display_handle();
126 | Ok(unsafe { raw_window_handle::DisplayHandle::borrow_raw(raw) })
127 | }
128 | }
129 |
130 | impl HasWindowHandle for Window {
131 | fn window_handle(
132 | &self,
133 | ) -> Result, raw_window_handle::HandleError> {
134 | let raw = self.window.raw_window_handle();
135 | Ok(unsafe { raw_window_handle::WindowHandle::borrow_raw(raw) })
136 | }
137 | }
138 |
--------------------------------------------------------------------------------
/crates/vent-window/src/mouse.rs:
--------------------------------------------------------------------------------
1 | #[derive(PartialEq, Clone)]
2 | pub enum Button {
3 | LEFT,
4 | RIGHT,
5 | MIDDLE,
6 | SIDE,
7 | EXTRA,
8 | FORWARD,
9 | BACK,
10 | }
11 |
12 | #[derive(PartialEq, Clone)]
13 | pub enum ButtonState {
14 | Pressed,
15 | Released,
16 | }
17 |
--------------------------------------------------------------------------------
/crates/vent-window/src/platform/mod.rs:
--------------------------------------------------------------------------------
1 | #[cfg(unix)]
2 | #[path = "wayland/mod.rs"]
3 | #[allow(clippy::module_inception)]
4 | pub mod platform;
5 |
6 | #[cfg(target_os = "windows")]
7 | #[path = "windows/mod.rs"]
8 | #[allow(clippy::module_inception)]
9 | pub mod platform;
10 |
11 | pub use self::platform::*;
12 |
--------------------------------------------------------------------------------
/docs/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ventengine/Vent-Engine/89d706c80c2f1ae3c2b441cbec49c49b388471c0/docs/logo.png
--------------------------------------------------------------------------------
/test/runtime-sandbox/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "runtime-sandbox"
3 | version = "0.1.0"
4 | edition = "2021"
5 |
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 |
8 | [dependencies]
9 | vent-runtime = { path = "../../crates/vent-runtime"}
10 |
--------------------------------------------------------------------------------
/test/runtime-sandbox/project.vent:
--------------------------------------------------------------------------------
1 | {"name":"runtime-sandbox","version":"0.1.0"}
--------------------------------------------------------------------------------
/test/runtime-sandbox/src/main.rs:
--------------------------------------------------------------------------------
1 | use vent_runtime::VentApplication;
2 |
3 | fn main() {
4 | VentApplication::default();
5 | }
6 |
--------------------------------------------------------------------------------