Flutter Engine
 
Loading...
Searching...
No Matches
Classes | Functions | Variables
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
 

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)
 
skgpu::VulkanGetProc 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
 
static const VkDebugReportFlagsEXT kVulkanInfoFlags
 
constexpr auto kVulkanInvalidGraphicsQueueIndex
 

Function Documentation

◆ CreateSkiaGetProc()

skgpu::VulkanGetProc vulkan::CreateSkiaGetProc ( const fml::RefPtr< vulkan::VulkanProcTable > &  vk)

Definition at line 9 of file vulkan_skia_proc_table.cc.

10 {
11 if (!vk || !vk->IsValid()) {
12 return nullptr;
13 }
14
15 return [vk](const char* proc_name, VkInstance instance, VkDevice device) {
16 if (device != VK_NULL_HANDLE) {
17 auto result =
18 vk->AcquireProc(proc_name, VulkanHandle<VkDevice>{device, nullptr});
19 if (result != nullptr) {
20 return result;
21 }
22 }
23
24 return vk->AcquireProc(proc_name,
25 VulkanHandle<VkInstance>{instance, nullptr});
26 };
27}
vulkan::VulkanProcTable::AcquireProc
PFN_vkVoidFunction AcquireProc(const char *proc_name, const VulkanHandle< VkInstance > &instance) const
Definition vulkan_proc_table.cc:212
device
VkDevice device
Definition main.cc:69
instance
VkInstance instance
Definition main.cc:64

References device, and instance.

Referenced by flutter::testing::TestVulkanContext::TestVulkanContext().

◆ DesiredFormatInfos()

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

Definition at line 32 of file vulkan_swapchain.cc.

32 {
33 return {{VK_FORMAT_R8G8B8A8_SRGB, kRGBA_8888_SkColorType,
34 SkColorSpace::MakeSRGB()},
35 {VK_FORMAT_B8G8R8A8_SRGB, kRGBA_8888_SkColorType,
36 SkColorSpace::MakeSRGB()},
37 {VK_FORMAT_R16G16B16A16_SFLOAT, kRGBA_F16_SkColorType,
38 SkColorSpace::MakeSRGBLinear()},
39 {VK_FORMAT_R8G8B8A8_UNORM, kRGBA_8888_SkColorType,
40 SkColorSpace::MakeSRGB()},
41 {VK_FORMAT_B8G8R8A8_UNORM, kRGBA_8888_SkColorType,
42 SkColorSpace::MakeSRGB()}};
43}

Referenced by vulkan::VulkanSwapchain::VulkanSwapchain().

◆ 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.

106 {
107 if (!physical_device) {
108 return {};
109 }
110
111 return InstanceOrDeviceLayersToEnable(vk, physical_device,
112 enable_validation_layers);
113}
physical_device
VkPhysicalDevice physical_device
Definition main.cc:67
enable_validation_layers
bool enable_validation_layers
Definition main.cc:36
vulkan::InstanceOrDeviceLayersToEnable
static std::vector< std::string > InstanceOrDeviceLayersToEnable(const VulkanProcTable &vk, VkPhysicalDevice physical_device, bool enable_validation_layers)
Definition vulkan_utilities.cc:27

References enable_validation_layers, InstanceOrDeviceLayersToEnable(), and physical_device.

Referenced by vulkan::VulkanDevice::VulkanDevice().

◆ FindGraphicsQueueIndex()

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

Definition at line 20 of file vulkan_device.cc.

21 {
22 for (uint32_t i = 0, count = static_cast<uint32_t>(properties.size());
23 i < count; i++) {
24 if (properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
25 return i;
26 }
27 }
28 return kVulkanInvalidGraphicsQueueIndex;
29}
i
int i
Definition fl_socket_accessible.cc:18
vulkan::kVulkanInvalidGraphicsQueueIndex
constexpr auto kVulkanInvalidGraphicsQueueIndex
Definition vulkan_device.cc:17

References i, and kVulkanInvalidGraphicsQueueIndex.

Referenced by vulkan::VulkanDevice::VulkanDevice().

◆ InstanceLayersToEnable()

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

Definition at line 97 of file vulkan_utilities.cc.

98 {
99 return InstanceOrDeviceLayersToEnable(vk, VK_NULL_HANDLE,
100 enable_validation_layers);
101}

References enable_validation_layers, and InstanceOrDeviceLayersToEnable().

Referenced by vulkan::VulkanApplication::VulkanApplication().

◆ 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.

30 {
31 if (!enable_validation_layers) {
32 return {};
33 }
34
35 // NOTE: The loader is sensitive to the ordering here. Please do not rearrange
36 // this list.
37#if OS_FUCHSIA
38 // The other layers in the Fuchsia SDK seem to have a bug right now causing
39 // crashes, so it is only recommended that we use VK_LAYER_KHRONOS_validation
40 // until we have a confirmation that they are fixed.
41 const std::vector<std::string> candidates = {"VK_LAYER_KHRONOS_validation"};
42#else
43 const std::vector<std::string> candidates = {
44 "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation",
45 "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation",
46 "VK_LAYER_LUNARG_device_limits", "VK_LAYER_LUNARG_image",
47 "VK_LAYER_LUNARG_swapchain", "VK_LAYER_GOOGLE_unique_objects"};
48#endif
49
50 uint32_t count = 0;
51
52 if (physical_device == VK_NULL_HANDLE) {
53 if (VK_CALL_LOG_ERROR(vk.EnumerateInstanceLayerProperties(
54 &count, nullptr)) != VK_SUCCESS) {
55 return {};
56 }
57 } else {
58 if (VK_CALL_LOG_ERROR(vk.EnumerateDeviceLayerProperties(
59 physical_device, &count, nullptr)) != VK_SUCCESS) {
60 return {};
61 }
62 }
63
64 std::vector<VkLayerProperties> properties;
65 properties.resize(count);
66
67 if (physical_device == VK_NULL_HANDLE) {
68 if (VK_CALL_LOG_ERROR(vk.EnumerateInstanceLayerProperties(
69 &count, properties.data())) != VK_SUCCESS) {
70 return {};
71 }
72 } else {
73 if (VK_CALL_LOG_ERROR(vk.EnumerateDeviceLayerProperties(
74 physical_device, &count, properties.data())) != VK_SUCCESS) {
75 return {};
76 }
77 }
78
79 std::unordered_set<std::string> available_extensions;
80
81 for (size_t i = 0; i < count; i++) {
82 available_extensions.emplace(properties[i].layerName);
83 }
84
85 std::vector<std::string> available_candidates;
86
87 for (const auto& candidate : candidates) {
88 auto found = available_extensions.find(candidate);
89 if (found != available_extensions.end()) {
90 available_candidates.emplace_back(candidate);
91 }
92 }
93
94 return available_candidates;
95}
VK_CALL_LOG_ERROR
#define VK_CALL_LOG_ERROR(expression)
Definition vulkan_interface.h:37

References enable_validation_layers, i, physical_device, and VK_CALL_LOG_ERROR.

Referenced by DeviceLayersToEnable(), and InstanceLayersToEnable().

◆ 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 115 of file vulkan_debug_report.cc.

122 {
123 std::vector<std::pair<std::string, std::string>> items;
124
125 items.emplace_back("Severity", VkDebugReportFlagsEXTToString(flags));
126
127 items.emplace_back("Object Type",
128 VkDebugReportObjectTypeEXTToString(object_type));
129
130 items.emplace_back("Object Handle", std::to_string(object));
131
132 if (location != 0) {
133 items.emplace_back("Location", std::to_string(location));
134 }
135
136 if (message_code != 0) {
137 items.emplace_back("Message Code", std::to_string(message_code));
138 }
139
140 if (layer_prefix != nullptr) {
141 items.emplace_back("Layer", layer_prefix);
142 }
143
144 if (message != nullptr) {
145 items.emplace_back("Message", message);
146 }
147
148 size_t padding = 0;
149
150 for (const auto& item : items) {
151 padding = std::max(padding, item.first.size());
152 }
153
154 padding += 1;
155
156 std::stringstream stream;
157
158 stream << std::endl;
159
160 stream << "--- Vulkan Debug Report ----------------------------------------";
161
162 stream << std::endl;
163
164 for (const auto& item : items) {
165 stream << "| " << std::setw(static_cast<int>(padding)) << item.first
166 << std::setw(0) << ": " << item.second << std::endl;
167 }
168
169 stream << "-----------------------------------------------------------------";
170
171 if (flags & kVulkanErrorFlags) {
172 if (ValidationErrorsFatal()) {
173 FML_DCHECK(false) << stream.str();
174 } else {
175 FML_LOG(ERROR) << stream.str();
176 }
177 } else {
178 FML_LOG(INFO) << stream.str();
179 }
180
181 // Returning false tells the layer not to stop when the event occurs, so
182 // they see the same behavior with and without validation layers enabled.
183 return VK_FALSE;
184}
message
G_BEGIN_DECLS GBytes * message
Definition fl_mock_binary_messenger.h:24
FML_LOG
#define FML_LOG(severity)
Definition logging.h:101
FML_DCHECK
#define FML_DCHECK(condition)
Definition logging.h:122
padding
Vector2 padding
The halo padding in source space.
Definition gaussian_blur_filter_contents.cc:86
vulkan::ValidationErrorsFatal
bool ValidationErrorsFatal()
Definition vulkan_utilities.cc:20
vulkan::VkDebugReportFlagsEXTToString
static const char * VkDebugReportFlagsEXTToString(VkDebugReportFlagsEXT flags)
Definition vulkan_debug_report.cc:28
vulkan::VkDebugReportObjectTypeEXTToString
static const char * VkDebugReportObjectTypeEXTToString(VkDebugReportObjectTypeEXT type)
Definition vulkan_debug_report.cc:43

References FML_DCHECK, FML_LOG, kVulkanErrorFlags, message, padding, ValidationErrorsFatal(), VkDebugReportFlagsEXTToString(), and VkDebugReportObjectTypeEXTToString().

Referenced by vulkan::VulkanDebugReport::VulkanDebugReport().

◆ ValidationErrorsFatal()

bool vulkan::ValidationErrorsFatal ( )

Definition at line 20 of file vulkan_utilities.cc.

20 {
21#if OS_FUCHSIA
22 return false;
23#endif
24 return true;
25}

Referenced by OnVulkanDebugReportCallback().

◆ ValidationLayerInfoMessagesEnabled()

bool vulkan::ValidationLayerInfoMessagesEnabled ( )

Definition at line 16 of file vulkan_utilities.cc.

16 {
17 return false;
18}

Referenced by vulkan::VulkanDebugReport::VulkanDebugReport().

◆ VkDebugReportFlagsEXTToString()

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

Definition at line 28 of file vulkan_debug_report.cc.

28 {
29 if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
30 return "Information";
31 } else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
32 return "Warning";
33 } else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
34 return "Performance Warning";
35 } else if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
36 return "Error";
37 } else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
38 return "Debug";
39 }
40 return "UNKNOWN";
41}

Referenced by OnVulkanDebugReportCallback().

◆ VkDebugReportObjectTypeEXTToString()

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

Definition at line 43 of file vulkan_debug_report.cc.

44 {
45 switch (type) {
46 case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
47 return "Unknown";
48 case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:
49 return "Instance";
50 case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:
51 return "Physical Device";
52 case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:
53 return "Device";
54 case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:
55 return "Queue";
56 case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:
57 return "Semaphore";
58 case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:
59 return "Command Buffer";
60 case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:
61 return "Fence";
62 case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:
63 return "Device Memory";
64 case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:
65 return "Buffer";
66 case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:
67 return "Image";
68 case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:
69 return "Event";
70 case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:
71 return "Query Pool";
72 case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:
73 return "Buffer View";
74 case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:
75 return "Image_view";
76 case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:
77 return "Shader Module";
78 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:
79 return "Pipeline Cache";
80 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:
81 return "Pipeline Layout";
82 case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:
83 return "Render Pass";
84 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:
85 return "Pipeline";
86 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:
87 return "Descriptor Set Layout";
88 case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:
89 return "Sampler";
90 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:
91 return "Descriptor Pool";
92 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:
93 return "Descriptor Set";
94 case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:
95 return "Framebuffer";
96 case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:
97 return "Command Pool";
98 case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:
99 return "Surface";
100 case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:
101 return "Swapchain";
102 case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT:
103 return "Debug";
104 default:
105 break;
106 }
107
108 return "Unknown";
109}
type
GLenum type
Definition blit_command_gles.cc:153

References type.

Referenced by OnVulkanDebugReportCallback().

◆ VulkanResultToString()

std::string vulkan::VulkanResultToString ( VkResult  result)

Definition at line 9 of file vulkan_interface.cc.

9 {
10 switch (result) {
11 case VK_SUCCESS:
12 return "VK_SUCCESS";
13 case VK_NOT_READY:
14 return "VK_NOT_READY";
15 case VK_TIMEOUT:
16 return "VK_TIMEOUT";
17 case VK_EVENT_SET:
18 return "VK_EVENT_SET";
19 case VK_EVENT_RESET:
20 return "VK_EVENT_RESET";
21 case VK_INCOMPLETE:
22 return "VK_INCOMPLETE";
23 case VK_ERROR_OUT_OF_HOST_MEMORY:
24 return "VK_ERROR_OUT_OF_HOST_MEMORY";
25 case VK_ERROR_OUT_OF_DEVICE_MEMORY:
26 return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
27 case VK_ERROR_INITIALIZATION_FAILED:
28 return "VK_ERROR_INITIALIZATION_FAILED";
29 case VK_ERROR_DEVICE_LOST:
30 return "VK_ERROR_DEVICE_LOST";
31 case VK_ERROR_MEMORY_MAP_FAILED:
32 return "VK_ERROR_MEMORY_MAP_FAILED";
33 case VK_ERROR_LAYER_NOT_PRESENT:
34 return "VK_ERROR_LAYER_NOT_PRESENT";
35 case VK_ERROR_EXTENSION_NOT_PRESENT:
36 return "VK_ERROR_EXTENSION_NOT_PRESENT";
37 case VK_ERROR_FEATURE_NOT_PRESENT:
38 return "VK_ERROR_FEATURE_NOT_PRESENT";
39 case VK_ERROR_INCOMPATIBLE_DRIVER:
40 return "VK_ERROR_INCOMPATIBLE_DRIVER";
41 case VK_ERROR_TOO_MANY_OBJECTS:
42 return "VK_ERROR_TOO_MANY_OBJECTS";
43 case VK_ERROR_FORMAT_NOT_SUPPORTED:
44 return "VK_ERROR_FORMAT_NOT_SUPPORTED";
45 case VK_ERROR_FRAGMENTED_POOL:
46 return "VK_ERROR_FRAGMENTED_POOL";
47 case VK_ERROR_SURFACE_LOST_KHR:
48 return "VK_ERROR_SURFACE_LOST_KHR";
49 case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
50 return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
51 case VK_SUBOPTIMAL_KHR:
52 return "VK_SUBOPTIMAL_KHR";
53 case VK_ERROR_OUT_OF_DATE_KHR:
54 return "VK_ERROR_OUT_OF_DATE_KHR";
55 case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
56 return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
57 case VK_ERROR_VALIDATION_FAILED_EXT:
58 return "VK_ERROR_VALIDATION_FAILED_EXT";
59 case VK_ERROR_INVALID_SHADER_NV:
60 return "VK_ERROR_INVALID_SHADER_NV";
61#if VK_HEADER_VERSION < 140
62 case VK_RESULT_RANGE_SIZE:
63 return "VK_RESULT_RANGE_SIZE";
64#endif
65 case VK_RESULT_MAX_ENUM:
66 return "VK_RESULT_MAX_ENUM";
67 case VK_ERROR_INVALID_EXTERNAL_HANDLE:
68 return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
69 case VK_ERROR_OUT_OF_POOL_MEMORY:
70 return "VK_ERROR_OUT_OF_POOL_MEMORY";
71 default:
72 return "Unknown Error";
73 }
74 return "";
75}

Variable Documentation

◆ kGrCacheMaxByteSize

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

Definition at line 18 of file vulkan_application.h.

Referenced by flutter::testing::TEST_F().

◆ kVulkanErrorFlags

const VkDebugReportFlagsEXT vulkan::kVulkanErrorFlags
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.

Referenced by OnVulkanDebugReportCallback(), and vulkan::VulkanDebugReport::VulkanDebugReport().

◆ kVulkanInfoFlags

const VkDebugReportFlagsEXT vulkan::kVulkanInfoFlags
static
Initial value:
=
VK_DEBUG_REPORT_INFORMATION_BIT_EXT | VK_DEBUG_REPORT_DEBUG_BIT_EXT

Definition at line 21 of file vulkan_debug_report.cc.

Referenced by vulkan::VulkanDebugReport::VulkanDebugReport().

◆ kVulkanInvalidGraphicsQueueIndex

constexpr auto vulkan::kVulkanInvalidGraphicsQueueIndex
constexpr
Initial value:
=
std::numeric_limits<uint32_t>::max()

Definition at line 17 of file vulkan_device.cc.

Referenced by FindGraphicsQueueIndex(), and vulkan::VulkanDevice::VulkanDevice().