impeller::CapabilitiesVK Class Reference

The Vulkan layers and extensions wrangler. More...

#include <capabilities_vk.h>

Inheritance diagram for impeller::CapabilitiesVK:

Public Types
using	PhysicalDeviceFeatures = vk::StructureChain< vk::PhysicalDeviceFeatures2, vk::PhysicalDeviceSamplerYcbcrConversionFeaturesKHR, vk::PhysicalDevice16BitStorageFeatures, vk::PhysicalDeviceImageCompressionControlFeaturesEXT, vk::PhysicalDeviceTextureCompressionASTCHDRFeatures >

Public Member Functions
	CapabilitiesVK (bool enable_validations, bool fatal_missing_validations=false, bool use_embedder_extensions=false, std::vector< std::string > instance_extensions={}, std::vector< std::string > device_extensions={})
	~CapabilitiesVK ()
bool	IsValid () const
bool	AreValidationsEnabled () const
bool	HasExtension (RequiredCommonDeviceExtensionVK ext) const
bool	HasExtension (RequiredAndroidDeviceExtensionVK ext) const
bool	HasExtension (OptionalDeviceExtensionVK ext) const
bool	HasExtension (OptionalAndroidDeviceExtensionVK ext) 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< PhysicalDeviceFeatures >	GetEnabledDeviceFeatures (const vk::PhysicalDevice &physical_device) const
bool	SetPhysicalDevice (const vk::PhysicalDevice &physical_device, const PhysicalDeviceFeatures &enabled_features)
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.
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.
bool	SupportsSSBO () const override
	Whether the context backend supports binding Shader Storage Buffer Objects (SSBOs) to pipelines.
bool	SupportsTextureToTextureBlits () const override
	Whether the context backend supports blitting from one texture region to another texture region (via the relevant BlitPass::AddCopy overloads).
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).
bool	SupportsCompute () const override
	Whether the context backend supports ComputePass.
bool	SupportsComputeSubgroups () const override
	Whether the context backend supports configuring ComputePass command subgroups.
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.
bool	SupportsDecalSamplerAddressMode () const override
	Whether the context backend supports SamplerAddressMode::Decal.
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.
bool	SupportsTriangleFan () const override
	Whether the primitive type TriangleFan is supported by the backend.
bool	SupportsPrimitiveRestart () const override
	Whether primitive restart is supported.
bool	Supports32BitPrimitiveIndices () const override
	Whether 32-bit values are supported in index buffers used to draw primitives.
bool	SupportsManuallyMippedTextures () const override
	Whether a texture whose mip levels were uploaded by hand (rather than produced by BlitPass::GenerateMipmap) samples with correct per-level selection. True everywhere except OpenGL ES 2.0 without GL_APPLE_texture_max_level, where the sampled mip range cannot be bounded to the levels the texture declares.
bool	SupportsExtendedRangeFormats () const override
	Whether the XR formats are supported on this device.
bool	SupportsTextureCompression (CompressedTextureFamily family) const override
	Whether the given family of block-compressed texture formats is supported by this device. Compressed formats are sample-only and their support varies by hardware, so callers must check this before allocating a compressed texture.
bool	SupportsFramebufferRenderMipmap () const override
	Whether a non-zero mip level of a texture can be attached as a render target. Rendering into a cube map face or array layer is always supported. Metal and Vulkan support this; the GLES backend does not yet, so it returns false there.
PixelFormat	GetDefaultColorFormat () const override
	Returns a supported PixelFormat for textures that store 4-channel colors (red/green/blue/alpha).
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.
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.
PixelFormat	GetDefaultGlyphAtlasFormat () const override
	Returns the default pixel format for the alpha bitmap glyph atlas.
ISize	GetMaximumRenderPassAttachmentSize () const override
	Return the maximum size of a render pass attachment.
size_t	GetMinimumUniformAlignment () const override
	The minimum alignment of uniform value offsets in bytes.
size_t	GetMinimumStorageBufferAlignment () const override
	The minimum alignment of storage buffer value offsets in bytes.
bool	NeedsPartitionedHostBuffer () const override
	Whether the host buffer should use separate device buffers for indexes from other data.
bool	SupportsTextureFixedRateCompression () const
bool	SupportsExternalSemaphoreExtensions () const
std::optional< vk::ImageCompressionFixedRateFlagBitsEXT >	GetSupportedFRCRate (CompressionType compression_type, const FRCFormatDescriptor &desc) const
	Get the fixed compression rate supported by the context for the given format and usage.
void	ApplyWorkarounds (const WorkaroundsVK &workarounds)
	Update capabilities for the given set of workarounds.
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 188 of file capabilities_vk.h.

Member Typedef Documentation

PhysicalDeviceFeatures

using impeller::CapabilitiesVK::PhysicalDeviceFeatures = vk::StructureChain<vk::PhysicalDeviceFeatures2, vk::PhysicalDeviceSamplerYcbcrConversionFeaturesKHR, vk::PhysicalDevice16BitStorageFeatures, vk::PhysicalDeviceImageCompressionControlFeaturesEXT, vk::PhysicalDeviceTextureCompressionASTCHDRFeatures>

Definition at line 218 of file capabilities_vk.h.

Constructor & Destructor Documentation

CapabilitiesVK()

impeller::CapabilitiesVK::CapabilitiesVK ( bool  enable_validations, bool  fatal_missing_validations = false, bool  use_embedder_extensions = false, std::vector< std::string >  instance_extensions = {}, std::vector< std::string >  device_extensions = {}  )

explicit

Definition at line 22 of file capabilities_vk.cc.

    : use_embedder_extensions_(use_embedder_extensions),
      embedder_instance_extensions_(std::move(instance_extensions)),
      embedder_device_extensions_(std::move(device_extensions)) {
  if (!use_embedder_extensions_) {
    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);
      }
    }
  } else {
    for (const auto& ext : embedder_instance_extensions_) {
      exts_[kInstanceLayer].insert(ext);
    }
  }
 
  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 (fatal_missing_validations) {
      FML_LOG(FATAL) << "Validation missing. Exiting.";
    }
  }
  if (validations_enabled_) {
    FML_LOG(INFO) << "Vulkan validations are enabled.";
  }
  is_valid_ = true;
}

References FML_LOG, impeller::kInstanceLayer, and layers.

~CapabilitiesVK()

impeller::CapabilitiesVK::~CapabilitiesVK ( )

default

Member Function Documentation

ApplyWorkarounds()

void impeller::CapabilitiesVK::ApplyWorkarounds

(

const WorkaroundsVK &

workarounds

)

Update capabilities for the given set of workarounds.

Definition at line 875 of file capabilities_vk.cc.

                                                                      {
  has_primitive_restart_ = !workarounds.slow_primitive_restart_performance;
  has_framebuffer_fetch_ = !workarounds.input_attachment_self_dependency_broken;
}

References impeller::WorkaroundsVK::input_attachment_self_dependency_broken, and impeller::WorkaroundsVK::slow_primitive_restart_performance.

AreValidationsEnabled()

bool impeller::CapabilitiesVK::AreValidationsEnabled

(

)

const

Definition at line 82 of file capabilities_vk.cc.

                                                 {
  return validations_enabled_;
}

Referenced by flutter::CreateImpellerContext(), impeller::DebugReportVK::DebugReportVK(), impeller::testing::TEST(), 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 755 of file capabilities_vk.cc.

                                                        {
  return default_color_format_;
}

Referenced by impeller::testing::TEST().

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 765 of file capabilities_vk.cc.

                                                               {
  return default_depth_stencil_format_;
}

Referenced by impeller::testing::TEST().

GetDefaultGlyphAtlasFormat()

PixelFormat impeller::CapabilitiesVK::GetDefaultGlyphAtlasFormat ( ) const

overridevirtual

Returns the default pixel format for the alpha bitmap glyph atlas.

   Some backends may use Red channel while others use grey. This
   should not have any impact 

Implements impeller::Capabilities.

Definition at line 774 of file capabilities_vk.cc.

                                                             {
  return PixelFormat::kR8UNormInt;
}

References impeller::kR8UNormInt.

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 760 of file capabilities_vk.cc.

                                                          {
  return default_stencil_format_;
}

Referenced by impeller::testing::TEST().

GetEnabledDeviceExtensions()

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

(

const vk::PhysicalDevice &

physical_device

)

const

Definition at line 265 of file capabilities_vk.cc.

                                                   {
  std::set<std::string> exts;
 
  if (!use_embedder_extensions_) {
    auto maybe_exts = GetSupportedDeviceExtensions(physical_device);
 
    if (!maybe_exts.has_value()) {
      return std::nullopt;
    }
    exts = maybe_exts.value();
  } else {
    for (const auto& ext : embedder_device_extensions_) {
      exts.insert(ext);
    }
  }
 
  std::vector<std::string> enabled;
 
  auto for_each_common_extension = [&](RequiredCommonDeviceExtensionVK ext) {
    auto name = GetExtensionName(ext);
    if (exts.find(name) == exts.end()) {
      VALIDATION_LOG << "Device does not support required extension: " << name;
      return false;
    }
    enabled.push_back(name);
    return true;
  };
 
  auto for_each_android_extension = [&](RequiredAndroidDeviceExtensionVK ext) {
#ifdef FML_OS_ANDROID
    auto name = GetExtensionName(ext);
    if (exts.find(name) == exts.end()) {
      VALIDATION_LOG << "Device does not support required Android extension: "
                     << name;
      return false;
    }
    enabled.push_back(name);
#endif  //  FML_OS_ANDROID
    return true;
  };
 
  auto for_each_optional_android_extension =
      [&](OptionalAndroidDeviceExtensionVK ext) {
#ifdef FML_OS_ANDROID
        auto name = GetExtensionName(ext);
        if (exts.find(name) != exts.end()) {
          enabled.push_back(name);
        }
#endif  //  FML_OS_ANDROID
        return true;
      };
 
  auto for_each_optional_extension = [&](OptionalDeviceExtensionVK ext) {
    auto name = GetExtensionName(ext);
    if (exts.find(name) != exts.end()) {
      enabled.push_back(name);
    }
    return true;
  };
 
  const auto iterate_extensions =
      IterateExtensions<RequiredCommonDeviceExtensionVK>(
          for_each_common_extension) &&
      IterateExtensions<RequiredAndroidDeviceExtensionVK>(
          for_each_android_extension) &&
      IterateExtensions<OptionalDeviceExtensionVK>(
          for_each_optional_extension) &&
      IterateExtensions<OptionalAndroidDeviceExtensionVK>(
          for_each_optional_android_extension);
 
  if (!iterate_extensions) {
    VALIDATION_LOG << "Device not suitable since required extensions are not "
                      "supported.";
    return std::nullopt;
  }
 
  return enabled;
}

References impeller::GetExtensionName(), impeller::GetSupportedDeviceExtensions(), name, physical_device, and VALIDATION_LOG.

Referenced by GetEnabledDeviceFeatures().

GetEnabledDeviceFeatures()

std::optional< CapabilitiesVK::PhysicalDeviceFeatures > impeller::CapabilitiesVK::GetEnabledDeviceFeatures

(

const vk::PhysicalDevice &

physical_device

)

const

Definition at line 401 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;
  }
 
  const auto enabled_extensions = GetEnabledDeviceExtensions(device);
  if (!enabled_extensions.has_value()) {
    VALIDATION_LOG << "Device doesn't support the required queues.";
    return std::nullopt;
  }
 
  PhysicalDeviceFeatures supported_chain;
 
  // Swiftshader seems to be fussy about just this structure even being in the
  // chain. Just unlink it if its not supported. We already perform an
  // extensions check on the other side when reading.
  if (!IsExtensionInList(
          enabled_extensions.value(),
          OptionalDeviceExtensionVK::kEXTImageCompressionControl)) {
    supported_chain
        .unlink<vk::PhysicalDeviceImageCompressionControlFeaturesEXT>();
  }
  if (!IsExtensionInList(
          enabled_extensions.value(),
          OptionalDeviceExtensionVK::kEXTTextureCompressionAstcHdr)) {
    supported_chain
        .unlink<vk::PhysicalDeviceTextureCompressionASTCHDRFeatures>();
  }
 
  device.getFeatures2(&supported_chain.get());
 
  PhysicalDeviceFeatures required_chain;
 
  // Base features.
  {
    auto& required = required_chain.get().features;
    const auto& supported = supported_chain.get().features;
 
    // 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 = supported.fillModeNonSolid;
  }
  // VK_KHR_sampler_ycbcr_conversion features.
  if (IsExtensionInList(
          enabled_extensions.value(),
          RequiredAndroidDeviceExtensionVK::kKHRSamplerYcbcrConversion)) {
    auto& required =
        required_chain
            .get<vk::PhysicalDeviceSamplerYcbcrConversionFeaturesKHR>();
    const auto& supported =
        supported_chain
            .get<vk::PhysicalDeviceSamplerYcbcrConversionFeaturesKHR>();
 
    required.samplerYcbcrConversion = supported.samplerYcbcrConversion;
  }
 
  // VK_EXT_image_compression_control
  if (IsExtensionInList(
          enabled_extensions.value(),
          OptionalDeviceExtensionVK::kEXTImageCompressionControl)) {
    auto& required =
        required_chain
            .get<vk::PhysicalDeviceImageCompressionControlFeaturesEXT>();
    const auto& supported =
        supported_chain
            .get<vk::PhysicalDeviceImageCompressionControlFeaturesEXT>();
 
    required.imageCompressionControl = supported.imageCompressionControl;
  } else {
    required_chain
        .unlink<vk::PhysicalDeviceImageCompressionControlFeaturesEXT>();
  }
 
  // VK_EXT_texture_compression_astc_hdr
  if (IsExtensionInList(
          enabled_extensions.value(),
          OptionalDeviceExtensionVK::kEXTTextureCompressionAstcHdr)) {
    auto& required =
        required_chain
            .get<vk::PhysicalDeviceTextureCompressionASTCHDRFeatures>();
    const auto& supported =
        supported_chain
            .get<vk::PhysicalDeviceTextureCompressionASTCHDRFeatures>();
 
    required.textureCompressionASTC_HDR = supported.textureCompressionASTC_HDR;
  } else {
    required_chain
        .unlink<vk::PhysicalDeviceTextureCompressionASTCHDRFeatures>();
  }
 
  // Vulkan 1.1
  {
    auto& required =
        required_chain.get<vk::PhysicalDevice16BitStorageFeatures>();
    const auto& supported =
        supported_chain.get<vk::PhysicalDevice16BitStorageFeatures>();
 
    required.uniformAndStorageBuffer16BitAccess =
        supported.uniformAndStorageBuffer16BitAccess;
  }
 
  return required_chain;
}

References device, GetEnabledDeviceExtensions(), impeller::HasRequiredProperties(), impeller::HasRequiredQueues(), impeller::IsExtensionInList(), impeller::kEXTImageCompressionControl, impeller::kEXTTextureCompressionAstcHdr, impeller::kKHRSamplerYcbcrConversion, impeller::PhysicalDeviceSupportsRequiredFormats(), and VALIDATION_LOG.

Referenced by impeller::PickPhysicalDevice().

GetEnabledInstanceExtensions()

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

(

)

const

Definition at line 99 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 HasExtension(), and VALIDATION_LOG.

GetEnabledLayers()

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

(

)

const

Definition at line 86 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;
}

GetMaximumRenderPassAttachmentSize()

ISize impeller::CapabilitiesVK::GetMaximumRenderPassAttachmentSize ( ) const

overridevirtual

Return the maximum size of a render pass attachment.

Note that this may be smaller than the maximum allocatable texture size.

Implements impeller::Capabilities.

Definition at line 871 of file capabilities_vk.cc.

                                                               {
  return max_render_pass_attachment_size_;
}

GetMinimumStorageBufferAlignment()

size_t impeller::CapabilitiesVK::GetMinimumStorageBufferAlignment ( ) const

overridevirtual

The minimum alignment of storage buffer value offsets in bytes.

Reimplemented from impeller::Capabilities.

Definition at line 782 of file capabilities_vk.cc.

                                                              {
  return minimum_storage_alignment_;
}

GetMinimumUniformAlignment()

size_t impeller::CapabilitiesVK::GetMinimumUniformAlignment ( ) const

overridevirtual

The minimum alignment of uniform value offsets in bytes.

Implements impeller::Capabilities.

Definition at line 778 of file capabilities_vk.cc.

                                                        {
  return minimum_uniform_alignment_;
}

GetPhysicalDeviceProperties()

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

(

)

const

Definition at line 770 of file capabilities_vk.cc.

                                                  {
  return device_properties_;
}

GetSupportedFRCRate()

std::optional< vk::ImageCompressionFixedRateFlagBitsEXT > impeller::CapabilitiesVK::GetSupportedFRCRate	(	CompressionType	compression_type,
		const FRCFormatDescriptor &	desc
	)		const

Get the fixed compression rate supported by the context for the given format and usage.

Parameters

[in]	compression_type	The compression type.
[in]	desc	The format and usage of the image.

Returns

The supported fixed compression rate.

Definition at line 815 of file capabilities_vk.cc.

                                                                           {
  if (compression_type != CompressionType::kLossy) {
    return std::nullopt;
  }
  if (!supports_texture_fixed_rate_compression_) {
    return std::nullopt;
  }
  // There are opportunities to hash and cache the FRCFormatDescriptor if
  // needed.
  vk::StructureChain<vk::PhysicalDeviceImageFormatInfo2,
                     vk::ImageCompressionControlEXT>
      format_chain;
 
  auto& format_info = format_chain.get();
 
  format_info.format = desc.format;
  format_info.type = desc.type;
  format_info.tiling = desc.tiling;
  format_info.usage = desc.usage;
  format_info.flags = desc.flags;
 
  const auto kIdealFRCRate = vk::ImageCompressionFixedRateFlagBitsEXT::e4Bpc;
 
  std::array<vk::ImageCompressionFixedRateFlagsEXT, 1u> rates = {kIdealFRCRate};
 
  auto& compression = format_chain.get<vk::ImageCompressionControlEXT>();
  compression.flags = vk::ImageCompressionFlagBitsEXT::eFixedRateExplicit;
  compression.compressionControlPlaneCount = rates.size();
  compression.pFixedRateFlags = rates.data();
 
  const auto [result, supported] = physical_device_.getImageFormatProperties2<
      vk::ImageFormatProperties2, vk::ImageCompressionPropertiesEXT>(
      format_chain.get());
 
  if (result != vk::Result::eSuccess ||
      !supported.isLinked<vk::ImageCompressionPropertiesEXT>()) {
    return std::nullopt;
  }
 
  const auto& compression_props =
      supported.get<vk::ImageCompressionPropertiesEXT>();
 
  if ((compression_props.imageCompressionFlags &
       vk::ImageCompressionFlagBitsEXT::eFixedRateExplicit) &&
      (compression_props.imageCompressionFixedRateFlags & kIdealFRCRate)) {
    return kIdealFRCRate;
  }
 
  return std::nullopt;
}

References impeller::FRCFormatDescriptor::flags, impeller::FRCFormatDescriptor::format, impeller::kLossy, impeller::FRCFormatDescriptor::tiling, impeller::FRCFormatDescriptor::type, and impeller::FRCFormatDescriptor::usage.

HasExtension() [1/4]

bool impeller::CapabilitiesVK::HasExtension

(

OptionalAndroidDeviceExtensionVK

ext

)

const

Definition at line 805 of file capabilities_vk.cc.

                                                                            {
  return optional_android_device_extensions_.find(ext) !=
         optional_android_device_extensions_.end();
}

HasExtension() [2/4]

bool impeller::CapabilitiesVK::HasExtension

(

OptionalDeviceExtensionVK

ext

)

const

Definition at line 800 of file capabilities_vk.cc.

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

HasExtension() [3/4]

bool impeller::CapabilitiesVK::HasExtension

(

RequiredAndroidDeviceExtensionVK

ext

)

const

Definition at line 795 of file capabilities_vk.cc.

                                                                            {
  return required_android_device_extensions_.find(ext) !=
         required_android_device_extensions_.end();
}

HasExtension() [4/4]

bool impeller::CapabilitiesVK::HasExtension

(

RequiredCommonDeviceExtensionVK

ext

)

const

Definition at line 790 of file capabilities_vk.cc.

                                                                           {
  return required_common_device_extensions_.find(ext) !=
         required_common_device_extensions_.end();
}

Referenced by GetEnabledInstanceExtensions(), and SetPhysicalDevice().

IsValid()

bool impeller::CapabilitiesVK::IsValid

(

)

const

Definition at line 78 of file capabilities_vk.cc.

                                   {
  return is_valid_;
}

NeedsPartitionedHostBuffer()

bool impeller::CapabilitiesVK::NeedsPartitionedHostBuffer ( ) const

overridevirtual

Whether the host buffer should use separate device buffers for indexes from other data.

Implements impeller::Capabilities.

Definition at line 786 of file capabilities_vk.cc.

                                                      {
  return false;
}

SetOffscreenFormat()

void impeller::CapabilitiesVK::SetOffscreenFormat

(

PixelFormat

pixel_format

)

const

Definition at line 547 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,
		const PhysicalDeviceFeatures &	enabled_features
	)

Definition at line 551 of file capabilities_vk.cc.

                                                    {
  if (HasSuitableColorFormat(device, vk::Format::eR8G8B8A8Unorm)) {
    default_color_format_ = PixelFormat::kR8G8B8A8UNormInt;
  } else {
    default_color_format_ = PixelFormat::kUnknown;
  }
 
  if (HasSuitableDepthStencilFormat(device, vk::Format::eD24UnormS8Uint)) {
    default_depth_stencil_format_ = PixelFormat::kD24UnormS8Uint;
  } else if (HasSuitableDepthStencilFormat(device,
                                           vk::Format::eD32SfloatS8Uint)) {
    default_depth_stencil_format_ = PixelFormat::kD32FloatS8UInt;
  } else {
    default_depth_stencil_format_ = PixelFormat::kUnknown;
  }
 
  if (HasSuitableDepthStencilFormat(device, vk::Format::eS8Uint)) {
    default_stencil_format_ = PixelFormat::kS8UInt;
  } else if (default_depth_stencil_format_ != PixelFormat::kUnknown) {
    default_stencil_format_ = default_depth_stencil_format_;
  }
 
  physical_device_ = device;
  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(129784): Add a capability check for expected memory types.
    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.
  {
    required_common_device_extensions_.clear();
    required_android_device_extensions_.clear();
    optional_device_extensions_.clear();
    optional_android_device_extensions_.clear();
 
    std::set<std::string> exts;
    if (!use_embedder_extensions_) {
      auto maybe_exts = GetSupportedDeviceExtensions(device);
      if (!maybe_exts.has_value()) {
        return false;
      }
      exts = maybe_exts.value();
    } else {
      for (const auto& ext : embedder_device_extensions_) {
        exts.insert(ext);
      }
    }
 
    IterateExtensions<RequiredCommonDeviceExtensionVK>([&](auto ext) -> bool {
      auto ext_name = GetExtensionName(ext);
      if (exts.find(ext_name) != exts.end()) {
        required_common_device_extensions_.insert(ext);
      }
      return true;
    });
    IterateExtensions<RequiredAndroidDeviceExtensionVK>([&](auto ext) -> bool {
      auto ext_name = GetExtensionName(ext);
      if (exts.find(ext_name) != exts.end()) {
        required_android_device_extensions_.insert(ext);
      }
      return true;
    });
    IterateExtensions<OptionalDeviceExtensionVK>([&](auto ext) -> bool {
      auto ext_name = GetExtensionName(ext);
      if (exts.find(ext_name) != exts.end()) {
        optional_device_extensions_.insert(ext);
      }
      return true;
    });
    IterateExtensions<OptionalAndroidDeviceExtensionVK>(
        [&](OptionalAndroidDeviceExtensionVK ext) {
          auto name = GetExtensionName(ext);
          if (exts.find(name) != exts.end()) {
            optional_android_device_extensions_.insert(ext);
          }
          return true;
        });
  }
 
  supports_texture_fixed_rate_compression_ =
      enabled_features
          .isLinked<vk::PhysicalDeviceImageCompressionControlFeaturesEXT>() &&
      enabled_features
          .get<vk::PhysicalDeviceImageCompressionControlFeaturesEXT>()
          .imageCompressionControl;
 
  {
    const auto& features = enabled_features.get().features;
    supports_texture_compression_bc_ = features.textureCompressionBC;
    supports_texture_compression_etc2_ = features.textureCompressionETC2;
    supports_texture_compression_astc_ = features.textureCompressionASTC_LDR;
  }
 
  supports_texture_compression_astc_hdr_ =
      enabled_features
          .isLinked<vk::PhysicalDeviceTextureCompressionASTCHDRFeatures>() &&
      enabled_features
          .get<vk::PhysicalDeviceTextureCompressionASTCHDRFeatures>()
          .textureCompressionASTC_HDR;
 
  max_render_pass_attachment_size_ =
      ISize{device_properties_.limits.maxFramebufferWidth,
            device_properties_.limits.maxFramebufferHeight};
 
  // Molten, Vulkan on Metal, cannot support triangle fans because Metal doesn't
  // support triangle fans.
  // See VUID-VkPipelineInputAssemblyStateCreateInfo-triangleFans-04452.
  has_triangle_fans_ =
      !HasExtension(OptionalDeviceExtensionVK::kVKKHRPortabilitySubset);
 
  // External Fence/Semaphore for AHB swapchain
  if (HasExtension(OptionalAndroidDeviceExtensionVK::kKHRExternalFenceFd) &&
      HasExtension(OptionalAndroidDeviceExtensionVK::kKHRExternalFence) &&
      HasExtension(OptionalAndroidDeviceExtensionVK::kKHRExternalSemaphore) &&
      HasExtension(OptionalAndroidDeviceExtensionVK::kKHRExternalSemaphoreFd)) {
    supports_external_fence_and_semaphore_ = true;
  }
 
  minimum_uniform_alignment_ =
      device_properties_.limits.minUniformBufferOffsetAlignment;
  minimum_storage_alignment_ =
      device_properties_.limits.minStorageBufferOffsetAlignment;
 
  return true;
}

References device, impeller::GetExtensionName(), impeller::GetSupportedDeviceExtensions(), HasExtension(), impeller::HasSuitableColorFormat(), impeller::HasSuitableDepthStencilFormat(), i, impeller::kD24UnormS8Uint, impeller::kD32FloatS8UInt, impeller::kKHRExternalFence, impeller::kKHRExternalFenceFd, impeller::kKHRExternalSemaphore, impeller::kKHRExternalSemaphoreFd, impeller::kR8G8B8A8UNormInt, impeller::kS8UInt, impeller::kUnknown, impeller::kVKKHRPortabilitySubset, and name.

Supports32BitPrimitiveIndices()

bool impeller::CapabilitiesVK::Supports32BitPrimitiveIndices ( ) const

overridevirtual

Whether 32-bit values are supported in index buffers used to draw primitives.

Implements impeller::Capabilities.

Definition at line 539 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 729 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 735 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 745 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 750 of file capabilities_vk.cc.

                                                           {
  return supports_device_transient_textures_;
}

SupportsExtendedRangeFormats()

bool impeller::CapabilitiesVK::SupportsExtendedRangeFormats ( ) const

overridevirtual

Whether the XR formats are supported on this device.

This is only ever true for iOS and macOS devices. We may need to revisit this API when approaching wide gamut rendering for Vulkan and GLES.

Implements impeller::Capabilities.

Definition at line 884 of file capabilities_vk.cc.

                                                        {
  return false;
}

SupportsExternalSemaphoreExtensions()

bool impeller::CapabilitiesVK::SupportsExternalSemaphoreExtensions

(

)

const

Whether the external fence and semaphore extensions used for AHB support are available.

Definition at line 880 of file capabilities_vk.cc.

                                                               {
  return supports_external_fence_and_semaphore_;
}

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

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 724 of file capabilities_vk.cc.

                                                    {
  return has_framebuffer_fetch_;
}

SupportsFramebufferRenderMipmap()

bool impeller::CapabilitiesVK::SupportsFramebufferRenderMipmap ( ) const

overridevirtual

Whether a non-zero mip level of a texture can be attached as a render target. Rendering into a cube map face or array layer is always supported. Metal and Vulkan support this; the GLES backend does not yet, so it returns false there.

Implements impeller::Capabilities.

Definition at line 888 of file capabilities_vk.cc.

                                                           {
  return true;
}

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 709 of file capabilities_vk.cc.

                                                         {
  return false;
}

SupportsManuallyMippedTextures()

bool impeller::CapabilitiesVK::SupportsManuallyMippedTextures ( ) const

overridevirtual

Whether a texture whose mip levels were uploaded by hand (rather than produced by BlitPass::GenerateMipmap) samples with correct per-level selection. True everywhere except OpenGL ES 2.0 without GL_APPLE_texture_max_level, where the sampled mip range cannot be bounded to the levels the texture declares.

Implements impeller::Capabilities.

Definition at line 543 of file capabilities_vk.cc.

                                                          {
  return true;
}

SupportsOffscreenMSAA()

bool impeller::CapabilitiesVK::SupportsOffscreenMSAA ( ) const

overridevirtual

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

Implements impeller::Capabilities.

Definition at line 704 of file capabilities_vk.cc.

                                                 {
  return true;
}

SupportsPrimitiveRestart()

bool impeller::CapabilitiesVK::SupportsPrimitiveRestart ( ) const

overridevirtual

Whether primitive restart is supported.

Implements impeller::Capabilities.

Definition at line 535 of file capabilities_vk.cc.

                                                    {
  return has_primitive_restart_;
}

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 741 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 714 of file capabilities_vk.cc.

                                        {
  return true;
}

SupportsTextureCompression()

bool impeller::CapabilitiesVK::SupportsTextureCompression ( CompressedTextureFamily  family ) const

overridevirtual

Whether the given family of block-compressed texture formats is supported by this device. Compressed formats are sample-only and their support varies by hardware, so callers must check this before allocating a compressed texture.

Implements impeller::Capabilities.

Definition at line 892 of file capabilities_vk.cc.

                                          {
  switch (family) {
    case CompressedTextureFamily::kBC:
      return supports_texture_compression_bc_;
    case CompressedTextureFamily::kETC2:
      return supports_texture_compression_etc2_;
    case CompressedTextureFamily::kASTC:
      return supports_texture_compression_astc_;
    case CompressedTextureFamily::kASTCHDR:
      return supports_texture_compression_astc_hdr_;
  }
  return false;
}

References impeller::kASTC, impeller::kASTCHDR, impeller::kBC, and impeller::kETC2.

SupportsTextureFixedRateCompression()

bool impeller::CapabilitiesVK::SupportsTextureFixedRateCompression

(

)

const

Returns

If fixed-rate compression for non-onscreen surfaces is supported.

Definition at line 810 of file capabilities_vk.cc.

                                                               {
  return supports_texture_fixed_rate_compression_;
}

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 719 of file capabilities_vk.cc.

                                                         {
  return true;
}

SupportsTriangleFan()

bool impeller::CapabilitiesVK::SupportsTriangleFan ( ) const

overridevirtual

Whether the primitive type TriangleFan is supported by the backend.

Implements impeller::Capabilities.

Definition at line 867 of file capabilities_vk.cc.

                                               {
  return has_triangle_fans_;
}

---

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