#include <vulkan_display.hpp>

Collaboration diagram for vulkan_display::VulkanDisplay:

Classes
struct	RenderedImage

Public Member Functions
	VulkanDisplay ()=default

	VulkanDisplay (const VulkanDisplay &other)=delete

	VulkanDisplay (VulkanDisplay &&other)=delete

	~VulkanDisplay () noexcept

TransferImage	acquire_image (ImageDescription description)

void	copy_and_queue_image (unsigned char *frame, ImageDescription description)

void	destroy ()

void	discard_image (TransferImage image)

bool	display_queued_image ()

uint32_t	get_vulkan_version () const

void	init (VulkanInstance &&instance, vk::SurfaceKHR surface, uint32_t transfer_image_count, WindowChangedCallback &window, uint32_t gpu_index=no_gpu_selected, std::string path_to_shaders="./shaders", bool vsync=true, bool tearing_permitted=false)

bool	is_image_description_supported (ImageDescription description)

bool	is_yCbCr_supported () const

VulkanDisplay &	operator= (const VulkanDisplay &other)=delete

VulkanDisplay &	operator= (VulkanDisplay &&other)=delete

bool	queue_image (TransferImage img, bool discardable)

void	window_parameters_changed ()

void	window_parameters_changed (WindowParameters new_parameters)
	Hint to vulkan display that some window parameters spicified in struct WindowParameters changed. Thread-safe.

Private Types
using	TransferImageImpl = detail::TransferImageImpl

Private Member Functions
TransferImageImpl &	acquire_transfer_image ()

void	bind_transfer_image (TransferImageImpl &image, detail::PerFrameResources &resources)

void	destroy_format_dependent_resources ()

void	reconfigure (const TransferImageImpl &transfer_image)

void	record_graphics_commands (detail::PerFrameResources &commands, TransferImageImpl &transfer_image, uint32_t swapchain_image_id)

Private Attributes
std::vector< TransferImageImpl * >	available_images
	local to provider thread

detail::ConcurrentQueue< TransferImageImpl * >	available_img_queue {}
	available_img_queue - producer is the render thread, consumer is the provided thread

vk::CommandPool	command_pool

detail::VulkanContext	context

detail::ConversionPipeline	conversion_pipeline

ImageDescription	current_image_description

vk::DescriptorPool	descriptor_pool

bool	destroyed = false

vk::Device	device

std::mutex	device_mutex {}

detail::ConcurrentQueue< TransferImageImpl *, detail::filled_img_max_count >	filled_img_queue {}
	filled_img_queue - producer is the provider thread, consumer is the render thread

bool	format_conversion_enabled = false

std::array< detail::PerFrameResources, 3 >	frame_resources

std::vector< detail::PerFrameResources * >	free_frame_resources

std::string	path_to_shaders

detail::RenderPipeline	render_pipeline

std::queue< RenderedImage >	rendered_images

std::deque< TransferImageImpl >	transfer_images {}

WindowChangedCallback *	window = nullptr

Detailed Description

Definition at line 84 of file vulkan_display.hpp.

Member Typedef Documentation

◆ TransferImageImpl

using vulkan_display::VulkanDisplay::TransferImageImpl = detail::TransferImageImpl

private

Definition at line 105 of file vulkan_display.hpp.

Constructor & Destructor Documentation

◆ VulkanDisplay() [1/3]

vulkan_display::VulkanDisplay::VulkanDisplay ( )

default

TERMINOLOGY: render thread - thread which renders queued images on the screen provider thread - thread which calls getf and putf and fills image queue with newly filled images

◆ VulkanDisplay() [2/3]

vulkan_display::VulkanDisplay::VulkanDisplay ( const VulkanDisplay & other )

delete

◆ VulkanDisplay() [3/3]

vulkan_display::VulkanDisplay::VulkanDisplay ( VulkanDisplay && other )

delete

◆ ~VulkanDisplay()

vulkan_display::VulkanDisplay::~VulkanDisplay ( )

inlinenoexcept

Definition at line 144 of file vulkan_display.hpp.

                                  {
                if (!destroyed) {
                        try {
                                destroy();
                        } catch (vk::SystemError &e) {
                                std::string err = std::string("~VulkanDisplay vk::SystemError: ") + e.what() + "\n";
                                vulkan_display_detail::vulkan_log_msg(LogLevel::error, err);
                        }
                }
        }

References destroy(), destroyed, vulkan_display::error, and vulkan_display_detail::vulkan_log_msg.

Here is the call graph for this function:

Member Function Documentation

◆ acquire_image()

TransferImage vulkan_display::VulkanDisplay::acquire_image ( ImageDescription description )

Thread-safe to call from provider thread.

Definition at line 418 of file vulkan_display.cpp.

                                                                       {
        assert(description.size.width * description.size.height != 0);
        TransferImageImpl& transfer_image = acquire_transfer_image();
        assert(transfer_image.get_id() != TransferImageImpl::NO_ID);
 
        if (transfer_image.get_image_description() != description) {
                std::scoped_lock device_lock(device_mutex);
                transfer_image.recreate(context, description);
        }
        
        return TransferImage{ transfer_image };
}

References acquire_transfer_image(), context, description, device_mutex, vulkan_display_detail::TransferImageImpl::get_id(), vulkan_display_detail::TransferImageImpl::get_image_description(), vulkan_display_detail::TransferImageImpl::NO_ID, and vulkan_display_detail::TransferImageImpl::recreate().

Referenced by copy_and_queue_image().

Here is the call graph for this function:

◆ acquire_transfer_image()

TransferImageImpl & vulkan_display::VulkanDisplay::acquire_transfer_image ( )

nodiscardprivate

Definition at line 400 of file vulkan_display.cpp.

                                                         {
        TransferImageImpl* result = nullptr;
        if (!available_images.empty()){
                result = available_images.back();
                available_images.pop_back();
                assert(result != nullptr);
                return *result;
        }
 
        result = available_img_queue.try_pop();
        if (result != nullptr){
                return *result;
        }
        uint32_t id = transfer_images.size();
        transfer_images.emplace_back(device, id);
        return transfer_images.back();
}

References available_images, available_img_queue, device, and transfer_images.

Referenced by acquire_image().

◆ bind_transfer_image()

void vulkan_display::VulkanDisplay::bind_transfer_image	(	TransferImageImpl &	image,
		detail::PerFrameResources &	resources )

private

Definition at line 320 of file vulkan_display.cpp.

                                                                                                       {
        auto image_layout = vk::ImageLayout::eShaderReadOnlyOptimal;
        auto descriptor_type = vk::DescriptorType::eCombinedImageSampler;
 
        auto yCbCr_conversion = format_conversion_enabled ?
                conversion_pipeline.get_yCbCr_conversion() : render_pipeline.get_yCbCr_conversion();
        auto sampler = format_conversion_enabled ?
                conversion_pipeline.get_sampler() : render_pipeline.get_sampler();
        auto descriptor_set = format_conversion_enabled ?
                resources.conversion_source_descriptor_set : resources.render_descriptor_set;
 
 
        auto view = transfer_image.get_image_view(device, yCbCr_conversion);
 
        vk::DescriptorImageInfo description_image_info;
        description_image_info
                .setImageLayout(image_layout)
                .setSampler(sampler)
                .setImageView(view);
 
        vk::WriteDescriptorSet descriptor_writes{};
        descriptor_writes
                .setDstBinding(0)
                .setDescriptorType(descriptor_type)
                .setPImageInfo(&description_image_info)
                .setDescriptorCount(1)
                .setDstSet(descriptor_set);
 
        device.updateDescriptorSets(descriptor_writes, nullptr);
}

References conversion_pipeline, vulkan_display_detail::PerFrameResources::conversion_source_descriptor_set, device, format_conversion_enabled, vulkan_display_detail::TransferImageImpl::get_image_view(), vulkan_display_detail::ConversionPipeline::get_sampler(), vulkan_display_detail::RenderPipeline::get_sampler(), vulkan_display_detail::ConversionPipeline::get_yCbCr_conversion(), vulkan_display_detail::RenderPipeline::get_yCbCr_conversion(), vulkan_display_detail::PerFrameResources::render_descriptor_set, and render_pipeline.

Referenced by display_queued_image().

Here is the call graph for this function:

◆ copy_and_queue_image()

void vulkan_display::VulkanDisplay::copy_and_queue_image	(	unsigned char *	frame,
		ImageDescription	description )

Thread-safe to call from provider thread.

Definition at line 431 of file vulkan_display.cpp.

                                                                                           {
        TransferImage image = acquire_image(description);
        memcpy(image.get_memory_ptr(), frame, image.get_size().height * image.get_row_pitch());
        queue_image(image, false);
}

References acquire_image(), description, frame, vulkan_display::TransferImage::get_memory_ptr(), vulkan_display::TransferImage::get_row_pitch(), vulkan_display::TransferImage::get_size(), and queue_image().

Here is the call graph for this function:

◆ destroy()

void vulkan_display::VulkanDisplay::destroy ( )

Definition at line 278 of file vulkan_display.cpp.

                            {
        if (!destroyed) {
                destroyed = true;
                if (device) {
                        device.waitIdle();
                        device.destroy(descriptor_pool);
 
                        for (auto& image : transfer_images) {
                                image.destroy(device);
                        }
                        device.destroy(command_pool);
                        for (auto& resources : frame_resources) {
                                device.destroy(resources.image_acquired_semaphore);
                                device.destroy(resources.image_rendered_semaphore);
                        }
                        destroy_format_dependent_resources();
                        render_pipeline.destroy(device);
                        conversion_pipeline.destroy(device);
                }
                context.destroy();
        }
}

References command_pool, context, conversion_pipeline, descriptor_pool, vulkan_display_detail::ConversionPipeline::destroy(), vulkan_display_detail::RenderPipeline::destroy(), vulkan_display_detail::VulkanContext::destroy(), destroy_format_dependent_resources(), destroyed, device, frame_resources, render_pipeline, and transfer_images.

Referenced by ~VulkanDisplay().

Here is the call graph for this function:

◆ destroy_format_dependent_resources()

void vulkan_display::VulkanDisplay::destroy_format_dependent_resources ( )

private

Definition at line 270 of file vulkan_display.cpp.

                                                      {
        conversion_pipeline.destroy(device);
 
        for(auto& resorces: frame_resources){
                resorces.converted_image.destroy(device);
        }
}

References conversion_pipeline, vulkan_display_detail::ConversionPipeline::destroy(), device, and frame_resources.

Referenced by destroy(), and reconfigure().

Here is the call graph for this function:

◆ discard_image()

void vulkan_display::VulkanDisplay::discard_image ( TransferImage image )

inline

Thread-safe to call from provider thread.

Definition at line 177 of file vulkan_display.hpp.

                                                {
                auto* ptr = image.get_transfer_image();
                assert(ptr);
                available_images.push_back(ptr);
        }

References available_images, and vulkan_display::TransferImage::get_transfer_image().

Here is the call graph for this function:

◆ display_queued_image()

bool vulkan_display::VulkanDisplay::display_queued_image ( )

Thread-safe to call from render thread.

Returns: true if image was displayed

Definition at line 508 of file vulkan_display.cpp.

                                         {
        auto window_parameters = window->get_window_parameters();
        if (window_parameters.is_minimized()) {
                discard_filled_image(filled_img_queue, available_img_queue);
                return false;
        }
 
        {
                std::scoped_lock lock{device_mutex};
                while (!rendered_images.empty()){
                        auto* first_image = rendered_images.front().image;
                        auto result = device.waitForFences(first_image->is_available_fence, VK_TRUE, 0);
                        if (result == vk::Result::eSuccess){
                                device.resetFences(first_image->is_available_fence);
                                free_frame_resources.push_back(rendered_images.front().gpu_commands);
                                rendered_images.pop();
                                assert(first_image != nullptr);
                                available_img_queue.wait_push(first_image);
                        }
                        else if (result == vk::Result::eTimeout){
                                break;
                        }
                        else {
                                throw VulkanError{"Waiting for fence failed."};
                        }
                }
        }
 
        if(free_frame_resources.empty()){
                return false;
        }
        auto& resources = *free_frame_resources.back();
        free_frame_resources.pop_back();
 
        bool frame_resources_used_by_gpu = false;
        AtScopeExit frame_resources_cleaner{[&](){
                if(!frame_resources_used_by_gpu){
                        free_frame_resources.push_back(&resources);
                }
        }};
 
        // 24FPS (lowest expected framerate) has a period of approximately 42ms
        TransferImageImpl* transfer_image_ptr = filled_img_queue.timed_pop(84ms);
        if (transfer_image_ptr == nullptr) {
                return false;
        }
 
        TransferImageImpl& transfer_image = *transfer_image_ptr;
        transfer_image.preprocess();
 
        std::unique_lock lock(device_mutex);
        if (transfer_image.get_image_description() != current_image_description) {
                reconfigure(transfer_image);
        }
 
        uint32_t swapchain_image_id = context.acquire_next_swapchain_image(resources.image_acquired_semaphore);
        int swapchain_recreation_attempt = 0;
        while (swapchain_image_id == swapchain_image_out_of_date || swapchain_image_id == swapchain_image_timeout) 
        {
                swapchain_recreation_attempt++;
                if (swapchain_recreation_attempt > 3) {
                        throw VulkanError{"Cannot acquire swapchain image"};
                }
                
                auto window_parameters = window->get_window_parameters();
                if (window_parameters.is_minimized()) {
                        discard_filled_image(filled_img_queue, available_img_queue);
                        return false;
                }
                context.recreate_swapchain(window_parameters, render_pipeline.get_render_pass());
                auto render_area_size = context.get_render_area_size();
                render_pipeline.update_render_area(render_area_size, current_image_description.size);
                
                swapchain_image_id = context.acquire_next_swapchain_image(resources.image_acquired_semaphore);
        }
 
        bind_transfer_image(transfer_image, resources);
        lock.unlock();
 
        record_graphics_commands(resources, transfer_image, swapchain_image_id);
        std::vector<vk::PipelineStageFlags> wait_masks{ vk::PipelineStageFlagBits::eColorAttachmentOutput };
        vk::SubmitInfo submit_info{};
        submit_info
                .setCommandBufferCount(1)
                .setPCommandBuffers(&resources.command_buffer)
                .setPWaitDstStageMask(wait_masks.data())
                .setWaitSemaphoreCount(1)
                .setPWaitSemaphores(&resources.image_acquired_semaphore)
                .setSignalSemaphoreCount(1)
                .setPSignalSemaphores(&resources.image_rendered_semaphore);
 
        context.get_queue().submit(submit_info, transfer_image.is_available_fence);
 
        frame_resources_used_by_gpu = true;
        rendered_images.emplace(RenderedImage{&transfer_image, &resources});
 
        auto swapchain = context.get_swapchain();
        vk::PresentInfoKHR present_info{};
        present_info
                .setPImageIndices(&swapchain_image_id)
                .setSwapchainCount(1)
                .setPSwapchains(&swapchain)
                .setWaitSemaphoreCount(1)
                .setPWaitSemaphores(&resources.image_rendered_semaphore);
 
        auto present_result = context.get_queue().presentKHR(&present_info);
 
        switch (present_result) {
                case vk::Result::eSuccess:
                        break;
                // skip recoverable errors, othervise return/throw error 
                case vk::Result::eErrorOutOfDateKHR: 
                case vk::Result::eSuboptimalKHR: 
                        break;
                default: 
                        throw VulkanError{"Error presenting image:"s + vk::to_string(present_result)};
        }
 
        return true;
}

Here is the call graph for this function:

◆ get_vulkan_version()

uint32_t vulkan_display::VulkanDisplay::get_vulkan_version ( ) const

inline

Thread-safe

Definition at line 192 of file vulkan_display.hpp.

192{ return context.get_vulkan_version(); }

vulkan_display_detail::VulkanContext::get_vulkan_version

uint32_t get_vulkan_version() const

Definition vulkan_context.hpp:159

References context, and vulkan_display_detail::VulkanContext::get_vulkan_version().

Here is the call graph for this function:

◆ init()

void vulkan_display::VulkanDisplay::init	(	VulkanInstance &&	instance,
		vk::SurfaceKHR	surface,
		uint32_t	transfer_image_count,
		WindowChangedCallback &	window,
		uint32_t	gpu_index = no_gpu_selected,
		std::string	path_to_shaders = "./shaders",
		bool	vsync = true,
		bool	tearing_permitted = false )

Definition at line 232 of file vulkan_display.cpp.

                                                                                                                       {
        assert(surface);
        this->window = &window;
        this->path_to_shaders = std::move(shaders_path);
 
        auto window_parameters = window.get_window_parameters();
 
        context.init(std::move(instance), surface, window_parameters, gpu_index, get_present_mode(vsync, tearing_permitted));
        device = context.get_device();
        
        command_pool = create_command_pool(device, context.get_queue_family_index());
        descriptor_pool = create_descriptor_pool(device, frame_resources.size());
 
        render_pipeline.create(context, path_to_shaders);
 
        context.create_framebuffers(render_pipeline.get_render_pass());
 
        available_images.reserve(initial_image_count);
        for (uint32_t i = 0; i < initial_image_count; i++) {
                transfer_images.emplace_back(device, i);
                available_images.push_back(&transfer_images.back());
        }
 
        auto command_buffers = create_command_buffers(device, command_pool, frame_resources.size());
        for (size_t i = 0; i < frame_resources.size(); i++){
                auto& resources = frame_resources[i];
                resources.image_acquired_semaphore = create_semaphore(device);
                resources.image_rendered_semaphore = create_semaphore(device);
                resources.command_buffer = command_buffers[i];
        }
 
        free_frame_resources.reserve(frame_resources.size());
        for(auto& resources: frame_resources){
                free_frame_resources.emplace_back(&resources);
        }
}

References available_images, command_pool, context, vulkan_display_detail::RenderPipeline::create(), vulkan_display_detail::VulkanContext::create_framebuffers(), descriptor_pool, device, frame_resources, free_frame_resources, vulkan_display_detail::VulkanContext::get_device(), vulkan_display_detail::VulkanContext::get_queue_family_index(), vulkan_display_detail::RenderPipeline::get_render_pass(), vulkan_display::WindowChangedCallback::get_window_parameters(), vulkan_display_detail::VulkanContext::init(), instance, path_to_shaders, render_pipeline, transfer_images, and window.

Here is the call graph for this function:

◆ is_image_description_supported()

bool vulkan_display::VulkanDisplay::is_image_description_supported ( ImageDescription description )

Thread-safe

Definition at line 301 of file vulkan_display.cpp.

                                                                               {
        std::scoped_lock lock(device_mutex);
 
        auto& format_info = description.format_info();
        if(!is_format_supported(context.get_gpu(), context.is_yCbCr_supported(), get_buffer_size(description),
                format_info.buffer_format, vk::ImageTiling::eLinear, vk::ImageUsageFlagBits::eSampled))
        {
                return false;;
        }
 
        if (format_info.conversion_image_format == vk::Format::eUndefined){
                return true;
        }
 
        return is_format_supported(context.get_gpu(), context.is_yCbCr_supported(), description.size,
                format_info.conversion_image_format, vk::ImageTiling::eOptimal,
                vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eStorage);
}

References vulkan_display_detail::FormatInfo::buffer_format, context, vulkan_display_detail::FormatInfo::conversion_image_format, description, device_mutex, vulkan_display_detail::format_info(), vulkan_display_detail::get_buffer_size(), vulkan_display_detail::VulkanContext::get_gpu(), is_format_supported(), and vulkan_display_detail::VulkanContext::is_yCbCr_supported().

Here is the call graph for this function:

◆ is_yCbCr_supported()

bool vulkan_display::VulkanDisplay::is_yCbCr_supported ( ) const

inline

Thread-safe

Definition at line 195 of file vulkan_display.hpp.

195{ return context.is_yCbCr_supported(); }

References context, and vulkan_display_detail::VulkanContext::is_yCbCr_supported().

Here is the call graph for this function:

◆ operator=() [1/2]

VulkanDisplay & vulkan_display::VulkanDisplay::operator= ( const VulkanDisplay & other )

delete

◆ operator=() [2/2]

VulkanDisplay & vulkan_display::VulkanDisplay::operator= ( VulkanDisplay && other )

delete

◆ queue_image()

bool vulkan_display::VulkanDisplay::queue_image	(	TransferImage	img,
		bool	discardable )

Thread-safe to call from provider thread.

Returns: true if image was discarded

Definition at line 437 of file vulkan_display.cpp.

                                                                     {
        assert(image.get_transfer_image() != nullptr);
        if(!discardable){
                filled_img_queue.wait_push(image.get_transfer_image());
                return false;
        }
        
        auto removed = filled_img_queue.force_push(image.get_transfer_image());
        if (removed != nullptr){
                available_images.push_back(removed);
                return true;
        }
        return false;
}

References available_images, filled_img_queue, and vulkan_display::TransferImage::get_transfer_image().

Referenced by copy_and_queue_image().

Here is the call graph for this function:

◆ reconfigure()

void vulkan_display::VulkanDisplay::reconfigure ( const TransferImageImpl & transfer_image )

private

Definition at line 452 of file vulkan_display.cpp.

                                                                      {
        auto image_description = transfer_image.get_image_description();
        auto& image_format_info = image_description.format_info();
 
        if (image_description != current_image_description) {
                vulkan_log_msg(LogLevel::info, "Recreating render_pipeline");
                context.get_queue().waitIdle();
                device.resetDescriptorPool(descriptor_pool);
 
                destroy_format_dependent_resources();
 
                format_conversion_enabled = !image_format_info.conversion_shader.empty();
 
                render_pipeline.reconfigure(device, format_conversion_enabled ?
                        image_format_info.conversion_image_format : image_format_info.buffer_format);
 
                auto descriptor_sets = allocate_description_sets(device, descriptor_pool, 
                        render_pipeline.get_image_desc_set_layout(), frame_resources.size());
                for(size_t i = 0; i < frame_resources.size(); i++){
                        frame_resources[i].render_descriptor_set = descriptor_sets[i];
                }
 
                if(format_conversion_enabled){
                        auto shader_path = path_to_shaders + "/" + image_format_info.conversion_shader + ".comp.spv";
                        conversion_pipeline.create(device, shader_path, image_format_info.buffer_format);
                        vk::Extent2D image_size = transfer_image.get_image_description().size;
                        for(size_t i = 0; i < frame_resources.size(); i++){
                                frame_resources[i].converted_image.init(
                                        context,
                                        image_size,
                                        image_format_info.conversion_image_format,
                                        vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eSampled,
                                        vk::AccessFlagBits::eShaderWrite,
                                        InitialImageData::undefined, MemoryLocation::device_local);
                        }
                        auto conversion_source_descriptor_sets = allocate_description_sets(device, descriptor_pool,
                                conversion_pipeline.get_source_image_desc_set_layout(), frame_resources.size());
                        auto conversion_destination_descriptor_sets = allocate_description_sets(device, descriptor_pool,
                                conversion_pipeline.get_destination_image_desc_set_layout(), frame_resources.size());
                        for(size_t i = 0; i < frame_resources.size(); i++){
                                assert(conversion_source_descriptor_sets.size() == frame_resources.size());
                                assert(conversion_destination_descriptor_sets.size() == frame_resources.size());
                                auto& resources = frame_resources[i];
                                resources.conversion_source_descriptor_set = conversion_source_descriptor_sets[i];
                                resources.conversion_destination_descriptor_set = conversion_destination_descriptor_sets[i];
                        }
                        
                        bind_conversion_images(device, conversion_pipeline.get_sampler(), frame_resources);
                }
        }
 
        current_image_description = transfer_image.get_image_description();
        auto render_area_size = context.get_render_area_size();
        render_pipeline.update_render_area( render_area_size, current_image_description.size);
}

Referenced by display_queued_image().

Here is the call graph for this function:

◆ record_graphics_commands()

void vulkan_display::VulkanDisplay::record_graphics_commands	(	detail::PerFrameResources &	commands,
		TransferImageImpl &	transfer_image,
		uint32_t	swapchain_image_id )

private

Definition at line 351 of file vulkan_display.cpp.

{
        vk::CommandBuffer cmd_buffer = frame_resources.command_buffer;
        cmd_buffer.reset(vk::CommandBufferResetFlags{});
 
        vk::CommandBufferBeginInfo begin_info{};
        begin_info.setFlags(vk::CommandBufferUsageFlagBits::eOneTimeSubmit);
        cmd_buffer.begin(begin_info);
 
        if(format_conversion_enabled){
                if(format_conversion_enabled){
                        auto conversion_image_memory_barrier = frame_resources.converted_image.create_memory_barrier(
                                vk::ImageLayout::eGeneral, vk::AccessFlagBits::eShaderWrite);
                        cmd_buffer.pipelineBarrier(vk::PipelineStageFlagBits::eFragmentShader, vk::PipelineStageFlagBits::eComputeShader,
                                vk::DependencyFlagBits::eByRegion, nullptr, nullptr, conversion_image_memory_barrier);
                }
 
                auto transfer_image_memory_barrier = transfer_image.get_buffer().create_memory_barrier(
                        vk::ImageLayout::eShaderReadOnlyOptimal, vk::AccessFlagBits::eShaderRead);
                cmd_buffer.pipelineBarrier(vk::PipelineStageFlagBits::eHost, vk::PipelineStageFlagBits::eComputeShader,
                        vk::DependencyFlagBits::eByRegion, nullptr, nullptr, transfer_image_memory_barrier);
 
                auto image_size = ImageSize::fromExtent2D(frame_resources.converted_image.size);
                conversion_pipeline.record_commands(cmd_buffer, image_size,
                        {frame_resources.conversion_source_descriptor_set,
                         frame_resources.conversion_destination_descriptor_set});
        }
 
        Image2D& rendered_image = format_conversion_enabled ? frame_resources.converted_image : transfer_image.get_buffer();
        auto render_begin_memory_barrier = rendered_image.create_memory_barrier(
                vk::ImageLayout::eShaderReadOnlyOptimal, vk::AccessFlagBits::eShaderRead);
         auto previous_stage = format_conversion_enabled ?
                 vk::PipelineStageFlagBits::eComputeShader : vk::PipelineStageFlagBits::eHost;
        cmd_buffer.pipelineBarrier(previous_stage, vk::PipelineStageFlagBits::eFragmentShader,
                vk::DependencyFlagBits::eByRegion, nullptr, nullptr, render_begin_memory_barrier);
 
        render_pipeline.record_commands(cmd_buffer, frame_resources.render_descriptor_set,
                context.get_framebuffer(swapchain_image_id));
 
        auto transfer_image_memory_barrier = transfer_image.get_buffer().create_memory_barrier(
                vk::ImageLayout::eGeneral, vk::AccessFlagBits::eHostWrite | vk::AccessFlagBits::eHostRead);
        auto transfer_image_last_stage = format_conversion_enabled ?
                vk::PipelineStageFlagBits::eComputeShader : vk::PipelineStageFlagBits::eFragmentShader;
        cmd_buffer.pipelineBarrier(transfer_image_last_stage, vk::PipelineStageFlagBits::eHost,
                vk::DependencyFlagBits::eByRegion, nullptr, nullptr, transfer_image_memory_barrier);
        cmd_buffer.end();
}

References context, conversion_pipeline, vulkan_display_detail::Image2D::create_memory_barrier(), format_conversion_enabled, frame_resources, vulkan_display_detail::ImageSize::fromExtent2D(), vulkan_display_detail::TransferImageImpl::get_buffer(), vulkan_display_detail::VulkanContext::get_framebuffer(), vulkan_display_detail::ConversionPipeline::record_commands(), vulkan_display_detail::RenderPipeline::record_commands(), and render_pipeline.

Referenced by display_queued_image().

Here is the call graph for this function:

◆ window_parameters_changed() [1/2]

void vulkan_display::VulkanDisplay::window_parameters_changed ( )

inline

Thread-safe

Definition at line 205 of file vulkan_display.hpp.

                                         {
                window_parameters_changed(window->get_window_parameters());
        }

References vulkan_display::WindowChangedCallback::get_window_parameters(), window, and window_parameters_changed().

Referenced by window_parameters_changed().

Here is the call graph for this function:

◆ window_parameters_changed() [2/2]

void vulkan_display::VulkanDisplay::window_parameters_changed ( WindowParameters new_parameters )

Hint to vulkan display that some window parameters spicified in struct WindowParameters changed. Thread-safe.

Definition at line 629 of file vulkan_display.cpp.

                                                                             {
        if (new_parameters != context.get_window_parameters() && !new_parameters.is_minimized()) {
                std::scoped_lock lock{device_mutex};
                context.recreate_swapchain(new_parameters, render_pipeline.get_render_pass());
                auto render_area_size = context.get_render_area_size();
                render_pipeline.update_render_area(render_area_size, current_image_description.size);
        }
}

References context, current_image_description, device_mutex, vulkan_display_detail::VulkanContext::get_render_area_size(), vulkan_display_detail::RenderPipeline::get_render_pass(), vulkan_display_detail::VulkanContext::get_window_parameters(), vulkan_display::WindowParameters::is_minimized(), vulkan_display_detail::VulkanContext::recreate_swapchain(), render_pipeline, vulkan_display::ImageDescription::size, and vulkan_display_detail::RenderPipeline::update_render_area().

Here is the call graph for this function:

Member Data Documentation

◆ available_images

std::vector<TransferImageImpl*> vulkan_display::VulkanDisplay::available_images

private

local to provider thread

Definition at line 113 of file vulkan_display.hpp.

Referenced by acquire_transfer_image(), discard_image(), init(), and queue_image().

◆ available_img_queue

detail::ConcurrentQueue<TransferImageImpl*> vulkan_display::VulkanDisplay::available_img_queue {}

private

available_img_queue - producer is the render thread, consumer is the provided thread

Definition at line 109 of file vulkan_display.hpp.

109{};

Referenced by acquire_transfer_image(), and display_queued_image().

◆ command_pool

vk::CommandPool vulkan_display::VulkanDisplay::command_pool

private

Definition at line 98 of file vulkan_display.hpp.

Referenced by destroy(), and init().

◆ context

detail::VulkanContext vulkan_display::VulkanDisplay::context

private

Definition at line 87 of file vulkan_display.hpp.

Referenced by acquire_image(), destroy(), display_queued_image(), get_vulkan_version(), init(), is_image_description_supported(), is_yCbCr_supported(), reconfigure(), record_graphics_commands(), and window_parameters_changed().

◆ conversion_pipeline

detail::ConversionPipeline vulkan_display::VulkanDisplay::conversion_pipeline

private

Definition at line 93 of file vulkan_display.hpp.

Referenced by bind_transfer_image(), destroy(), destroy_format_dependent_resources(), reconfigure(), and record_graphics_commands().

◆ current_image_description

ImageDescription vulkan_display::VulkanDisplay::current_image_description

private

Definition at line 103 of file vulkan_display.hpp.

Referenced by display_queued_image(), reconfigure(), and window_parameters_changed().

◆ descriptor_pool

vk::DescriptorPool vulkan_display::VulkanDisplay::descriptor_pool

private

Definition at line 97 of file vulkan_display.hpp.

Referenced by destroy(), init(), and reconfigure().

◆ destroyed

bool vulkan_display::VulkanDisplay::destroyed = false

private

Definition at line 121 of file vulkan_display.hpp.

Referenced by ~VulkanDisplay(), and destroy().

◆ device

vk::Device vulkan_display::VulkanDisplay::device

private

Definition at line 89 of file vulkan_display.hpp.

Referenced by acquire_transfer_image(), bind_transfer_image(), destroy(), destroy_format_dependent_resources(), display_queued_image(), init(), and reconfigure().

◆ device_mutex

std::mutex vulkan_display::VulkanDisplay::device_mutex {}

private

Definition at line 90 of file vulkan_display.hpp.

90{};

Referenced by acquire_image(), display_queued_image(), is_image_description_supported(), and window_parameters_changed().

◆ filled_img_queue

detail::ConcurrentQueue<TransferImageImpl*, detail::filled_img_max_count> vulkan_display::VulkanDisplay::filled_img_queue {}

private

filled_img_queue - producer is the provider thread, consumer is the render thread

Definition at line 111 of file vulkan_display.hpp.

111{};

Referenced by display_queued_image(), and queue_image().

◆ format_conversion_enabled

bool vulkan_display::VulkanDisplay::format_conversion_enabled = false

private

Definition at line 92 of file vulkan_display.hpp.

Referenced by bind_transfer_image(), reconfigure(), and record_graphics_commands().

◆ frame_resources

std::array<detail::PerFrameResources, 3> vulkan_display::VulkanDisplay::frame_resources

private

Definition at line 100 of file vulkan_display.hpp.

Referenced by destroy(), destroy_format_dependent_resources(), init(), reconfigure(), and record_graphics_commands().

◆ free_frame_resources

std::vector<detail::PerFrameResources*> vulkan_display::VulkanDisplay::free_frame_resources

private

Definition at line 101 of file vulkan_display.hpp.

Referenced by display_queued_image(), and init().

◆ path_to_shaders

std::string vulkan_display::VulkanDisplay::path_to_shaders

private

Definition at line 85 of file vulkan_display.hpp.

Referenced by init(), and reconfigure().

◆ render_pipeline

detail::RenderPipeline vulkan_display::VulkanDisplay::render_pipeline

private

Definition at line 95 of file vulkan_display.hpp.

Referenced by bind_transfer_image(), destroy(), display_queued_image(), init(), reconfigure(), record_graphics_commands(), and window_parameters_changed().

◆ rendered_images

std::queue<RenderedImage> vulkan_display::VulkanDisplay::rendered_images

private

Definition at line 119 of file vulkan_display.hpp.

Referenced by display_queued_image().

◆ transfer_images

std::deque<TransferImageImpl> vulkan_display::VulkanDisplay::transfer_images {}

private

Definition at line 106 of file vulkan_display.hpp.

106{};

Referenced by acquire_transfer_image(), destroy(), and init().

◆ window

WindowChangedCallback* vulkan_display::VulkanDisplay::window = nullptr

private

Definition at line 86 of file vulkan_display.hpp.

Referenced by display_queued_image(), init(), and window_parameters_changed().

The documentation for this class was generated from the following files:

src/video_display/vulkan/vulkan_display.hpp
src/video_display/vulkan/vulkan_display.cpp

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ TransferImageImpl

Constructor & Destructor Documentation

◆ VulkanDisplay() [1/3]

◆ VulkanDisplay() [2/3]

◆ VulkanDisplay() [3/3]

◆ ~VulkanDisplay()

Member Function Documentation

◆ acquire_image()

◆ acquire_transfer_image()

◆ bind_transfer_image()

◆ copy_and_queue_image()

◆ destroy()

◆ destroy_format_dependent_resources()

◆ discard_image()

◆ display_queued_image()

◆ get_vulkan_version()

◆ init()

◆ is_image_description_supported()

◆ is_yCbCr_supported()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ queue_image()

◆ reconfigure()

◆ record_graphics_commands()

◆ window_parameters_changed() [1/2]

◆ window_parameters_changed() [2/2]

Member Data Documentation

◆ available_images

◆ available_img_queue

◆ command_pool

◆ context

◆ conversion_pipeline

◆ current_image_description

◆ descriptor_pool

◆ destroyed

◆ device

◆ device_mutex

◆ filled_img_queue

◆ format_conversion_enabled

◆ frame_resources

◆ free_frame_resources

◆ path_to_shaders

◆ render_pipeline

◆ rendered_images

◆ transfer_images

◆ window