| Flutter Impeller |

Public Member Functions | List of all members
impeller::CapabilitiesVK Class Referencefinal

The Vulkan layers and extensions wrangler. More...

`#include <capabilities_vk.h>`

Inheritance diagram for impeller::CapabilitiesVK:

## Public Member Functions
| CapabilitiesVK (bool enable_validations)
| ~CapabilitiesVK ()
bool | IsValid () const
bool | AreValidationsEnabled () const
bool | HasOptionalDeviceExtension (OptionalDeviceExtensionVK extension) const
std::optional< std::vector< std::string > > | GetEnabledLayers () const
std::optional< std::vector< std::string > > | GetEnabledInstanceExtensions () const
std::optional< std::vector< std::string > > | GetEnabledDeviceExtensions (const vk::PhysicalDevice &physical_device) const
std::optional< vk::PhysicalDeviceFeatures > | GetEnabledDeviceFeatures (const vk::PhysicalDevice &physical_device) const
bool | SetPhysicalDevice (const vk::PhysicalDevice &physical_device)
const vk::PhysicalDeviceProperties & | GetPhysicalDeviceProperties () const
void | SetOffscreenFormat (PixelFormat pixel_format) const
bool | SupportsOffscreenMSAA () const override
| Whether the context backend supports attaching offscreen MSAA color/stencil textures. More...
bool | SupportsImplicitResolvingMSAA () const override
| Whether the context backend supports multisampled rendering to the on-screen surface without requiring an explicit resolve of the MSAA color attachment. More...
bool | SupportsSSBO () const override
| Whether the context backend supports binding Shader Storage Buffer Objects (SSBOs) to pipelines. More...
bool | SupportsBufferToTextureBlits () const override
| Whether the context backend supports blitting from a given `DeviceBuffer` view to a texture region (via the relevant `BlitPass::AddCopy` overloads). More...
bool | SupportsTextureToTextureBlits () const override
| Whether the context backend supports blitting from one texture region to another texture region (via the relevant `BlitPass::AddCopy` overloads). More...
bool | SupportsFramebufferFetch () const override
| Whether the context backend is able to support pipelines with shaders that read from the framebuffer (i.e. pixels that have been written by previous draw calls in the current render pass). More...
bool | SupportsCompute () const override
| Whether the context backend supports `ComputePass`. More...
bool | SupportsComputeSubgroups () const override
| Whether the context backend supports configuring `ComputePass` command subgroups. More...
bool | SupportsReadFromResolve () const override
| Whether the context backend supports binding the current `RenderPass` attachments. This is supported if the backend can guarantee that attachment textures will not be mutated until the render pass has fully completed. More...
bool | SupportsDecalSamplerAddressMode () const override
| Whether the context backend supports `SamplerAddressMode::Decal`. More...
bool | SupportsDeviceTransientTextures () const override
| Whether the context backend supports allocating `StorageMode::kDeviceTransient` (aka "memoryless") textures, which are temporary textures kept in tile memory for the duration of the `RenderPass` it's attached to. More...
PixelFormat | GetDefaultColorFormat () const override
| Returns a supported `PixelFormat` for textures that store 4-channel colors (red/green/blue/alpha). More...
PixelFormat | GetDefaultStencilFormat () const override
| Returns a supported `PixelFormat` for textures that store stencil information. May include a depth channel if a stencil-only format is not available. More...
PixelFormat | GetDefaultDepthStencilFormat () const override
| Returns a supported `PixelFormat` for textures that store both a stencil and depth component. This will never return a depth-only or stencil-only texture. Returns `PixelFormat::kUnknown` if no suitable depth+stencil format was found. More...
Public Member Functions inherited from impeller::Capabilities
virtual | ~Capabilities ()

## Additional Inherited Members
Static Public Member Functions inherited from impeller::BackendCast< CapabilitiesVK, Capabilities >
static CapabilitiesVK & | Cast (Capabilities &base)
static const CapabilitiesVK & | Cast (const Capabilities &base)
static CapabilitiesVK * | Cast (Capabilities *base)
static const CapabilitiesVK * | Cast (const Capabilities *base)
Protected Member Functions inherited from impeller::Capabilities
| Capabilities ()
| Capabilities (const Capabilities &)=delete
Capabilities & | operator= (const Capabilities &)=delete

## Detailed Description

The Vulkan layers and extensions wrangler.

Definition at line 33 of file capabilities_vk.h.

## Constructor & Destructor Documentation

## ◆ CapabilitiesVK()

impeller::CapabilitiesVK::CapabilitiesVK | ( | bool | enable_validations | ) |
| explicit

Definition at line 18 of file capabilities_vk.cc.

18 {
19 auto extensions = vk::enumerateInstanceExtensionProperties();
20 auto layers = vk::enumerateInstanceLayerProperties();
21
22 if (extensions.result != vk::Result::eSuccess ||
23 layers.result != vk::Result::eSuccess) {
24 return;
25 }
26
27 for (const auto& ext : extensions.value) {
28 exts_[kInstanceLayer].insert(ext.extensionName);
29 }
30
31 for (const auto& layer : layers.value) {
32 const std::string layer_name = layer.layerName;
33 auto layer_exts = vk::enumerateInstanceExtensionProperties(layer_name);
34 if (layer_exts.result != vk::Result::eSuccess) {
35 return;
36 }
37 for (const auto& layer_ext : layer_exts.value) {
38 exts_[layer_name].insert(layer_ext.extensionName);
39 }
40 }
41
42 validations_enabled_ =
43 enable_validations && HasLayer("VK_LAYER_KHRONOS_validation");
44 if (enable_validations && !validations_enabled_) {
45 FML_LOG(ERROR)
46 << "Requested Impeller context creation with validations but the "
47 "validation layers could not be found. Expect no Vulkan validation "
48 "checks!";
49 }
50 if (validations_enabled_) {
51 FML_LOG(INFO) << "Vulkan validations are enabled.";
52 }
53 is_valid_ = true;
54 }

References impeller::kInstanceLayer.

## ◆ ~CapabilitiesVK()

impeller::CapabilitiesVK::~CapabilitiesVK | ( |  | ) |
| default

## Member Function Documentation

## ◆ AreValidationsEnabled()

bool impeller::CapabilitiesVK::AreValidationsEnabled | ( |  | ) | const

Definition at line 62 of file capabilities_vk.cc.

62 {
63 return validations_enabled_;
64 }

Referenced by impeller::DebugReportVK::DebugReportVK(), and impeller::testing::TEST().

## ◆ GetDefaultColorFormat()

PixelFormat impeller::CapabilitiesVK::GetDefaultColorFormat | ( |  | ) | const
| override virtual

Returns a supported `PixelFormat` for textures that store 4-channel colors (red/green/blue/alpha).

Implements impeller::Capabilities.

Definition at line 481 of file capabilities_vk.cc.

481 {
482 return default_color_format_;
483 }

## ◆ GetDefaultDepthStencilFormat()

PixelFormat impeller::CapabilitiesVK::GetDefaultDepthStencilFormat | ( |  | ) | const
| override virtual

Returns a supported `PixelFormat` for textures that store both a stencil and depth component. This will never return a depth-only or stencil-only texture. Returns `PixelFormat::kUnknown` if no suitable depth+stencil format was found.

Implements impeller::Capabilities.

Definition at line 491 of file capabilities_vk.cc.

491 {
492 return default_depth_stencil_format_;
493 }

## ◆ GetDefaultStencilFormat()

PixelFormat impeller::CapabilitiesVK::GetDefaultStencilFormat | ( |  | ) | const
| override virtual

Returns a supported `PixelFormat` for textures that store stencil information. May include a depth channel if a stencil-only format is not available.

Implements impeller::Capabilities.

Definition at line 486 of file capabilities_vk.cc.

486 {
487 return default_stencil_format_;
488 }

## ◆ GetEnabledDeviceExtensions()

std::optional< std::vector< std::string > > impeller::CapabilitiesVK::GetEnabledDeviceExtensions | ( | const vk::PhysicalDevice & | physical_device | ) | const

Definition at line 197 of file capabilities_vk.cc.

198 {
199 auto exts = GetSupportedDeviceExtensions(physical_device);
200
201 if (!exts.has_value()) {
202 return std::nullopt;
203 }
204
205 std::vector<std::string> enabled;
206
207 if (exts->find("VK_KHR_swapchain") == exts->end()) {
208 VALIDATION_LOG << "Device does not support the swapchain extension.";
209 return std::nullopt;
210 }
211 enabled.push_back("VK_KHR_swapchain");
212
213 // Required for non-conformant implementations like MoltenVK.
214 if (exts->find("VK_KHR_portability_subset") != exts->end()) {
215 enabled.push_back("VK_KHR_portability_subset");
216 }
217
218 #ifdef FML_OS_ANDROID
219 if (exts->find("VK_ANDROID_external_memory_android_hardware_buffer") ==
220 exts->end()) {
221 VALIDATION_LOG
222 << "Device does not support "
223 "VK_ANDROID_external_memory_android_hardware_buffer extension.";
224 return std::nullopt;
225 }
226 enabled.push_back("VK_ANDROID_external_memory_android_hardware_buffer");
227 enabled.push_back("VK_EXT_queue_family_foreign");
228 #endif
229
230 // Enable all optional extensions if the device supports it.
231 IterateOptionalDeviceExtensions([&](auto ext) {
232 auto ext_name = GetDeviceExtensionName(ext);
233 if (exts->find(ext_name) != exts->end()) {
234 enabled.push_back(ext_name);
235 }
236 });
237
238 return enabled;
239 }

References impeller::GetDeviceExtensionName(), impeller::GetSupportedDeviceExtensions(), impeller::IterateOptionalDeviceExtensions(), and VALIDATION_LOG.

Referenced by GetEnabledDeviceFeatures().

## ◆ GetEnabledDeviceFeatures()

std::optional< vk::PhysicalDeviceFeatures > impeller::CapabilitiesVK::GetEnabledDeviceFeatures | ( | const vk::PhysicalDevice & | physical_device | ) | const

Definition at line 291 of file capabilities_vk.cc.

292 {
293 if (!PhysicalDeviceSupportsRequiredFormats(device)) {
294 VALIDATION_LOG << "Device doesn't support the required formats.";
295 return std::nullopt;
296 }
297
298 if (!HasRequiredProperties(device)) {
299 VALIDATION_LOG << "Device doesn't support the required properties.";
300 return std::nullopt;
301 }
302
303 if (!HasRequiredQueues(device)) {
304 VALIDATION_LOG << "Device doesn't support the required queues.";
305 return std::nullopt;
306 }
307
308 if (!GetEnabledDeviceExtensions(device).has_value()) {
309 VALIDATION_LOG << "Device doesn't support the required queues.";
310 return std::nullopt;
311 }
312
313 const auto device_features = device.getFeatures();
314
315 vk::PhysicalDeviceFeatures required;
316
317 // We require this for enabling wireframes in the playground. But its not
318 // necessarily a big deal if we don't have this feature.
319 required.fillModeNonSolid = device_features.fillModeNonSolid;
320
321 return required;
322 }

References GetEnabledDeviceExtensions(), impeller::HasRequiredProperties(), impeller::HasRequiredQueues(), impeller::PhysicalDeviceSupportsRequiredFormats(), and VALIDATION_LOG.

Referenced by impeller::PickPhysicalDevice().

## ◆ GetEnabledInstanceExtensions()

std::optional< std::vector< std::string > > impeller::CapabilitiesVK::GetEnabledInstanceExtensions | ( |  | ) | const

Definition at line 79 of file capabilities_vk.cc.

79 {
80 std::vector<std::string> required;
81
82 if (!HasExtension("VK_KHR_surface")) {
83 // Swapchain support is required and this is a dependency of
84 // VK_KHR_swapchain.
85 VALIDATION_LOG << "Could not find the surface extension.";
86 return std::nullopt;
87 }
88 required.push_back("VK_KHR_surface");
89
90 auto has_wsi = false;
91 if (HasExtension("VK_MVK_macos_surface")) {
92 required.push_back("VK_MVK_macos_surface");
93 has_wsi = true;
94 }
95
96 if (HasExtension("VK_EXT_metal_surface")) {
97 required.push_back("VK_EXT_metal_surface");
98 has_wsi = true;
99 }
100
101 if (HasExtension("VK_KHR_portability_enumeration")) {
102 required.push_back("VK_KHR_portability_enumeration");
103 has_wsi = true;
104 }
105
106 if (HasExtension("VK_KHR_win32_surface")) {
107 required.push_back("VK_KHR_win32_surface");
108 has_wsi = true;
109 }
110
111 if (HasExtension("VK_KHR_android_surface")) {
112 required.push_back("VK_KHR_android_surface");
113 has_wsi = true;
114 }
115
116 if (HasExtension("VK_KHR_xcb_surface")) {
117 required.push_back("VK_KHR_xcb_surface");
118 has_wsi = true;
119 }
120
121 if (HasExtension("VK_KHR_xlib_surface")) {
122 required.push_back("VK_KHR_xlib_surface");
123 has_wsi = true;
124 }
125
126 if (HasExtension("VK_KHR_wayland_surface")) {
127 required.push_back("VK_KHR_wayland_surface");
128 has_wsi = true;
129 }
130
131 if (!has_wsi) {
132 // Don't really care which WSI extension there is as long there is at least
133 // one.
134 VALIDATION_LOG << "Could not find a WSI extension.";
135 return std::nullopt;
136 }
137
138 if (validations_enabled_) {
139 if (!HasExtension("VK_EXT_debug_utils")) {
140 VALIDATION_LOG << "Requested validations but could not find the "
141 "VK_EXT_debug_utils extension.";
142 return std::nullopt;
143 }
144 required.push_back("VK_EXT_debug_utils");
145
146 if (HasExtension("VK_EXT_validation_features")) {
147 // It's valid to not have `VK_EXT_validation_features` available. That's
148 // the case when using AGI as a frame debugger.
149 required.push_back("VK_EXT_validation_features");
150 }
151 }
152
153 return required;
154 }

References VALIDATION_LOG.

## ◆ GetEnabledLayers()

std::optional< std::vector< std::string > > impeller::CapabilitiesVK::GetEnabledLayers | ( |  | ) | const

Definition at line 66 of file capabilities_vk.cc.

67 {
68 std::vector<std::string> required;
69
70 if (validations_enabled_) {
71 // The presence of this layer is already checked in the ctor.
72 required.push_back("VK_LAYER_KHRONOS_validation");
73 }
74
75 return required;
76 }

## ◆ GetPhysicalDeviceProperties()

const vk::PhysicalDeviceProperties & impeller::CapabilitiesVK::GetPhysicalDeviceProperties | ( |  | ) | const

Definition at line 496 of file capabilities_vk.cc.

496 {
497 return device_properties_;
498 }

## ◆ HasOptionalDeviceExtension()

bool impeller::CapabilitiesVK::HasOptionalDeviceExtension | ( | OptionalDeviceExtensionVK | extension | ) | const

Definition at line 500 of file capabilities_vk.cc.

501 {
502 return optional_device_extensions_.find(extension) !=
503 optional_device_extensions_.end();
504 }

## ◆ IsValid()

bool impeller::CapabilitiesVK::IsValid | ( |  | ) | const

Definition at line 58 of file capabilities_vk.cc.

58 {
59 return is_valid_;
60 }

## ◆ SetOffscreenFormat()

void impeller::CapabilitiesVK::SetOffscreenFormat | ( | PixelFormat | pixel_format | ) | const

Definition at line 342 of file capabilities_vk.cc.

342 {
343 default_color_format_ = pixel_format;
344 }

Referenced by impeller::ContextVK::SetOffscreenFormat().

## ◆ SetPhysicalDevice()

bool impeller::CapabilitiesVK::SetPhysicalDevice | ( | const vk::PhysicalDevice & | physical_device | ) |

Definition at line 346 of file capabilities_vk.cc.

346 {
347 if (HasSuitableDepthStencilFormat(device, vk::Format::eD32SfloatS8Uint)) {
348 default_depth_stencil_format_ = PixelFormat::kD32FloatS8UInt;
349 } else if (HasSuitableDepthStencilFormat(device,
350 vk::Format::eD24UnormS8Uint)) {
351 default_depth_stencil_format_ = PixelFormat::kD24UnormS8Uint;
352 } else {
353 default_depth_stencil_format_ = PixelFormat::kUnknown;
354 }
355
356 if (HasSuitableDepthStencilFormat(device, vk::Format::eS8Uint)) {
357 default_stencil_format_ = PixelFormat::kS8UInt;
358 } else if (default_stencil_format_ != PixelFormat::kUnknown) {
359 default_stencil_format_ = default_depth_stencil_format_;
360 } else {
361 return false;
362 }
363
364 device_properties_ = device.getProperties();
365
366 auto physical_properties_2 =
367 device.getProperties2<vk::PhysicalDeviceProperties2,
368 vk::PhysicalDeviceSubgroupProperties>();
369
370 // Currently shaders only want access to arithmetic subgroup features.
371 // If that changes this needs to get updated, and so does Metal (which right
372 // now assumes it from compile time flags based on the MSL target version).
373
374 supports_compute_subgroups_ =
375 !!(physical_properties_2.get<vk::PhysicalDeviceSubgroupProperties>()
376 .supportedOperations &
377 vk::SubgroupFeatureFlagBits::eArithmetic);
378
379 {
380 // Query texture support.
381 // TODO(jonahwilliams):
382 // https://github.com/flutter/flutter/issues/129784
383 vk::PhysicalDeviceMemoryProperties memory_properties;
384 device.getMemoryProperties(&memory_properties);
385
386 for (auto i = 0u; i < memory_properties.memoryTypeCount; i++) {
387 if (memory_properties.memoryTypes[i].propertyFlags &
388 vk::MemoryPropertyFlagBits::eLazilyAllocated) {
389 supports_device_transient_textures_ = true;
390 }
391 }
392 }
393
394 // Determine the optional device extensions this physical device supports.
395 {
396 optional_device_extensions_.clear();
397 auto exts = GetSupportedDeviceExtensions(device);
398 if (!exts.has_value()) {
399 return false;
400 }
401 IterateOptionalDeviceExtensions([&](auto ext) {
402 auto ext_name = GetDeviceExtensionName(ext);
403 if (exts->find(ext_name) != exts->end()) {
404 optional_device_extensions_.insert(ext);
405 }
406 });
407 }
408
409 {
410 supports_framebuffer_fetch_ =
411 (optional_device_extensions_.find(
412 OptionalDeviceExtensionVK::
413 kARMRasterizationOrderAttachmentAccess) !=
414 optional_device_extensions_.end() ||
415 optional_device_extensions_.find(
416 OptionalDeviceExtensionVK::
417 kEXTRasterizationOrderAttachmentAccess) !=
418 optional_device_extensions_.end());
419 }
420
421 return true;
422 }

References impeller::GetDeviceExtensionName(), impeller::GetSupportedDeviceExtensions(), impeller::HasSuitableDepthStencilFormat(), impeller::IterateOptionalDeviceExtensions(), impeller::kARMRasterizationOrderAttachmentAccess, impeller::kD24UnormS8Uint, impeller::kD32FloatS8UInt, impeller::kEXTRasterizationOrderAttachmentAccess, impeller::kS8UInt, and impeller::kUnknown.

## ◆ SupportsBufferToTextureBlits()

bool impeller::CapabilitiesVK::SupportsBufferToTextureBlits | ( |  | ) | const
| override virtual

Whether the context backend supports blitting from a given `DeviceBuffer` view to a texture region (via the relevant `BlitPass::AddCopy` overloads).

Implements impeller::Capabilities.

Definition at line 440 of file capabilities_vk.cc.

440 {
441 return true;
442 }

## ◆ SupportsCompute()

bool impeller::CapabilitiesVK::SupportsCompute | ( |  | ) | const
| override virtual

Whether the context backend supports `ComputePass`.

Implements impeller::Capabilities.

Definition at line 455 of file capabilities_vk.cc.

455 {
456 // Vulkan 1.1 requires support for compute.
457 return true;
458 }

## ◆ SupportsComputeSubgroups()

bool impeller::CapabilitiesVK::SupportsComputeSubgroups | ( |  | ) | const
| override virtual

Whether the context backend supports configuring `ComputePass` command subgroups.

Implements impeller::Capabilities.

Definition at line 461 of file capabilities_vk.cc.

461 {
462 // Set by |SetPhysicalDevice|.
463 return supports_compute_subgroups_;
464 }

## ◆ SupportsDecalSamplerAddressMode()

bool impeller::CapabilitiesVK::SupportsDecalSamplerAddressMode | ( |  | ) | const
| override virtual

Whether the context backend supports `SamplerAddressMode::Decal`.

Implements impeller::Capabilities.

Definition at line 471 of file capabilities_vk.cc.

471 {
472 return true;
473 }

## ◆ SupportsDeviceTransientTextures()

bool impeller::CapabilitiesVK::SupportsDeviceTransientTextures | ( |  | ) | const
| override virtual

Whether the context backend supports allocating `StorageMode::kDeviceTransient` (aka "memoryless") textures, which are temporary textures kept in tile memory for the duration of the `RenderPass` it's attached to.

This feature is especially useful for MSAA and stencils.

Implements impeller::Capabilities.

Definition at line 476 of file capabilities_vk.cc.

476 {
477 return supports_device_transient_textures_;
478 }

## ◆ SupportsFramebufferFetch()

bool impeller::CapabilitiesVK::SupportsFramebufferFetch | ( |  | ) | const
| override virtual

Whether the context backend is able to support pipelines with shaders that read from the framebuffer (i.e. pixels that have been written by previous draw calls in the current render pass).

Example of reading from the first color attachment in a GLSL shader: ``` uniform subpassInput subpass_input;

out vec4 frag_color;

void main() { vec4 color = subpassLoad(subpass_input); // Invert the colors drawn to the framebuffer. frag_color = vec4(vec3(1) - color.rgb, color.a); } ```

Implements impeller::Capabilities.

Definition at line 450 of file capabilities_vk.cc.

450 {
451 return supports_framebuffer_fetch_;
452 }

## ◆ SupportsImplicitResolvingMSAA()

bool impeller::CapabilitiesVK::SupportsImplicitResolvingMSAA | ( |  | ) | const
| override virtual

Whether the context backend supports multisampled rendering to the on-screen surface without requiring an explicit resolve of the MSAA color attachment.

Implements impeller::Capabilities.

Definition at line 430 of file capabilities_vk.cc.

430 {
431 return false;
432 }

## ◆ SupportsOffscreenMSAA()

bool impeller::CapabilitiesVK::SupportsOffscreenMSAA | ( |  | ) | const
| override virtual

Whether the context backend supports attaching offscreen MSAA color/stencil textures.

Implements impeller::Capabilities.

Definition at line 425 of file capabilities_vk.cc.

425 {
426 return true;
427 }

## ◆ SupportsReadFromResolve()

bool impeller::CapabilitiesVK::SupportsReadFromResolve | ( |  | ) | const
| override virtual

Whether the context backend supports binding the current `RenderPass` attachments. This is supported if the backend can guarantee that attachment textures will not be mutated until the render pass has fully completed.

This is possible because many mobile graphics cards track `RenderPass` attachment state in intermediary tile memory prior to Storing the pass in the heap allocated attachments on DRAM. Metal's hazard tracking and Vulkan's barriers are granular enough to allow for safely accessing attachment textures prior to storage in the same `RenderPass`.

Implements impeller::Capabilities.

Definition at line 467 of file capabilities_vk.cc.

467 {
468 return false;
469 }

## ◆ SupportsSSBO()

bool impeller::CapabilitiesVK::SupportsSSBO | ( |  | ) | const
| override virtual

Whether the context backend supports binding Shader Storage Buffer Objects (SSBOs) to pipelines.

Implements impeller::Capabilities.

Definition at line 435 of file capabilities_vk.cc.

435 {
436 return true;
437 }

## ◆ SupportsTextureToTextureBlits()

bool impeller::CapabilitiesVK::SupportsTextureToTextureBlits | ( |  | ) | const
| override virtual

Whether the context backend supports blitting from one texture region to another texture region (via the relevant `BlitPass::AddCopy` overloads).

Implements impeller::Capabilities.

Definition at line 445 of file capabilities_vk.cc.

445 {
446 return true;
447 }

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

- impeller/renderer/backend/vulkan/capabilities_vk.h
- impeller/renderer/backend/vulkan/capabilities_vk.cc

impeller::OptionalDeviceExtensionVK
OptionalDeviceExtensionVK
Definition: capabilities_vk.h:22
impeller::HasRequiredProperties
static bool HasRequiredProperties(const vk::PhysicalDevice &physical_device)
Definition: capabilities_vk.cc:267
impeller::PixelFormat::kS8UInt
@ kS8UInt
impeller::kInstanceLayer
static constexpr const char * kInstanceLayer
Definition: capabilities_vk.cc:16
impeller::HasSuitableDepthStencilFormat
static bool HasSuitableDepthStencilFormat(const vk::PhysicalDevice &device, vk::Format format)
Definition: capabilities_vk.cc:249
impeller::HasRequiredQueues
static bool HasRequiredQueues(const vk::PhysicalDevice &physical_device)
Definition: capabilities_vk.cc:276
impeller::IterateOptionalDeviceExtensions
static void IterateOptionalDeviceExtensions(const std::function< void(OptionalDeviceExtensionVK)> &it)
Definition: capabilities_vk.cc:170
impeller::PixelFormat::kD32FloatS8UInt
@ kD32FloatS8UInt
impeller::PhysicalDeviceSupportsRequiredFormats
static bool PhysicalDeviceSupportsRequiredFormats(const vk::PhysicalDevice &device)
Definition: capabilities_vk.cc:256
impeller::GetSupportedDeviceExtensions
static std::optional< std::set< std::string > > GetSupportedDeviceExtensions(const vk::PhysicalDevice &physical_device)
Definition: capabilities_vk.cc:181
impeller::PixelFormat::kD24UnormS8Uint
@ kD24UnormS8Uint
impeller::GetDeviceExtensionName
static const char * GetDeviceExtensionName(OptionalDeviceExtensionVK ext)
Definition: capabilities_vk.cc:156
impeller::PixelFormat::kUnknown
@ kUnknown
VALIDATION_LOG
#define VALIDATION_LOG
Definition: validation.h:67
impeller::CapabilitiesVK::GetEnabledDeviceExtensions
std::optional< std::vector< std::string > > GetEnabledDeviceExtensions(const vk::PhysicalDevice &physical_device) const
Definition: capabilities_vk.cc:197