impeller::CapabilitiesVK Class Reference

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.

                                                      {
  auto extensions = vk::enumerateInstanceExtensionProperties();
  auto layers = vk::enumerateInstanceLayerProperties();
 
  if (extensions.result != vk::Result::eSuccess ||
      layers.result != vk::Result::eSuccess) {
    return;
  }
 
  for (const auto& ext : extensions.value) {
    exts_[kInstanceLayer].insert(ext.extensionName);
  }
 
  for (const auto& layer : layers.value) {
    const std::string layer_name = layer.layerName;
    auto layer_exts = vk::enumerateInstanceExtensionProperties(layer_name);
    if (layer_exts.result != vk::Result::eSuccess) {
      return;
    }
    for (const auto& layer_ext : layer_exts.value) {
      exts_[layer_name].insert(layer_ext.extensionName);
    }
  }
 
  validations_enabled_ =
      enable_validations && HasLayer("VK_LAYER_KHRONOS_validation");
  if (enable_validations && !validations_enabled_) {
    FML_LOG(ERROR)
        << "Requested Impeller context creation with validations but the "
           "validation layers could not be found. Expect no Vulkan validation "
           "checks!";
  }
  if (validations_enabled_) {
    FML_LOG(INFO) << "Vulkan validations are enabled.";
  }
  is_valid_ = true;
}

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.

                                                 {
  return validations_enabled_;
}

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

GetDefaultColorFormat()

PixelFormat impeller::CapabilitiesVK::GetDefaultColorFormat ( ) const

overridevirtual

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.

                                                        {
  return default_color_format_;
}

GetDefaultDepthStencilFormat()

PixelFormat impeller::CapabilitiesVK::GetDefaultDepthStencilFormat ( ) const

overridevirtual

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.

                                                               {
  return default_depth_stencil_format_;
}

GetDefaultStencilFormat()

PixelFormat impeller::CapabilitiesVK::GetDefaultStencilFormat ( ) const

overridevirtual

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.

                                                          {
  return default_stencil_format_;
}

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.

                                                   {
  auto exts = GetSupportedDeviceExtensions(physical_device);
 
  if (!exts.has_value()) {
    return std::nullopt;
  }
 
  std::vector<std::string> enabled;
 
  if (exts->find("VK_KHR_swapchain") == exts->end()) {
    VALIDATION_LOG << "Device does not support the swapchain extension.";
    return std::nullopt;
  }
  enabled.push_back("VK_KHR_swapchain");
 
  // Required for non-conformant implementations like MoltenVK.
  if (exts->find("VK_KHR_portability_subset") != exts->end()) {
    enabled.push_back("VK_KHR_portability_subset");
  }
 
#ifdef FML_OS_ANDROID
  if (exts->find("VK_ANDROID_external_memory_android_hardware_buffer") ==
      exts->end()) {
    VALIDATION_LOG
        << "Device does not support "
           "VK_ANDROID_external_memory_android_hardware_buffer extension.";
    return std::nullopt;
  }
  enabled.push_back("VK_ANDROID_external_memory_android_hardware_buffer");
  enabled.push_back("VK_EXT_queue_family_foreign");
#endif
 
  // Enable all optional extensions if the device supports it.
  IterateOptionalDeviceExtensions([&](auto ext) {
    auto ext_name = GetDeviceExtensionName(ext);
    if (exts->find(ext_name) != exts->end()) {
      enabled.push_back(ext_name);
    }
  });
 
  return enabled;
}

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.

                                          {
  if (!PhysicalDeviceSupportsRequiredFormats(device)) {
    VALIDATION_LOG << "Device doesn't support the required formats.";
    return std::nullopt;
  }
 
  if (!HasRequiredProperties(device)) {
    VALIDATION_LOG << "Device doesn't support the required properties.";
    return std::nullopt;
  }
 
  if (!HasRequiredQueues(device)) {
    VALIDATION_LOG << "Device doesn't support the required queues.";
    return std::nullopt;
  }
 
  if (!GetEnabledDeviceExtensions(device).has_value()) {
    VALIDATION_LOG << "Device doesn't support the required queues.";
    return std::nullopt;
  }
 
  const auto device_features = device.getFeatures();
 
  vk::PhysicalDeviceFeatures required;
 
  // We require this for enabling wireframes in the playground. But its not
  // necessarily a big deal if we don't have this feature.
  required.fillModeNonSolid = device_features.fillModeNonSolid;
 
  return required;
}

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.

                                                   {
  std::vector<std::string> required;
 
  if (!HasExtension("VK_KHR_surface")) {
    // Swapchain support is required and this is a dependency of
    // VK_KHR_swapchain.
    VALIDATION_LOG << "Could not find the surface extension.";
    return std::nullopt;
  }
  required.push_back("VK_KHR_surface");
 
  auto has_wsi = false;
  if (HasExtension("VK_MVK_macos_surface")) {
    required.push_back("VK_MVK_macos_surface");
    has_wsi = true;
  }
 
  if (HasExtension("VK_EXT_metal_surface")) {
    required.push_back("VK_EXT_metal_surface");
    has_wsi = true;
  }
 
  if (HasExtension("VK_KHR_portability_enumeration")) {
    required.push_back("VK_KHR_portability_enumeration");
    has_wsi = true;
  }
 
  if (HasExtension("VK_KHR_win32_surface")) {
    required.push_back("VK_KHR_win32_surface");
    has_wsi = true;
  }
 
  if (HasExtension("VK_KHR_android_surface")) {
    required.push_back("VK_KHR_android_surface");
    has_wsi = true;
  }
 
  if (HasExtension("VK_KHR_xcb_surface")) {
    required.push_back("VK_KHR_xcb_surface");
    has_wsi = true;
  }
 
  if (HasExtension("VK_KHR_xlib_surface")) {
    required.push_back("VK_KHR_xlib_surface");
    has_wsi = true;
  }
 
  if (HasExtension("VK_KHR_wayland_surface")) {
    required.push_back("VK_KHR_wayland_surface");
    has_wsi = true;
  }
 
  if (!has_wsi) {
    // Don't really care which WSI extension there is as long there is at least
    // one.
    VALIDATION_LOG << "Could not find a WSI extension.";
    return std::nullopt;
  }
 
  if (validations_enabled_) {
    if (!HasExtension("VK_EXT_debug_utils")) {
      VALIDATION_LOG << "Requested validations but could not find the "
                        "VK_EXT_debug_utils extension.";
      return std::nullopt;
    }
    required.push_back("VK_EXT_debug_utils");
 
    if (HasExtension("VK_EXT_validation_features")) {
      // It's valid to not have `VK_EXT_validation_features` available.  That's
      // the case when using AGI as a frame debugger.
      required.push_back("VK_EXT_validation_features");
    }
  }
 
  return required;
}

References VALIDATION_LOG.

GetEnabledLayers()

std::optional< std::vector< std::string > > impeller::CapabilitiesVK::GetEnabledLayers

(

)

const

Definition at line 66 of file capabilities_vk.cc.

          {
  std::vector<std::string> required;
 
  if (validations_enabled_) {
    // The presence of this layer is already checked in the ctor.
    required.push_back("VK_LAYER_KHRONOS_validation");
  }
 
  return required;
}

GetPhysicalDeviceProperties()

const vk::PhysicalDeviceProperties & impeller::CapabilitiesVK::GetPhysicalDeviceProperties

(

)

const

Definition at line 496 of file capabilities_vk.cc.

                                                  {
  return device_properties_;
}

HasOptionalDeviceExtension()

bool impeller::CapabilitiesVK::HasOptionalDeviceExtension

(

OptionalDeviceExtensionVK

extension

)

const

Definition at line 500 of file capabilities_vk.cc.

                                               {
  return optional_device_extensions_.find(extension) !=
         optional_device_extensions_.end();
}

IsValid()

bool impeller::CapabilitiesVK::IsValid

(

)

const

Definition at line 58 of file capabilities_vk.cc.

                                   {
  return is_valid_;
}

SetOffscreenFormat()

void impeller::CapabilitiesVK::SetOffscreenFormat

(

PixelFormat

pixel_format

)

const

Definition at line 342 of file capabilities_vk.cc.

                                                                      {
  default_color_format_ = pixel_format;
}

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

SetPhysicalDevice()

bool impeller::CapabilitiesVK::SetPhysicalDevice

(

const vk::PhysicalDevice &

physical_device

)

Definition at line 346 of file capabilities_vk.cc.

                                                                     {
  if (HasSuitableDepthStencilFormat(device, vk::Format::eD32SfloatS8Uint)) {
    default_depth_stencil_format_ = PixelFormat::kD32FloatS8UInt;
  } else if (HasSuitableDepthStencilFormat(device,
                                           vk::Format::eD24UnormS8Uint)) {
    default_depth_stencil_format_ = PixelFormat::kD24UnormS8Uint;
  } else {
    default_depth_stencil_format_ = PixelFormat::kUnknown;
  }
 
  if (HasSuitableDepthStencilFormat(device, vk::Format::eS8Uint)) {
    default_stencil_format_ = PixelFormat::kS8UInt;
  } else if (default_stencil_format_ != PixelFormat::kUnknown) {
    default_stencil_format_ = default_depth_stencil_format_;
  } else {
    return false;
  }
 
  device_properties_ = device.getProperties();
 
  auto physical_properties_2 =
      device.getProperties2<vk::PhysicalDeviceProperties2,
                            vk::PhysicalDeviceSubgroupProperties>();
 
  // Currently shaders only want access to arithmetic subgroup features.
  // If that changes this needs to get updated, and so does Metal (which right
  // now assumes it from compile time flags based on the MSL target version).
 
  supports_compute_subgroups_ =
      !!(physical_properties_2.get<vk::PhysicalDeviceSubgroupProperties>()
             .supportedOperations &
         vk::SubgroupFeatureFlagBits::eArithmetic);
 
  {
    // Query texture support.
    // TODO(jonahwilliams):
    // https://github.com/flutter/flutter/issues/129784
    vk::PhysicalDeviceMemoryProperties memory_properties;
    device.getMemoryProperties(&memory_properties);
 
    for (auto i = 0u; i < memory_properties.memoryTypeCount; i++) {
      if (memory_properties.memoryTypes[i].propertyFlags &
          vk::MemoryPropertyFlagBits::eLazilyAllocated) {
        supports_device_transient_textures_ = true;
      }
    }
  }
 
  // Determine the optional device extensions this physical device supports.
  {
    optional_device_extensions_.clear();
    auto exts = GetSupportedDeviceExtensions(device);
    if (!exts.has_value()) {
      return false;
    }
    IterateOptionalDeviceExtensions([&](auto ext) {
      auto ext_name = GetDeviceExtensionName(ext);
      if (exts->find(ext_name) != exts->end()) {
        optional_device_extensions_.insert(ext);
      }
    });
  }
 
  {
    supports_framebuffer_fetch_ =
        (optional_device_extensions_.find(
             OptionalDeviceExtensionVK::
                 kARMRasterizationOrderAttachmentAccess) !=
             optional_device_extensions_.end() ||
         optional_device_extensions_.find(
             OptionalDeviceExtensionVK::
                 kEXTRasterizationOrderAttachmentAccess) !=
             optional_device_extensions_.end());
  }
 
  return true;
}

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

overridevirtual

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.

                                                        {
  return true;
}

SupportsCompute()

bool impeller::CapabilitiesVK::SupportsCompute ( ) const

overridevirtual

Whether the context backend supports ComputePass.

Implements impeller::Capabilities.

Definition at line 455 of file capabilities_vk.cc.

                                           {
  // Vulkan 1.1 requires support for compute.
  return true;
}

SupportsComputeSubgroups()

bool impeller::CapabilitiesVK::SupportsComputeSubgroups ( ) const

overridevirtual

Whether the context backend supports configuring ComputePass command subgroups.

Implements impeller::Capabilities.

Definition at line 461 of file capabilities_vk.cc.

                                                    {
  // Set by |SetPhysicalDevice|.
  return supports_compute_subgroups_;
}

SupportsDecalSamplerAddressMode()

bool impeller::CapabilitiesVK::SupportsDecalSamplerAddressMode ( ) const

overridevirtual

Whether the context backend supports SamplerAddressMode::Decal.

Implements impeller::Capabilities.

Definition at line 471 of file capabilities_vk.cc.

                                                           {
  return true;
}

SupportsDeviceTransientTextures()

bool impeller::CapabilitiesVK::SupportsDeviceTransientTextures ( ) const

overridevirtual

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.

                                                           {
  return supports_device_transient_textures_;
}

SupportsFramebufferFetch()

bool impeller::CapabilitiesVK::SupportsFramebufferFetch ( ) const

overridevirtual

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.

                                                    {
  return supports_framebuffer_fetch_;
}

SupportsImplicitResolvingMSAA()

bool impeller::CapabilitiesVK::SupportsImplicitResolvingMSAA ( ) const

overridevirtual

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.

                                                         {
  return false;
}

SupportsOffscreenMSAA()

bool impeller::CapabilitiesVK::SupportsOffscreenMSAA ( ) const

overridevirtual

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

Implements impeller::Capabilities.

Definition at line 425 of file capabilities_vk.cc.

                                                 {
  return true;
}

SupportsReadFromResolve()

bool impeller::CapabilitiesVK::SupportsReadFromResolve ( ) const

overridevirtual

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.

                                                   {
  return false;
}

SupportsSSBO()

bool impeller::CapabilitiesVK::SupportsSSBO ( ) const

overridevirtual

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.

                                        {
  return true;
}

SupportsTextureToTextureBlits()

bool impeller::CapabilitiesVK::SupportsTextureToTextureBlits ( ) const

overridevirtual

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.

                                                         {
  return true;
}

---

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