vulkan Namespace Reference

Classes
class	VulkanApplication
class	VulkanBackbuffer
class	VulkanCommandBuffer
class	VulkanDebugReport
class	VulkanDevice
class	VulkanHandle
class	VulkanImage
class	VulkanNativeSurface
class	VulkanNativeSurfaceAndroid
class	VulkanProcTable
class	VulkanProvider
class	VulkanSurface
class	VulkanSwapchain
class	VulkanWindow

Functions
std::string	VulkanResultToString (VkResult result)
static const char *	VkDebugReportFlagsEXTToString (VkDebugReportFlagsEXT flags)
static const char *	VkDebugReportObjectTypeEXTToString (VkDebugReportObjectTypeEXT type)
static VKAPI_ATTR VkBool32	OnVulkanDebugReportCallback (VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT object_type, uint64_t object, size_t location, int32_t message_code, const char *layer_prefix, const char *message, void *user_data)
static uint32_t	FindGraphicsQueueIndex (const std::vector< VkQueueFamilyProperties > &properties)
GrVkGetProc	CreateSkiaGetProc (const fml::RefPtr< vulkan::VulkanProcTable > &vk)
static std::vector< FormatInfo >	DesiredFormatInfos ()
bool	ValidationLayerInfoMessagesEnabled ()
bool	ValidationErrorsFatal ()
static std::vector< std::string >	InstanceOrDeviceLayersToEnable (const VulkanProcTable &vk, VkPhysicalDevice physical_device, bool enable_validation_layers)
std::vector< std::string >	InstanceLayersToEnable (const VulkanProcTable &vk, bool enable_validation_layers)
std::vector< std::string >	DeviceLayersToEnable (const VulkanProcTable &vk, const VulkanHandle< VkPhysicalDevice > &physical_device, bool enable_validation_layers)

Variables
static const size_t	kGrCacheMaxByteSize = 512 * (1 << 20)
static const VkDebugReportFlagsEXT kVulkanErrorFlags	FML_ALLOW_UNUSED_TYPE
constexpr auto	kVulkanInvalidGraphicsQueueIndex

Function Documentation

CreateSkiaGetProc()

GrVkGetProc vulkan::CreateSkiaGetProc

(

const fml::RefPtr< vulkan::VulkanProcTable > &

vk

)

Definition at line 9 of file vulkan_skia_proc_table.cc.

                                                                          {
  if (!vk || !vk->IsValid()) {
    return nullptr;
  }
 
  return [vk](const char* proc_name, VkInstance instance, VkDevice device) {
    if (device != VK_NULL_HANDLE) {
      auto result =
          vk->AcquireProc(proc_name, VulkanHandle<VkDevice>{device, nullptr});
      if (result != nullptr) {
        return result;
      }
    }
 
    return vk->AcquireProc(proc_name,
                           VulkanHandle<VkInstance>{instance, nullptr});
  };
}

DesiredFormatInfos()

static std::vector< FormatInfo > vulkan::DesiredFormatInfos ( )

static

Definition at line 32 of file vulkan_swapchain.cc.

                                                  {
  return {{VK_FORMAT_R8G8B8A8_SRGB, kRGBA_8888_SkColorType,
           SkColorSpace::MakeSRGB()},
          {VK_FORMAT_B8G8R8A8_SRGB, kRGBA_8888_SkColorType,
           SkColorSpace::MakeSRGB()},
          {VK_FORMAT_R16G16B16A16_SFLOAT, kRGBA_F16_SkColorType,
           SkColorSpace::MakeSRGBLinear()},
          {VK_FORMAT_R8G8B8A8_UNORM, kRGBA_8888_SkColorType,
           SkColorSpace::MakeSRGB()},
          {VK_FORMAT_B8G8R8A8_UNORM, kRGBA_8888_SkColorType,
           SkColorSpace::MakeSRGB()}};
}

DeviceLayersToEnable()

std::vector< std::string > vulkan::DeviceLayersToEnable	(	const VulkanProcTable &	vk,
		const VulkanHandle< VkPhysicalDevice > &	physical_device,
		bool	enable_validation_layers
	)

Definition at line 103 of file vulkan_utilities.cc.

                                   {
  if (!physical_device) {
    return {};
  }
 
  return InstanceOrDeviceLayersToEnable(vk, physical_device,
                                        enable_validation_layers);
}

FindGraphicsQueueIndex()

static uint32_t vulkan::FindGraphicsQueueIndex ( const std::vector< VkQueueFamilyProperties > &  properties )

static

Definition at line 21 of file vulkan_device.cc.

                                                          {
  for (uint32_t i = 0, count = static_cast<uint32_t>(properties.size());
       i < count; i++) {
    if (properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
      return i;
    }
  }
  return kVulkanInvalidGraphicsQueueIndex;
}

InstanceLayersToEnable()

std::vector< std::string > vulkan::InstanceLayersToEnable	(	const VulkanProcTable &	vk,
		bool	enable_validation_layers
	)

Definition at line 97 of file vulkan_utilities.cc.

                                                                               {
  return InstanceOrDeviceLayersToEnable(vk, VK_NULL_HANDLE,
                                        enable_validation_layers);
}

InstanceOrDeviceLayersToEnable()

static std::vector< std::string > vulkan::InstanceOrDeviceLayersToEnable ( const VulkanProcTable &  vk, VkPhysicalDevice  physical_device, bool  enable_validation_layers  )

static

Definition at line 27 of file vulkan_utilities.cc.

                                   {
  if (!enable_validation_layers) {
    return {};
  }
 
  // NOTE: The loader is sensitive to the ordering here. Please do not rearrange
  // this list.
#if OS_FUCHSIA
  // The other layers in the Fuchsia SDK seem to have a bug right now causing
  // crashes, so it is only recommended that we use VK_LAYER_KHRONOS_validation
  // until we have a confirmation that they are fixed.
  const std::vector<std::string> candidates = {"VK_LAYER_KHRONOS_validation"};
#else
  const std::vector<std::string> candidates = {
      "VK_LAYER_GOOGLE_threading",      "VK_LAYER_LUNARG_parameter_validation",
      "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation",
      "VK_LAYER_LUNARG_device_limits",  "VK_LAYER_LUNARG_image",
      "VK_LAYER_LUNARG_swapchain",      "VK_LAYER_GOOGLE_unique_objects"};
#endif
 
  uint32_t count = 0;
 
  if (physical_device == VK_NULL_HANDLE) {
    if (VK_CALL_LOG_ERROR(vk.EnumerateInstanceLayerProperties(
            &count, nullptr)) != VK_SUCCESS) {
      return {};
    }
  } else {
    if (VK_CALL_LOG_ERROR(vk.EnumerateDeviceLayerProperties(
            physical_device, &count, nullptr)) != VK_SUCCESS) {
      return {};
    }
  }
 
  std::vector<VkLayerProperties> properties;
  properties.resize(count);
 
  if (physical_device == VK_NULL_HANDLE) {
    if (VK_CALL_LOG_ERROR(vk.EnumerateInstanceLayerProperties(
            &count, properties.data())) != VK_SUCCESS) {
      return {};
    }
  } else {
    if (VK_CALL_LOG_ERROR(vk.EnumerateDeviceLayerProperties(
            physical_device, &count, properties.data())) != VK_SUCCESS) {
      return {};
    }
  }
 
  std::unordered_set<std::string> available_extensions;
 
  for (size_t i = 0; i < count; i++) {
    available_extensions.emplace(properties[i].layerName);
  }
 
  std::vector<std::string> available_candidates;
 
  for (const auto& candidate : candidates) {
    auto found = available_extensions.find(candidate);
    if (found != available_extensions.end()) {
      available_candidates.emplace_back(candidate);
    }
  }
 
  return available_candidates;
}

OnVulkanDebugReportCallback()

static VKAPI_ATTR VkBool32 vulkan::OnVulkanDebugReportCallback ( VkDebugReportFlagsEXT  flags, VkDebugReportObjectTypeEXT  object_type, uint64_t  object, size_t  location, int32_t  message_code, const char *  layer_prefix, const char *  message, void *  user_data  )

static

Definition at line 114 of file vulkan_debug_report.cc.

                                                 {
  std::vector<std::pair<std::string, std::string>> items;
 
  items.emplace_back("Severity", VkDebugReportFlagsEXTToString(flags));
 
  items.emplace_back("Object Type",
                     VkDebugReportObjectTypeEXTToString(object_type));
 
  items.emplace_back("Object Handle", std::to_string(object));
 
  if (location != 0) {
    items.emplace_back("Location", std::to_string(location));
  }
 
  if (message_code != 0) {
    items.emplace_back("Message Code", std::to_string(message_code));
  }
 
  if (layer_prefix != nullptr) {
    items.emplace_back("Layer", layer_prefix);
  }
 
  if (message != nullptr) {
    items.emplace_back("Message", message);
  }
 
  size_t padding = 0;
 
  for (const auto& item : items) {
    padding = std::max(padding, item.first.size());
  }
 
  padding += 1;
 
  std::stringstream stream;
 
  stream << std::endl;
 
  stream << "--- Vulkan Debug Report  ----------------------------------------";
 
  stream << std::endl;
 
  for (const auto& item : items) {
    stream << "| " << std::setw(static_cast<int>(padding)) << item.first
           << std::setw(0) << ": " << item.second << std::endl;
  }
 
  stream << "-----------------------------------------------------------------";
 
  if (flags & kVulkanErrorFlags) {
    if (ValidationErrorsFatal()) {
      FML_DCHECK(false) << stream.str();
    } else {
      FML_LOG(ERROR) << stream.str();
    }
  } else {
    FML_LOG(INFO) << stream.str();
  }
 
  // Returning false tells the layer not to stop when the event occurs, so
  // they see the same behavior with and without validation layers enabled.
  return VK_FALSE;
}

ValidationErrorsFatal()

bool vulkan::ValidationErrorsFatal

(

)

Definition at line 20 of file vulkan_utilities.cc.

                             {
#if OS_FUCHSIA
  return false;
#endif
  return true;
}

ValidationLayerInfoMessagesEnabled()

bool vulkan::ValidationLayerInfoMessagesEnabled

(

)

Definition at line 16 of file vulkan_utilities.cc.

                                          {
  return false;
}

VkDebugReportFlagsEXTToString()

static const char * vulkan::VkDebugReportFlagsEXTToString ( VkDebugReportFlagsEXT  flags )

static

Definition at line 27 of file vulkan_debug_report.cc.

                                                                              {
  if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
    return "Information";
  } else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
    return "Warning";
  } else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
    return "Performance Warning";
  } else if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
    return "Error";
  } else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
    return "Debug";
  }
  return "UNKNOWN";
}

VkDebugReportObjectTypeEXTToString()

static const char * vulkan::VkDebugReportObjectTypeEXTToString ( VkDebugReportObjectTypeEXT  type )

static

Definition at line 42 of file vulkan_debug_report.cc.

                                     {
  switch (type) {
    case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
      return "Unknown";
    case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:
      return "Instance";
    case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:
      return "Physical Device";
    case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:
      return "Device";
    case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:
      return "Queue";
    case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:
      return "Semaphore";
    case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:
      return "Command Buffer";
    case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:
      return "Fence";
    case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:
      return "Device Memory";
    case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:
      return "Buffer";
    case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:
      return "Image";
    case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:
      return "Event";
    case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:
      return "Query Pool";
    case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:
      return "Buffer View";
    case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:
      return "Image_view";
    case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:
      return "Shader Module";
    case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:
      return "Pipeline Cache";
    case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:
      return "Pipeline Layout";
    case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:
      return "Render Pass";
    case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:
      return "Pipeline";
    case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:
      return "Descriptor Set Layout";
    case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:
      return "Sampler";
    case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:
      return "Descriptor Pool";
    case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:
      return "Descriptor Set";
    case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:
      return "Framebuffer";
    case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:
      return "Command Pool";
    case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:
      return "Surface";
    case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:
      return "Swapchain";
    case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT:
      return "Debug";
    default:
      break;
  }
 
  return "Unknown";
}

VulkanResultToString()

std::string vulkan::VulkanResultToString

(

VkResult

result

)

Definition at line 9 of file vulkan_interface.cc.

                                                {
  switch (result) {
    case VK_SUCCESS:
      return "VK_SUCCESS";
    case VK_NOT_READY:
      return "VK_NOT_READY";
    case VK_TIMEOUT:
      return "VK_TIMEOUT";
    case VK_EVENT_SET:
      return "VK_EVENT_SET";
    case VK_EVENT_RESET:
      return "VK_EVENT_RESET";
    case VK_INCOMPLETE:
      return "VK_INCOMPLETE";
    case VK_ERROR_OUT_OF_HOST_MEMORY:
      return "VK_ERROR_OUT_OF_HOST_MEMORY";
    case VK_ERROR_OUT_OF_DEVICE_MEMORY:
      return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
    case VK_ERROR_INITIALIZATION_FAILED:
      return "VK_ERROR_INITIALIZATION_FAILED";
    case VK_ERROR_DEVICE_LOST:
      return "VK_ERROR_DEVICE_LOST";
    case VK_ERROR_MEMORY_MAP_FAILED:
      return "VK_ERROR_MEMORY_MAP_FAILED";
    case VK_ERROR_LAYER_NOT_PRESENT:
      return "VK_ERROR_LAYER_NOT_PRESENT";
    case VK_ERROR_EXTENSION_NOT_PRESENT:
      return "VK_ERROR_EXTENSION_NOT_PRESENT";
    case VK_ERROR_FEATURE_NOT_PRESENT:
      return "VK_ERROR_FEATURE_NOT_PRESENT";
    case VK_ERROR_INCOMPATIBLE_DRIVER:
      return "VK_ERROR_INCOMPATIBLE_DRIVER";
    case VK_ERROR_TOO_MANY_OBJECTS:
      return "VK_ERROR_TOO_MANY_OBJECTS";
    case VK_ERROR_FORMAT_NOT_SUPPORTED:
      return "VK_ERROR_FORMAT_NOT_SUPPORTED";
    case VK_ERROR_FRAGMENTED_POOL:
      return "VK_ERROR_FRAGMENTED_POOL";
    case VK_ERROR_SURFACE_LOST_KHR:
      return "VK_ERROR_SURFACE_LOST_KHR";
    case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
      return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
    case VK_SUBOPTIMAL_KHR:
      return "VK_SUBOPTIMAL_KHR";
    case VK_ERROR_OUT_OF_DATE_KHR:
      return "VK_ERROR_OUT_OF_DATE_KHR";
    case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
      return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
    case VK_ERROR_VALIDATION_FAILED_EXT:
      return "VK_ERROR_VALIDATION_FAILED_EXT";
    case VK_ERROR_INVALID_SHADER_NV:
      return "VK_ERROR_INVALID_SHADER_NV";
#if VK_HEADER_VERSION < 140
    case VK_RESULT_RANGE_SIZE:
      return "VK_RESULT_RANGE_SIZE";
#endif
    case VK_RESULT_MAX_ENUM:
      return "VK_RESULT_MAX_ENUM";
    case VK_ERROR_INVALID_EXTERNAL_HANDLE:
      return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
    case VK_ERROR_OUT_OF_POOL_MEMORY:
      return "VK_ERROR_OUT_OF_POOL_MEMORY";
    default:
      return "Unknown Error";
  }
  return "";
}

Variable Documentation

FML_ALLOW_UNUSED_TYPE

static const VkDebugReportFlagsEXT kVulkanInfoFlags vulkan::FML_ALLOW_UNUSED_TYPE

static

Initial value:

=
    VK_DEBUG_REPORT_WARNING_BIT_EXT |
    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT | VK_DEBUG_REPORT_ERROR_BIT_EXT

Definition at line 16 of file vulkan_debug_report.cc.

kGrCacheMaxByteSize

const size_t vulkan::kGrCacheMaxByteSize = 512 * (1 << 20)

static

Definition at line 18 of file vulkan_application.h.

kVulkanInvalidGraphicsQueueIndex

constexpr auto vulkan::kVulkanInvalidGraphicsQueueIndex

constexpr

Initial value:

=
    std::numeric_limits<uint32_t>::max()

Definition at line 18 of file vulkan_device.cc.