#include <vulkan_device.h>

Public Member Functions
	VulkanDevice (VulkanProcTable &vk, VulkanHandle< VkPhysicalDevice > physical_device, bool enable_validation_layers)
	Create a new VkDevice with a resolved VkQueue suitable for rendering with Skia.

	VulkanDevice (VulkanProcTable &vk, VulkanHandle< VkPhysicalDevice > physical_device, VulkanHandle< VkDevice > device, uint32_t queue_family_index, VulkanHandle< VkQueue > queue)
	Wrap an existing VkDevice and VkQueue.

	~VulkanDevice ()

bool	IsValid () const

const VulkanHandle< VkDevice > &	GetHandle () const

const VulkanHandle< VkPhysicalDevice > &	GetPhysicalDeviceHandle () const

const VulkanHandle< VkQueue > &	GetQueueHandle () const

const VulkanHandle< VkCommandPool > &	GetCommandPool () const

uint32_t	GetGraphicsQueueIndex () const

void	ReleaseDeviceOwnership ()

bool	GetSurfaceCapabilities (const VulkanSurface &surface, VkSurfaceCapabilitiesKHR *capabilities) const

bool	GetPhysicalDeviceFeatures (VkPhysicalDeviceFeatures *features) const

int	ChooseSurfaceFormat (const VulkanSurface &surface, const std::vector< VkFormat > &desired_formats, VkSurfaceFormatKHR *format) const

bool	ChoosePresentMode (const VulkanSurface &surface, VkPresentModeKHR *present_mode) const

bool	QueueSubmit (std::vector< VkPipelineStageFlags > wait_dest_pipeline_stages, const std::vector< VkSemaphore > &wait_semaphores, const std::vector< VkSemaphore > &signal_semaphores, const std::vector< VkCommandBuffer > &command_buffers, const VulkanHandle< VkFence > &fence) const

bool	WaitIdle () const

Detailed Description

Definition at line 18 of file vulkan_device.h.

Constructor & Destructor Documentation

◆ VulkanDevice() [1/2]

vulkan::VulkanDevice::VulkanDevice	(	VulkanProcTable &	vk,
		VulkanHandle< VkPhysicalDevice >	physical_device,
		bool	enable_validation_layers
	)

Create a new VkDevice with a resolved VkQueue suitable for rendering with Skia.

Definition at line 31 of file vulkan_device.cc.

    : vk_(p_vk),
      physical_device_(std::move(physical_device)),
      graphics_queue_index_(std::numeric_limits<uint32_t>::max()),
      valid_(false) {
  if (!physical_device_ || !vk_.AreInstanceProcsSetup()) {
    return;
  }
 
  graphics_queue_index_ = FindGraphicsQueueIndex(GetQueueFamilyProperties());
 
  if (graphics_queue_index_ == kVulkanInvalidGraphicsQueueIndex) {
    FML_DLOG(INFO) << "Could not find the graphics queue index.";
    return;
  }
 
  const float priorities[1] = {1.0f};
 
  const VkDeviceQueueCreateInfo queue_create = {
      .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
      .pNext = nullptr,
      .flags = 0,
      .queueFamilyIndex = graphics_queue_index_,
      .queueCount = 1,
      .pQueuePriorities = priorities,
  };
 
  const char* extensions[] = {
#if FML_OS_ANDROID
      VK_KHR_SWAPCHAIN_EXTENSION_NAME,
#endif
#if OS_FUCHSIA
      VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME,
      VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
      VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
      VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME,
      VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
      VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME,
#endif
  };
 
  auto enabled_layers =
      DeviceLayersToEnable(vk_, physical_device_, enable_validation_layers);
 
  std::vector<const char*> layers;
 
  layers.reserve(enabled_layers.size());
  for (size_t i = 0; i < enabled_layers.size(); i++) {
    layers.push_back(enabled_layers[i].c_str());
  }
 
  const VkDeviceCreateInfo create_info = {
      .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
      .pNext = nullptr,
      .flags = 0,
      .queueCreateInfoCount = 1,
      .pQueueCreateInfos = &queue_create,
      .enabledLayerCount = static_cast<uint32_t>(layers.size()),
      .ppEnabledLayerNames = layers.data(),
      .enabledExtensionCount = sizeof(extensions) / sizeof(const char*),
      .ppEnabledExtensionNames = extensions,
      .pEnabledFeatures = nullptr,
  };
 
  VkDevice device = VK_NULL_HANDLE;
 
  if (VK_CALL_LOG_ERROR(vk_.CreateDevice(physical_device_, &create_info,
                                         nullptr, &device)) != VK_SUCCESS) {
    FML_DLOG(INFO) << "Could not create device.";
    return;
  }
 
  device_ = VulkanHandle<VkDevice>{
      device, [this](VkDevice device) { vk_.DestroyDevice(device, nullptr); }};
 
  if (!vk_.SetupDeviceProcAddresses(device_)) {
    FML_DLOG(INFO) << "Could not set up device proc addresses.";
    return;
  }
 
  VkQueue queue = VK_NULL_HANDLE;
 
  vk_.GetDeviceQueue(device_, graphics_queue_index_, 0, &queue);
 
  if (queue == VK_NULL_HANDLE) {
    FML_DLOG(INFO) << "Could not get the device queue handle.";
    return;
  }
 
  queue_ = VulkanHandle<VkQueue>(queue);
 
  if (!InitializeCommandPool()) {
    return;
  }
 
  valid_ = true;
}

References vulkan::VulkanProcTable::AreInstanceProcsSetup(), device, vulkan::DeviceLayersToEnable(), enable_validation_layers, vulkan::FindGraphicsQueueIndex(), FML_DLOG, i, vulkan::kVulkanInvalidGraphicsQueueIndex, layers, queue, vulkan::VulkanProcTable::SetupDeviceProcAddresses(), FlutterLayer::size, and VK_CALL_LOG_ERROR.

◆ VulkanDevice() [2/2]

vulkan::VulkanDevice::VulkanDevice	(	VulkanProcTable &	vk,
		VulkanHandle< VkPhysicalDevice >	physical_device,
		VulkanHandle< VkDevice >	device,
		uint32_t	queue_family_index,
		VulkanHandle< VkQueue >	queue
	)

Wrap an existing VkDevice and VkQueue.

Definition at line 131 of file vulkan_device.cc.

    : vk_(p_vk),
      physical_device_(std::move(physical_device)),
      device_(std::move(device)),
      queue_(std::move(queue)),
      graphics_queue_index_(queue_family_index),
      valid_(false) {
  if (!physical_device_ || !vk_.AreInstanceProcsSetup()) {
    return;
  }
 
  if (!InitializeCommandPool()) {
    return;
  }
 
  valid_ = true;
}

References vulkan::VulkanProcTable::AreInstanceProcsSetup().

◆ ~VulkanDevice()

vulkan::VulkanDevice::~VulkanDevice ( )

Definition at line 177 of file vulkan_device.cc.

                            {
  [[maybe_unused]] auto result = WaitIdle();
}

References WaitIdle().

Member Function Documentation

◆ ChoosePresentMode()

bool vulkan::VulkanDevice::ChoosePresentMode	(	const VulkanSurface &	surface,
		VkPresentModeKHR *	present_mode
	)		const

Definition at line 322 of file vulkan_device.cc.

                                                                           {
  if (!surface.IsValid() || present_mode == nullptr) {
    return false;
  }
 
  // https://github.com/LunarG/VulkanSamples/issues/98 indicates that
  // VK_PRESENT_MODE_FIFO_KHR is preferable on mobile platforms. The problems
  // mentioned in the ticket w.r.t the application being faster that the refresh
  // rate of the screen should not be faced by any Flutter platforms as they are
  // powered by Vsync pulses instead of depending the submit to block.
  // However, for platforms that don't have VSync providers set up, it is better
  // to fall back to FIFO. For platforms that do have VSync providers, there
  // should be little difference. In case there is a need for a mode other than
  // FIFO, availability checks must be performed here before returning the
  // result. FIFO is always present.
  *present_mode = VK_PRESENT_MODE_FIFO_KHR;
  return true;
}

References surface.

◆ ChooseSurfaceFormat()

int vulkan::VulkanDevice::ChooseSurfaceFormat	(	const VulkanSurface &	surface,
		const std::vector< VkFormat > &	desired_formats,
		VkSurfaceFormatKHR *	format
	)		const

Definition at line 276 of file vulkan_device.cc.

                                      {
#if FML_OS_ANDROID
  if (!surface.IsValid() || format == nullptr) {
    return -1;
  }
 
  uint32_t format_count = 0;
  if (VK_CALL_LOG_ERROR(vk_.GetPhysicalDeviceSurfaceFormatsKHR(
          physical_device_, surface.Handle(), &format_count, nullptr)) !=
      VK_SUCCESS) {
    return -1;
  }
 
  if (format_count == 0) {
    return -1;
  }
 
  std::vector<VkSurfaceFormatKHR> formats;
  formats.resize(format_count);
 
  if (VK_CALL_LOG_ERROR(vk_.GetPhysicalDeviceSurfaceFormatsKHR(
          physical_device_, surface.Handle(), &format_count, formats.data())) !=
      VK_SUCCESS) {
    return -1;
  }
 
  std::map<VkFormat, VkSurfaceFormatKHR> supported_formats;
  for (uint32_t i = 0; i < format_count; i++) {
    supported_formats[formats[i].format] = formats[i];
  }
 
  // Try to find the first supported format in the list of desired formats.
  for (size_t i = 0; i < desired_formats.size(); ++i) {
    auto found = supported_formats.find(desired_formats[i]);
    if (found != supported_formats.end()) {
      *format = found->second;
      return static_cast<int>(i);
    }
  }
#endif
  return -1;
}

References format, i, surface, and VK_CALL_LOG_ERROR.

◆ GetCommandPool()

const VulkanHandle< VkCommandPool > & vulkan::VulkanDevice::GetCommandPool ( ) const

Definition at line 206 of file vulkan_device.cc.

                                                                      {
  return command_pool_;
}

◆ GetGraphicsQueueIndex()

uint32_t vulkan::VulkanDevice::GetGraphicsQueueIndex ( ) const

Definition at line 210 of file vulkan_device.cc.

                                                   {
  return graphics_queue_index_;
}

◆ GetHandle()

const VulkanHandle< VkDevice > & vulkan::VulkanDevice::GetHandle ( ) const

Definition at line 189 of file vulkan_device.cc.

                                                            {
  return device_;
}

◆ GetPhysicalDeviceFeatures()

bool vulkan::VulkanDevice::GetPhysicalDeviceFeatures ( VkPhysicalDeviceFeatures * features ) const

Definition at line 252 of file vulkan_device.cc.

                                              {
  if (features == nullptr || !physical_device_) {
    return false;
  }
  vk_.GetPhysicalDeviceFeatures(physical_device_, features);
  return true;
}

◆ GetPhysicalDeviceHandle()

const VulkanHandle< VkPhysicalDevice > & vulkan::VulkanDevice::GetPhysicalDeviceHandle ( ) const

Definition at line 197 of file vulkan_device.cc.

          {
  return physical_device_;
}

◆ GetQueueHandle()

const VulkanHandle< VkQueue > & vulkan::VulkanDevice::GetQueueHandle ( ) const

Definition at line 202 of file vulkan_device.cc.

                                                                {
  return queue_;
}

◆ GetSurfaceCapabilities()

bool vulkan::VulkanDevice::GetSurfaceCapabilities	(	const VulkanSurface &	surface,
		VkSurfaceCapabilitiesKHR *	capabilities
	)		const

Definition at line 214 of file vulkan_device.cc.

                                                  {
#if FML_OS_ANDROID
  if (!surface.IsValid() || capabilities == nullptr) {
    return false;
  }
 
  bool success =
      VK_CALL_LOG_ERROR(vk_.GetPhysicalDeviceSurfaceCapabilitiesKHR(
          physical_device_, surface.Handle(), capabilities)) == VK_SUCCESS;
 
  if (!success) {
    return false;
  }
 
  // Check if the physical device surface capabilities are valid. If so, there
  // is nothing more to do.
  if (capabilities->currentExtent.width != 0xFFFFFFFF &&
      capabilities->currentExtent.height != 0xFFFFFFFF) {
    return true;
  }
 
  // Ask the native surface for its size as a fallback.
  SkISize size = surface.GetSize();
 
  if (size.width() == 0 || size.height() == 0) {
    return false;
  }
 
  capabilities->currentExtent.width = size.width();
  capabilities->currentExtent.height = size.height();
  return true;
#else
  return false;
#endif
}

References surface, and VK_CALL_LOG_ERROR.

◆ IsValid()

bool vulkan::VulkanDevice::IsValid ( ) const

Definition at line 181 of file vulkan_device.cc.

                                 {
  return valid_;
}

◆ QueueSubmit()

bool vulkan::VulkanDevice::QueueSubmit	(	std::vector< VkPipelineStageFlags >	wait_dest_pipeline_stages,
		const std::vector< VkSemaphore > &	wait_semaphores,
		const std::vector< VkSemaphore > &	signal_semaphores,
		const std::vector< VkCommandBuffer > &	command_buffers,
		const VulkanHandle< VkFence > &	fence
	)		const

Definition at line 342 of file vulkan_device.cc.

                                              {
  if (wait_semaphores.size() != wait_dest_pipeline_stages.size()) {
    return false;
  }
 
  const VkSubmitInfo submit_info = {
      .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
      .pNext = nullptr,
      .waitSemaphoreCount = static_cast<uint32_t>(wait_semaphores.size()),
      .pWaitSemaphores = wait_semaphores.data(),
      .pWaitDstStageMask = wait_dest_pipeline_stages.data(),
      .commandBufferCount = static_cast<uint32_t>(command_buffers.size()),
      .pCommandBuffers = command_buffers.data(),
      .signalSemaphoreCount = static_cast<uint32_t>(signal_semaphores.size()),
      .pSignalSemaphores = signal_semaphores.data(),
  };
 
  if (VK_CALL_LOG_ERROR(vk_.QueueSubmit(queue_, 1, &submit_info, fence)) !=
      VK_SUCCESS) {
    return false;
  }
 
  return true;
}

References VK_CALL_LOG_ERROR.

◆ ReleaseDeviceOwnership()

void vulkan::VulkanDevice::ReleaseDeviceOwnership ( )

Definition at line 193 of file vulkan_device.cc.

                                          {
  device_.ReleaseOwnership();
}

References vulkan::VulkanHandle< T >::ReleaseOwnership().

◆ WaitIdle()

bool vulkan::VulkanDevice::WaitIdle ( ) const

Definition at line 185 of file vulkan_device.cc.

                                  {
  return VK_CALL_LOG_ERROR(vk_.DeviceWaitIdle(device_)) == VK_SUCCESS;
}