vulkan::VulkanApplication Class Reference

#include <vulkan_application.h>

Public Member Functions
	VulkanApplication (VulkanProcTable &vk, const std::string &application_name, std::vector< std::string > enabled_extensions, uint32_t application_version=VK_MAKE_VERSION(1, 0, 0), uint32_t api_version=VK_MAKE_VERSION(1, 0, 0), bool enable_validation_layers=false)
	~VulkanApplication ()
bool	IsValid () const
uint32_t	GetAPIVersion () const
const VulkanHandle< VkInstance > &	GetInstance () const
void	ReleaseInstanceOwnership ()
std::unique_ptr< VulkanDevice >	AcquireFirstCompatibleLogicalDevice () const

Detailed Description

Applications using Vulkan acquire a VulkanApplication that attempts to create a VkInstance (with debug reporting optionally enabled).

Definition at line 25 of file vulkan_application.h.

Constructor & Destructor Documentation

VulkanApplication()

vulkan::VulkanApplication::VulkanApplication	(	VulkanProcTable &	vk,
		const std::string &	application_name,
		std::vector< std::string >	enabled_extensions,
		uint32_t	application_version = VK_MAKE_VERSION(1, 0, 0),
		uint32_t	api_version = VK_MAKE_VERSION(1, 0, 0),
		bool	enable_validation_layers = false
	)

Definition at line 16 of file vulkan_application.cc.

    : vk_(p_vk),
      api_version_(api_version),
      valid_(false),
      enable_validation_layers_(enable_validation_layers) {
  // Check if we want to enable debugging.
  std::vector<VkExtensionProperties> supported_extensions =
      GetSupportedInstanceExtensions(vk_);
  bool enable_instance_debugging =
      enable_validation_layers_ &&
      ExtensionSupported(supported_extensions,
                         VulkanDebugReport::DebugExtensionName());
 
  // Configure extensions.
 
  if (enable_instance_debugging) {
    enabled_extensions.emplace_back(VulkanDebugReport::DebugExtensionName());
  }
#if OS_FUCHSIA
  if (ExtensionSupported(supported_extensions,
                         VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
    // VK_KHR_get_physical_device_properties2 is a dependency of the memory
    // capabilities extension, so the validation layers require that it be
    // enabled.
    enabled_extensions.emplace_back(
        VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
    enabled_extensions.emplace_back(
        VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
  }
#endif
 
  std::vector<const char*> extensions;
 
  for (size_t i = 0; i < enabled_extensions.size(); i++) {
    extensions.push_back(enabled_extensions[i].c_str());
  }
 
  // Configure layers.
 
  const std::vector<std::string> enabled_layers =
      InstanceLayersToEnable(vk_, enable_validation_layers_);
 
  std::vector<const char*> layers;
 
  for (size_t i = 0; i < enabled_layers.size(); i++) {
    layers.push_back(enabled_layers[i].c_str());
  }
 
  // Configure init structs.
 
  const VkApplicationInfo info = {
      .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
      .pNext = nullptr,
      .pApplicationName = application_name.c_str(),
      .applicationVersion = application_version,
      .pEngineName = "FlutterEngine",
      .engineVersion = VK_MAKE_VERSION(1, 0, 0),
      .apiVersion = api_version_,
  };
 
  const VkInstanceCreateInfo create_info = {
      .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
      .pNext = nullptr,
      .flags = 0,
      .pApplicationInfo = &info,
      .enabledLayerCount = static_cast<uint32_t>(layers.size()),
      .ppEnabledLayerNames = layers.data(),
      .enabledExtensionCount = static_cast<uint32_t>(extensions.size()),
      .ppEnabledExtensionNames = extensions.data(),
  };
 
  // Perform initialization.
 
  VkInstance instance = VK_NULL_HANDLE;
 
  if (VK_CALL_LOG_ERROR(vk_.CreateInstance(&create_info, nullptr, &instance)) !=
      VK_SUCCESS) {
    FML_DLOG(INFO) << "Could not create application instance.";
    return;
  }
 
  // Now that we have an instance, set up instance proc table entries.
  if (!vk_.SetupInstanceProcAddresses(VulkanHandle<VkInstance>(instance))) {
    FML_DLOG(INFO) << "Could not set up instance proc addresses.";
    return;
  }
 
  instance_ = VulkanHandle<VkInstance>{instance, [this](VkInstance i) {
                                         FML_DLOG(INFO)
                                             << "Destroying Vulkan instance";
                                         vk_.DestroyInstance(i, nullptr);
                                       }};
 
  if (enable_instance_debugging) {
    auto debug_report = std::make_unique<VulkanDebugReport>(vk_, instance_);
    if (!debug_report->IsValid()) {
      FML_DLOG(INFO) << "Vulkan debugging was enabled but could not be set up "
                        "for this instance.";
    } else {
      debug_report_ = std::move(debug_report);
      FML_DLOG(INFO) << "Debug reporting is enabled.";
    }
  }
 
  valid_ = true;
}

~VulkanApplication()

vulkan::VulkanApplication::~VulkanApplication ( )

default

Member Function Documentation

AcquireFirstCompatibleLogicalDevice()

std::unique_ptr< VulkanDevice > vulkan::VulkanApplication::AcquireFirstCompatibleLogicalDevice

(

)

const

Definition at line 179 of file vulkan_application.cc.

                                                             {
  for (auto device_handle : GetPhysicalDevices()) {
    auto logical_device = std::make_unique<VulkanDevice>(
        vk_, VulkanHandle<VkPhysicalDevice>(device_handle),
        enable_validation_layers_);
    if (logical_device->IsValid()) {
      return logical_device;
    }
  }
  FML_DLOG(INFO) << "Could not acquire compatible logical device.";
  return nullptr;
}

GetAPIVersion()

uint32_t vulkan::VulkanApplication::GetAPIVersion

(

)

const

Definition at line 135 of file vulkan_application.cc.

                                                {
  return api_version_;
}

GetInstance()

const VulkanHandle< VkInstance > & vulkan::VulkanApplication::GetInstance

(

)

const

Definition at line 139 of file vulkan_application.cc.

                                                                     {
  return instance_;
}

IsValid()

bool vulkan::VulkanApplication::IsValid

(

)

const

Definition at line 131 of file vulkan_application.cc.

                                      {
  return valid_;
}

ReleaseInstanceOwnership()

void vulkan::VulkanApplication::ReleaseInstanceOwnership

(

)

Definition at line 143 of file vulkan_application.cc.

                                                 {
  instance_.ReleaseOwnership();
}

---

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

• vulkan/vulkan_application.h
• vulkan/vulkan_application.cc