hodasemi/ui
1
0
Fork 0
Code Issues 1 Pull requests 1 Projects Releases Wiki Activity Actions

Implement first draft for multisampled text

Browse source
This commit is contained in:
hodasemi 2023-01-21 22:09:07 +01:00
parent f5b0f76173
commit f4a8e48d67
1 changed files with 86 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

104
src/guihandler/guihandler.rs
View file

@ -162,6 +162,8 @@ pub struct GuiHandler {
current_hoverable: RwLock<Option<Arc<Hoverable>>>,
current_clickable: RwLock<Option<Arc<Clickable>>>,
current_selectable: RwLock<Option<Arc<Selectable>>>,
text_sample_count: VkSampleCountFlags,
}
impl GuiHandler {
@ -186,11 +188,10 @@ impl GuiHandler {
}
};
// let render_pass =
// Self::create_render_pass(device, context.format(), context.image_layout())?;
// let framebuffers = Self::create_framebuffers(device, &context.images(), &render_pass)?;
let text_sample_count = device.max_supported_sample_count(VK_SAMPLE_COUNT_4_BIT);
let render_targets = Self::create_render_targets(device, &context.images())?;
let render_targets =
Self::create_render_targets(device, &context.images(), queue, text_sample_count)?;
let (text_objs, color_layout) = Self::init_text_objects(device, &render_targets)?;
let rect_objs = Self::init_rectangle_objects(device, &render_targets)?;
@ -306,6 +307,8 @@ impl GuiHandler {
current_hoverable: RwLock::new(None),
current_selectable: RwLock::new(None),
current_writeable: RwLock::new(None),
text_sample_count,
}))
}
@ -782,6 +785,7 @@ impl GuiHandler {
single_color_objects: &GuiSeparator,
rectangle_objects: &GuiSeparator,
text_objects: &GuiSeparator,
index: usize,
) -> Result<()> {
if !command_buffer_state.valid.load(SeqCst) {
let gui_command_buffer = &command_buffer_state.command_buffer;
@ -816,6 +820,8 @@ impl GuiHandler {
let layers = self.layers.lock().unwrap();
for (_, elements) in layers.iter() {
render_target.begin(&mut buffer_recorder, VK_SUBPASS_CONTENTS_INLINE, index);
if !elements.is_colorables_empty() {
buffer_recorder.bind_pipeline(&single_color_objects._pipeline)?;
@ -860,6 +866,8 @@ impl GuiHandler {
}
}
render_target.next_subpass(&mut buffer_recorder, VK_SUBPASS_CONTENTS_INLINE);
if !elements.is_textables_empty() {
buffer_recorder.bind_pipeline(&text_objects._pipeline)?;
@ -885,6 +893,8 @@ impl GuiHandler {
}
}
}
render_target.end(&mut buffer_recorder);
}
command_buffer_state.valid.store(true, SeqCst);
@ -1157,14 +1167,32 @@ impl GuiHandler {
fn create_render_targets(
device: &Arc<Device>,
target_images: &TargetMode<Vec<Arc<Image>>>,
queue: &Arc<Mutex<Queue>>,
sample_count: VkSampleCountFlags,
) -> Result<TargetMode<RwLock<RenderTarget>>> {
Ok(match target_images {
TargetMode::Mono(images) => TargetMode::Mono(RwLock::new(Self::create_render_target(
device, images, None,
device,
images,
None,
queue,
sample_count,
)?)),
TargetMode::Stereo(left_images, right_images) => TargetMode::Stereo(
RwLock::new(Self::create_render_target(device, left_images, None)?),
RwLock::new(Self::create_render_target(device, right_images, None)?),
RwLock::new(Self::create_render_target(
device,
left_images,
None,
queue,
sample_count,
)?),
RwLock::new(Self::create_render_target(
device,
right_images,
None,
queue,
sample_count,
)?),
),
})
}
@ -1173,11 +1201,30 @@ impl GuiHandler {
device: &Arc<Device>,
target_images: &Vec<Arc<Image>>,
old_render_target: Option<&RenderTarget>,
queue: &Arc<Mutex<Queue>>,
sample_count: VkSampleCountFlags,
) -> Result<RenderTarget> {
let mut builder = RenderTarget::builder().add_sub_pass(
let mut builder = RenderTarget::builder()
.add_sub_pass(
SubPass::builder(target_images[0].width(), target_images[0].height())
.set_prepared_targets(target_images, 0, [0.0, 0.0, 0.0, 0.0], false)
.build(device)?,
)
.add_sub_pass(
SubPass::builder(target_images[0].width(), target_images[0].height())
.add_target_info(CustomTarget {
usage: VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT.into(),
format: target_images[0].vk_format(),
clear_on_load: false,
store_on_save: true,
attach_sampler: false,
use_as_input: false,
clear_value: ClearValue::Color([0.0, 0.0, 0.0, 0.0]),
})
.set_sample_count(sample_count)
.add_resolve_targets(target_images.clone())
.use_queue(queue.clone())
.build(device)?,
);
if let Some(render_target) = old_render_target {
@ -1284,6 +1331,7 @@ impl GuiHandler {
&pipeline_layout,
vertex_shader.clone(),
fragment_shader.clone(),
1,
)?,
})
})?,
@ -1334,6 +1382,7 @@ impl GuiHandler {
&pipeline_layout,
vertex_shader.clone(),
fragment_shader.clone(),
0,
)?,
})
})
@ -1382,6 +1431,7 @@ impl GuiHandler {
&pipeline_layout,
vertex_shader.clone(),
fragment_shader.clone(),
0,
)?,
})
})
@ -1395,6 +1445,7 @@ impl GuiHandler {
pipeline_layout: &Arc<PipelineLayout>,
vertex_shader: Arc<ShaderModule>,
fragment_shader: Arc<ShaderModule>,
sub_pass: u32,
) -> Result<Arc<Pipeline>> {
Pipeline::new_graphics()
.set_vertex_shader(vertex_shader, binding_description, attribute_description)
@ -1403,7 +1454,7 @@ impl GuiHandler {
.default_multisample(VK_SAMPLE_COUNT_1_BIT)
.default_color_blend(vec![VkPipelineColorBlendAttachmentState::default()])
.default_rasterization(VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE)
.build(device.clone(), pipeline_layout, render_pass, 0)
.build(device.clone(), pipeline_layout, render_pass, sub_pass)
}
#[inline]
@ -1425,18 +1476,11 @@ impl GuiHandler {
single_color_objects,
rectangle_objects,
text_objects,
index,
)?;
render_target.begin(
buffer_recorder,
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
index,
);
buffer_recorder.execute_commands(&[&command_buffer_state.command_buffer]);
render_target.end(buffer_recorder);
Ok(())
}
}
@ -1542,7 +1586,13 @@ impl GuiHandler {
(TargetMode::Mono(images), TargetMode::Mono(render_target)) => {
let mut rt_lock = render_target.write().unwrap();
*rt_lock = Self::create_render_target(&self.device, &images, Some(&*rt_lock))?;
*rt_lock = Self::create_render_target(
&self.device,
&images,
Some(&*rt_lock),
&self.queue,
self.text_sample_count,
)?;
}
(
TargetMode::Stereo(left_images, right_images),
@ -1550,13 +1600,23 @@ impl GuiHandler {
) => {
let mut left_rt_lock = left_render_target.write().unwrap();
*left_rt_lock =
Self::create_render_target(&self.device, &left_images, Some(&*left_rt_lock))?;
*left_rt_lock = Self::create_render_target(
&self.device,
&left_images,
Some(&*left_rt_lock),
&self.queue,
self.text_sample_count,
)?;
let mut right_rt_lock = right_render_target.write().unwrap();
*right_rt_lock =
Self::create_render_target(&self.device, &right_images, Some(&*right_rt_lock))?;
*right_rt_lock = Self::create_render_target(
&self.device,
&right_images,
Some(&*right_rt_lock),
&self.queue,
self.text_sample_count,
)?;
}
_ => unreachable!("unsupported case!"),