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 >

Public Member Functions
	CapabilitiesVK (bool enable_validations, bool fatal_missing_validations=false)

	~CapabilitiesVK ()

bool	IsValid () const

bool	AreValidationsEnabled () const

bool	HasExtension (RequiredCommonDeviceExtensionVK ext) const

bool	HasExtension (RequiredAndroidDeviceExtensionVK ext) const

bool	HasExtension (OptionalDeviceExtensionVK 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 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	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...

PixelFormat	GetDefaultGlyphAtlasFormat () const override
	Returns the default pixel format for the alpha bitmap glyph atlas. 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 140 of file capabilities_vk.h.

Member Typedef Documentation

◆ PhysicalDeviceFeatures

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

Definition at line 168 of file capabilities_vk.h.

Constructor & Destructor Documentation

◆ CapabilitiesVK()

impeller::CapabilitiesVK::CapabilitiesVK	(	bool	enable_validations,
		bool	fatal_missing_validations = `false`
	)

explicit

Definition at line 17 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 (fatal_missing_validations) {
       FML_LOG(FATAL) << "Validation missing. Exiting.";
     }
   }
   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 65 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 576 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 586 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 595 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 581 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 237 of file capabilities_vk.cc.

                                                    {
   auto exts = GetSupportedDeviceExtensions(physical_device);
  
   if (!exts.has_value()) {
     return std::nullopt;
   }
  
   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_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);
  
   if (!iterate_extensions) {
     VALIDATION_LOG << "Device not suitable since required extensions are not "
                       "supported.";
     return std::nullopt;
   }
  
   return enabled;
 }

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

Referenced by GetEnabledDeviceFeatures().

◆ GetEnabledDeviceFeatures()

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

Definition at line 350 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;
   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;
   }
  
   // 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 GetEnabledDeviceExtensions(), impeller::HasRequiredProperties(), impeller::HasRequiredQueues(), impeller::IsExtensionInList(), 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 82 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 69 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 591 of file capabilities_vk.cc.

                                                   {
   return device_properties_;
 }

◆ HasExtension() [1/3]

bool impeller::CapabilitiesVK::HasExtension ( OptionalDeviceExtensionVK ext ) const

Definition at line 609 of file capabilities_vk.cc.

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

◆ HasExtension() [2/3]

bool impeller::CapabilitiesVK::HasExtension ( RequiredAndroidDeviceExtensionVK ext ) const

Definition at line 604 of file capabilities_vk.cc.

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

◆ HasExtension() [3/3]

bool impeller::CapabilitiesVK::HasExtension ( RequiredCommonDeviceExtensionVK ext ) const

Definition at line 599 of file capabilities_vk.cc.

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

Referenced by GetEnabledInstanceExtensions().

◆ IsValid()

bool impeller::CapabilitiesVK::IsValid ( ) const

Definition at line 61 of file capabilities_vk.cc.

                                    {
   return is_valid_;
 }

◆ SetOffscreenFormat()

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

Definition at line 433 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 437 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::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_depth_stencil_format_ != PixelFormat::kUnknown) {
     default_stencil_format_ = default_depth_stencil_format_;
   }
  
   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.
   {
     required_common_device_extensions_.clear();
     required_android_device_extensions_.clear();
     optional_device_extensions_.clear();
     auto exts = GetSupportedDeviceExtensions(device);
     if (!exts.has_value()) {
       return false;
     }
     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;
     });
   }
  
   return true;
 }

References impeller::GetExtensionName(), impeller::GetSupportedDeviceExtensions(), impeller::HasSuitableColorFormat(), impeller::HasSuitableDepthStencilFormat(), impeller::kD24UnormS8Uint, impeller::kD32FloatS8UInt, impeller::kR8G8B8A8UNormInt, impeller::kS8UInt, and impeller::kUnknown.

◆ SupportsCompute()

bool impeller::CapabilitiesVK::SupportsCompute ( ) const

overridevirtual

Whether the context backend supports ComputePass.

Implements impeller::Capabilities.

Definition at line 550 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 556 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 566 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 571 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 545 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 530 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 525 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 562 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 535 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 540 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

Public Types

Public Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ PhysicalDeviceFeatures

Constructor & Destructor Documentation

◆ CapabilitiesVK()

◆ ~CapabilitiesVK()

Member Function Documentation

◆ AreValidationsEnabled()

◆ GetDefaultColorFormat()

◆ GetDefaultDepthStencilFormat()

◆ GetDefaultGlyphAtlasFormat()

◆ GetDefaultStencilFormat()

◆ GetEnabledDeviceExtensions()

◆ GetEnabledDeviceFeatures()

◆ GetEnabledInstanceExtensions()

◆ GetEnabledLayers()

◆ GetPhysicalDeviceProperties()

◆ HasExtension() [1/3]

◆ HasExtension() [2/3]

◆ HasExtension() [3/3]

◆ IsValid()

◆ SetOffscreenFormat()

◆ SetPhysicalDevice()

◆ SupportsCompute()

◆ SupportsComputeSubgroups()

◆ SupportsDecalSamplerAddressMode()

◆ SupportsDeviceTransientTextures()

◆ SupportsFramebufferFetch()

◆ SupportsImplicitResolvingMSAA()

◆ SupportsOffscreenMSAA()

◆ SupportsReadFromResolve()

◆ SupportsSSBO()

◆ SupportsTextureToTextureBlits()