Flutter Impeller
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
impeller Namespace Reference

Namespaces

 compiler
 
 egl
 
 scene
 
 skia_conversions
 
 testing
 

Classes

class  AiksContext
 
class  AiksInspector
 
class  AiksPlayground
 
class  AllocatedTextureSourceVK
 
class  Allocation
 
class  Allocator
 An object that allocates device memory. More...
 
class  AllocatorGLES
 
class  AllocatorMTL
 
class  AllocatorVK
 
struct  AllocatorVMATraits
 
class  AnonymousContents
 
class  Archivable
 Instances of Archivables can be read from and written to a persistent archive. More...
 
class  Archive
 
class  ArchiveClassRegistration
 
class  ArchiveDatabase
 A handle to the underlying database connection for an archive. More...
 
struct  ArchiveDef
 
class  ArchiveLocation
 
class  ArchiveStatement
 Represents a read/write query to an archive database. Statements are expensive to create and must be cached for as long as possible. More...
 
class  ArchiveTransaction
 All writes made to the archive within a transaction that is not marked as ready for commit will be rolled back with the transaction ends. More...
 
class  ArchiveVector
 
struct  AtlasBlenderKey
 
class  AtlasColorContents
 
class  AtlasContents
 
class  AtlasTextureContents
 
struct  Attachment
 
struct  AutoErrorCheck
 
class  BackendCast
 
class  BackgroundCommandPoolVK
 
struct  BarrierVK
 Defines an operations and memory access barrier on a resource. More...
 
struct  Bindings
 
class  BitmapSTB
 
class  BlendColorFilter
 
class  BlendFilterContents
 
struct  BlitCommand
 
struct  BlitCopyBufferToTextureCommand
 
struct  BlitCopyBufferToTextureCommandMTL
 
struct  BlitCopyBufferToTextureCommandVK
 
struct  BlitCopyTextureToBufferCommand
 
struct  BlitCopyTextureToBufferCommandGLES
 
struct  BlitCopyTextureToBufferCommandMTL
 
struct  BlitCopyTextureToBufferCommandVK
 
struct  BlitCopyTextureToTextureCommand
 
struct  BlitCopyTextureToTextureCommandGLES
 
struct  BlitCopyTextureToTextureCommandMTL
 
struct  BlitCopyTextureToTextureCommandVK
 
struct  BlitEncodeGLES
 Mixin for dispatching GLES commands. More...
 
struct  BlitEncodeMTL
 Mixin for dispatching Metal commands. More...
 
struct  BlitEncodeVK
 Mixin for dispatching Vulkan commands. More...
 
struct  BlitGenerateMipmapCommand
 
struct  BlitGenerateMipmapCommandGLES
 
struct  BlitGenerateMipmapCommandMTL
 
struct  BlitGenerateMipmapCommandVK
 
class  BlitPass
 Blit passes encode blit into the underlying command buffer. More...
 
class  BlitPassGLES
 
class  BlitPassMTL
 
class  BlitPassVK
 
class  BlobLibrary
 
class  BlobWriter
 
class  BlurImageFilter
 
class  BorderMaskBlurFilterContents
 
class  Buffer
 
struct  BufferAndUniformSlot
 combines the buffer resource and its uniform slot information. More...
 
class  BufferBindingsGLES
 Sets up stage bindings for single draw call in the OpenGLES backend. More...
 
struct  BufferView
 
struct  BufferVMA
 
struct  BufferVMATraits
 
class  Canvas
 
struct  CanvasStackEntry
 
class  Capabilities
 
class  CapabilitiesBuilder
 
struct  CapabilitiesGLES
 
class  CapabilitiesVK
 The Vulkan layers and extensions wrangler. More...
 
class  Capture
 
class  CaptureContext
 
struct  CaptureCursorListElement
 
struct  CaptureElement
 
class  CapturePlaybackList
 
struct  CaptureProcTable
 
struct  CaptureProperty
 A capturable property type. More...
 
class  CheckerboardContents
 
class  ClipContents
 
class  ClipRestoreContents
 
struct  Color
 
struct  ColorAttachment
 
struct  ColorAttachmentDescriptor
 Describe the color attachment that will be used with this pipeline. More...
 
class  ColorFilter
 
class  ColorFilterContents
 
struct  ColorHSB
 
class  ColorImageFilter
 
struct  ColorMatrix
 
class  ColorMatrixFilterContents
 
class  ColorSource
 
class  ColorSourceContents
 
struct  Command
 An object used to specify work to the GPU along with references to resources the GPU will used when doing said work. More...
 
class  CommandBuffer
 A collection of encoded commands to be submitted to the GPU for execution. A command buffer is obtained from a graphics Context. More...
 
class  CommandBufferGLES
 
class  CommandBufferMTL
 
class  CommandBufferVK
 
class  CommandEncoderFactoryVK
 
class  CommandEncoderVK
 
class  CommandPoolRecyclerVK
 Creates and manages the lifecycle of |vk::CommandPool| objects. More...
 
class  CommandPoolVK
 Manages the lifecycle of a single |vk::CommandPool|. More...
 
class  Comparable
 
class  ComparableBase
 
struct  ComparableEqual
 
struct  ComparableHash
 
class  ComposeImageFilter
 
class  CompressedImage
 
class  CompressedImageSkia
 
struct  ComputeCommand
 An object used to specify compute work to the GPU along with references to resources the GPU will used when doing said work. More...
 
class  ComputePass
 Compute passes encode compute shader into the underlying command buffer. More...
 
struct  ComputePassBindingsCache
 Ensures that bindings on the pass are not redundantly set or updated. Avoids making the driver do additional checks and makes the frame insights during profiling and instrumentation not complain about the same. More...
 
class  ComputePassMTL
 
class  ComputePassVK
 
struct  ComputePipelineBuilder
 An optional (but highly recommended) utility for creating pipelines from reflected shader information. More...
 
class  ComputePipelineDescriptor
 
class  ComputePipelineMTL
 
class  ComputePipelineT
 
class  ComputePipelineVK
 
class  ComputePlaygroundTest
 
class  ComputeTessellator
 A utility that generates triangles of the specified fill type given a path. More...
 
class  ConicalGradientContents
 
class  ContentContext
 
struct  ContentContextOptions
 
class  Contents
 
class  ContentsFilterInput
 
class  Context
 To do anything rendering related with Impeller, you need a context. More...
 
class  ContextGLES
 
class  ContextMTL
 
class  ContextVK
 
struct  ContourComponent
 
class  CoverGeometry
 A geometry that implements "drawPaint" like behavior by covering the entire render pass area. More...
 
struct  CubicPathComponent
 
class  DebugReportVK
 
class  DecompressedImage
 
class  DefaultEntityPassDelegate
 
struct  Degrees
 
struct  DepthAttachment
 
struct  DepthAttachmentDescriptor
 
struct  DepthRange
 
class  DescriptionGLES
 
class  DescriptorPoolVK
 A short-lived dynamically-sized descriptor pool. Descriptors from this pool don't need to be freed individually. Instead, the pool must be collected after all the descriptors allocated from it are done being used. More...
 
struct  DescriptorSetLayout
 
class  DeviceBuffer
 
struct  DeviceBufferDescriptor
 
class  DeviceBufferGLES
 
class  DeviceBufferMTL
 
class  DeviceBufferVK
 
class  DeviceHolder
 
class  DilateImageFilter
 
class  DirectionalGaussianBlurFilterContents
 
class  DirectionalMorphologyFilterContents
 
class  DlDispatcher
 
class  DlImageImpeller
 
class  DlPlayground
 
struct  EGLImageKHRWithDisplay
 
struct  EGLImageKHRWithDisplayTraits
 
struct  EGLImageWithDisplay
 
struct  EGLImageWithDisplayTraits
 
class  Entity
 
class  EntityPass
 
class  EntityPassDelegate
 
class  EntityPassTarget
 
class  EntityPlayground
 
class  ErodeImageFilter
 
class  FenceWaiterVK
 
class  FillPathGeometry
 A geometry that is created from a filled path object. More...
 
class  FilterContents
 
class  FilterContentsFilterInput
 
class  FilterInput
 
class  Font
 Describes a typeface along with any modifications to its intrinsic properties. More...
 
class  FontGlyphAtlas
 An object that can look up glyph locations within the GlyphAtlas for a particular typeface. More...
 
struct  FontGlyphPair
 A font along with a glyph in that font rendered at a particular scale. More...
 
class  FramebufferBlendContents
 
struct  FrameSynchronizer
 
class  Geometry
 
struct  GeometryResult
 
struct  GLProc
 
struct  GLTexture
 
struct  GLTextureTraits
 
struct  Glyph
 The glyph index in the typeface. More...
 
class  GlyphAtlas
 A texture containing the bitmap representation of glyphs in different fonts along with the ability to query the location of specific font glyphs within the texture. More...
 
class  GlyphAtlasContext
 A container for caching a glyph atlas across frames. More...
 
class  GlyphAtlasContextSkia
 A container for caching a glyph atlas across frames. More...
 
class  GlyphAtlasContextSTB
 
class  GoldenPlaygroundTest
 
struct  GradientData
 
struct  Half
 A storage only class for half precision floating point. More...
 
struct  HalfVector2
 A storage only class for half precision floating point vector 2. More...
 
struct  HalfVector3
 A storage only class for half precision floating point vector 3. More...
 
struct  HalfVector4
 A storage only class for half precision floating point vector 4. More...
 
struct  HandleGLES
 
class  HostBuffer
 
class  Image
 
class  ImageFilter
 
struct  ImageVMA
 
struct  ImageVMATraits
 
class  InlinePassContext
 
struct  IPoint16
 
class  LazyGlyphAtlas
 
class  LinearGradientContents
 
struct  LinearPathComponent
 
class  LinearToSrgbColorFilter
 
class  LinearToSrgbFilterContents
 
class  LocalMatrixFilterContents
 
class  LocalMatrixImageFilter
 
class  Lock
 
struct  Matrix
 A 4x4 matrix using column-major storage. More...
 
class  MatrixColorFilter
 
struct  MatrixDecomposition
 
class  MatrixFilterContents
 
class  MatrixImageFilter
 
struct  MixedOp_
 
class  NinePatchConverter
 
class  OpacityPeepholePassDelegate
 
struct  Padded
 Struct used for padding uniform buffer array elements. More...
 
struct  Padding
 
struct  Paint
 
class  PaintPassDelegate
 
class  PassBindingsCache
 Ensures that bindings on the pass are not redundantly set or updated. Avoids making the driver do additional checks and makes the frame insights during profiling and instrumentation not complain about the same. More...
 
class  Path
 Paths are lightweight objects that describe a collection of linear, quadratic, or cubic segments. These segments may be broken up by move commands, which are effectively linear commands that pick up the pen rather than continuing to draw. More...
 
class  PathBuilder
 
struct  PathComponentEndDirectionVisitor
 
struct  PathComponentStartDirectionVisitor
 
struct  Picture
 
class  PictureRecorder
 
class  Pipeline
 Describes the fixed function and programmable aspects of rendering and compute operations performed by commands submitted to the GPU via a command buffer. More...
 
struct  PipelineBuilder
 An optional (but highly recommended) utility for creating pipelines from reflected shader information. More...
 
class  PipelineCacheVK
 
class  PipelineDescriptor
 
struct  PipelineFuture
 
class  PipelineGLES
 
class  PipelineLibrary
 
class  PipelineLibraryGLES
 
class  PipelineLibraryMTL
 
class  PipelineLibraryVK
 
class  PipelineMTL
 
class  PipelineVK
 
class  PlaceholderFilterInput
 
class  Playground
 
class  PlaygroundImpl
 
class  PlaygroundImplGLES
 
class  PlaygroundImplMTL
 
class  PlaygroundImplVK
 
struct  PlaygroundSwitches
 
class  PlaygroundTest
 
class  PointFieldGeometry
 
class  Pool
 A thread-safe pool with a limited byte size. More...
 
struct  PoolVMA
 
struct  PoolVMATraits
 
class  ProcTableGLES
 
struct  QuadraticPathComponent
 
struct  Quaternion
 
struct  QueueIndexVK
 
struct  QueuesVK
 The collection of queues used by the context. The queues may all be the same. More...
 
class  QueueVK
 A thread safe object that can be used to access device queues. If multiple objects are created with the same underlying queue, then the external synchronization guarantees of Vulkan queues cannot be met. So care must be taken the same device queue doesn't form the basis of multiple QueueVKs. More...
 
class  RadialGradientContents
 
struct  Radians
 
struct  Radius
 For convolution filters, the "radius" is the size of the convolution kernel to use on the local space pixel grid of the filter input. For Gaussian blur kernels, this unit has a linear relationship with Sigma. See kKernelRadiusPerSigma for details on how this relationship works. More...
 
struct  Range
 
class  ReactorGLES
 
class  ReaderLock
 
class  RectanglePacker
 Packs rectangles into a specified area without rotating them. More...
 
class  RectGeometry
 
class  Renderer
 
class  RenderPass
 Render passes encode render commands directed as one specific render target into an underlying command buffer. More...
 
struct  RenderPassData
 Encapsulates data that will be needed in the reactor for the encoding of commands for this render pass. More...
 
class  RenderPassGLES
 
class  RenderPassMTL
 
class  RenderPassVK
 
class  RenderPipelineT
 
class  RenderTarget
 
class  RenderTargetAllocator
 a wrapper around the impeller [Allocator] instance that can be used to provide caching of allocated render target textures. More...
 
class  RenderTargetCache
 An implementation of the [RenderTargetAllocator] that caches all allocated texture data for one frame. More...
 
struct  Resource
 
struct  ResourceBinder
 An interface for binding resources. This is implemented by |Command| and |ComputeCommand| to make GPU resources available to a given command's pipeline. More...
 
class  ResourceManagerVK
 A resource manager controls how resources are allocated and reclaimed. More...
 
class  ResourceVK
 A resource that may be reclaimed by a |ResourceManagerVK|. More...
 
class  ResourceVKT
 An internal type that is used to move a resource reference. More...
 
class  RuntimeEffectContents
 
class  RuntimeStage
 
class  RuntimeStagePlayground
 
struct  RuntimeUniformDescription
 
struct  RuntimeUniformDimensions
 
struct  SampledImageSlot
 
class  Sampler
 
struct  SamplerDescriptor
 
class  SamplerGLES
 
class  SamplerLibrary
 
class  SamplerLibraryGLES
 
class  SamplerLibraryMTL
 
class  SamplerLibraryVK
 
class  SamplerMTL
 
class  SamplerVK
 
struct  ScaledFont
 A font and a scale. Used as a key that represents a typeface within a glyph atlas. More...
 
class  SceneContents
 
struct  ScopedValidationDisable
 
class  ShaderFunction
 
class  ShaderFunctionGLES
 
class  ShaderFunctionMTL
 
class  ShaderFunctionVK
 
struct  ShaderKey
 
class  ShaderLibrary
 
class  ShaderLibraryGLES
 
class  ShaderLibraryMTL
 
class  ShaderLibraryVK
 
struct  ShaderMetadata
 
struct  ShaderStageBufferLayout
 
struct  ShaderStageIOSlot
 
struct  ShaderStructMemberMetadata
 
struct  ShaderUniformSlot
 
class  SharedObjectVK
 
class  SharedObjectVKT
 
struct  Shear
 
struct  Sigma
 In filters that use Gaussian distributions, "sigma" is a size of one standard deviation in terms of the local space pixel grid of the filter input. In other words, this determines how wide the distribution stretches. More...
 
class  SkylineRectanglePacker
 
struct  Snapshot
 Represents a texture and its intended draw transform/sampler configuration. More...
 
class  SolidColorContents
 
class  SolidRRectBlurContents
 Draws a fast solid color blur of an rounded rectangle. Only supports RRects with fully symmetrical radii. Also produces correct results for rectangles (corner_radius=0) and circles (corner_radius=width/2=height/2). More...
 
class  SrgbToLinearColorFilter
 
class  SrgbToLinearFilterContents
 
class  StandardCapabilities
 
struct  StencilAttachment
 
struct  StencilAttachmentDescriptor
 
struct  StopData
 
class  StrokePathGeometry
 A geometry that is created from a stroked path object. More...
 
struct  SubAtlasResult
 
class  Surface
 
class  SurfaceContextVK
 
class  SurfaceGLES
 
class  SurfaceMTL
 
class  SurfaceVK
 
class  SwapchainImageVK
 
class  SwapchainImplVK
 An instance of a swapchain that does NOT adapt to going out of date with the underlying surface. Errors will be indicated when the next drawable is acquired from this implementation of the swapchain. If the error is due the swapchain going out of date, the caller must recreate another instance by optionally stealing this implementations guts. More...
 
class  SwapchainVK
 A swapchain that adapts to the underlying surface going out of date. If the caller cannot acquire the next drawable, it is due to an unrecoverable error and the swapchain must be recreated with a new surface. More...
 
class  SweepGradientContents
 
class  Tessellator
 A utility that generates triangles of the specified fill type given a polyline. This happens on the CPU. More...
 
struct  TexImage2DData
 
class  TextContents
 
class  TextFrame
 Represents a collection of shaped text runs. More...
 
class  TextRun
 Represents a collection of positioned glyphs from a specific font. More...
 
class  Texture
 
struct  TextureAndSampler
 combines the texture, sampler and sampler slot information. More...
 
class  TextureContents
 
struct  TextureDescriptor
 A lightweight object that describes the attributes of a texture that can then used an allocator to create that texture. More...
 
class  TextureFilterInput
 
class  TextureGLES
 
class  TextureMTL
 
class  TextureSourceVK
 
class  TextureVK
 
class  TiledTextureContents
 
struct  TPoint
 
class  TrackedObjectsVK
 
struct  TRect
 
struct  TSize
 
class  Typeface
 A typeface, usually obtained from a font-file, on disk describes the intrinsic properties of the font. Typefaces are rarely used directly. Instead, font refer to typefaces along with any modifications applied to its intrinsic properties. More...
 
class  TypefaceSkia
 
class  TypefaceSTB
 
class  TypographerContext
 The graphics context necessary to render text. More...
 
class  TypographerContextSkia
 
class  TypographerContextSTB
 
struct  UniqueID
 
class  UniqueResourceVKT
 A unique handle to a resource which will be reclaimed by the specified resource manager. More...
 
class  ValidationLog
 
struct  Vector3
 
struct  Vector4
 
struct  Version
 
struct  VertexBuffer
 
class  VertexBufferBuilder
 
class  VertexDescriptor
 Describes the format and layout of vertices expected by the pipeline. While it is possible to construct these descriptors manually, it would be tedious to do so. These are usually constructed using shader information reflected using impellerc. The usage of this class is indirectly via PipelineBuilder<VS, FS>. More...
 
class  VertexDescriptorMTL
 
struct  Vertices
 
class  VerticesColorContents
 
class  VerticesContents
 
class  VerticesGeometry
 A geometry that is created from a vertices object. More...
 
class  VerticesUVContents
 
struct  Viewport
 
class  WaitSetEntry
 
class  WriterLock
 
class  YUVToRGBFilterContents
 

Typedefs

using PrimaryKey = std::optional< int64_t >
 
using MillisecondsF = std::chrono::duration< float, std::milli >
 
using SecondsF = std::chrono::duration< float >
 
using Clock = std::chrono::high_resolution_clock
 
using TimePoint = std::chrono::time_point< std::chrono::high_resolution_clock >
 
using TextureUsageMask = uint64_t
 
using SamplerMap = std::unordered_map< SamplerDescriptor, std::shared_ptr< const Sampler >, ComparableHash< SamplerDescriptor >, ComparableEqual< SamplerDescriptor > >
 
using LinearGradientFillPipeline = RenderPipelineT< GradientFillVertexShader, LinearGradientFillFragmentShader >
 
using SolidFillPipeline = RenderPipelineT< SolidFillVertexShader, SolidFillFragmentShader >
 
using RadialGradientFillPipeline = RenderPipelineT< GradientFillVertexShader, RadialGradientFillFragmentShader >
 
using ConicalGradientFillPipeline = RenderPipelineT< GradientFillVertexShader, ConicalGradientFillFragmentShader >
 
using SweepGradientFillPipeline = RenderPipelineT< GradientFillVertexShader, SweepGradientFillFragmentShader >
 
using LinearGradientSSBOFillPipeline = RenderPipelineT< GradientFillVertexShader, LinearGradientSsboFillFragmentShader >
 
using ConicalGradientSSBOFillPipeline = RenderPipelineT< GradientFillVertexShader, ConicalGradientSsboFillFragmentShader >
 
using RadialGradientSSBOFillPipeline = RenderPipelineT< GradientFillVertexShader, RadialGradientSsboFillFragmentShader >
 
using SweepGradientSSBOFillPipeline = RenderPipelineT< GradientFillVertexShader, SweepGradientSsboFillFragmentShader >
 
using RRectBlurPipeline = RenderPipelineT< RrectBlurVertexShader, RrectBlurFragmentShader >
 
using BlendPipeline = RenderPipelineT< BlendVertexShader, BlendFragmentShader >
 
using TexturePipeline = RenderPipelineT< TextureFillVertexShader, TextureFillFragmentShader >
 
using PositionUVPipeline = RenderPipelineT< TextureFillVertexShader, TiledTextureFillFragmentShader >
 
using TiledTexturePipeline = RenderPipelineT< TextureFillVertexShader, TiledTextureFillFragmentShader >
 
using GaussianBlurDecalPipeline = RenderPipelineT< GaussianBlurVertexShader, GaussianBlurNoalphaDecalFragmentShader >
 
using GaussianBlurPipeline = RenderPipelineT< GaussianBlurVertexShader, GaussianBlurNoalphaNodecalFragmentShader >
 
using BorderMaskBlurPipeline = RenderPipelineT< BorderMaskBlurVertexShader, BorderMaskBlurFragmentShader >
 
using MorphologyFilterPipeline = RenderPipelineT< MorphologyFilterVertexShader, MorphologyFilterFragmentShader >
 
using ColorMatrixColorFilterPipeline = RenderPipelineT< ColorMatrixColorFilterVertexShader, ColorMatrixColorFilterFragmentShader >
 
using LinearToSrgbFilterPipeline = RenderPipelineT< LinearToSrgbFilterVertexShader, LinearToSrgbFilterFragmentShader >
 
using SrgbToLinearFilterPipeline = RenderPipelineT< SrgbToLinearFilterVertexShader, SrgbToLinearFilterFragmentShader >
 
using GlyphAtlasPipeline = RenderPipelineT< GlyphAtlasVertexShader, GlyphAtlasFragmentShader >
 
using GlyphAtlasColorPipeline = RenderPipelineT< GlyphAtlasVertexShader, GlyphAtlasColorFragmentShader >
 
using PorterDuffBlendPipeline = RenderPipelineT< PorterDuffBlendVertexShader, PorterDuffBlendFragmentShader >
 
using ClipPipeline = RenderPipelineT< ClipVertexShader, ClipFragmentShader >
 
using GeometryColorPipeline = RenderPipelineT< PositionColorVertexShader, VerticesFragmentShader >
 
using YUVToRGBFilterPipeline = RenderPipelineT< YuvToRgbFilterVertexShader, YuvToRgbFilterFragmentShader >
 
using BlendColorPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendColorFragmentShader >
 
using BlendColorBurnPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendColorburnFragmentShader >
 
using BlendColorDodgePipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendColordodgeFragmentShader >
 
using BlendDarkenPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendDarkenFragmentShader >
 
using BlendDifferencePipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendDifferenceFragmentShader >
 
using BlendExclusionPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendExclusionFragmentShader >
 
using BlendHardLightPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendHardlightFragmentShader >
 
using BlendHuePipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendHueFragmentShader >
 
using BlendLightenPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendLightenFragmentShader >
 
using BlendLuminosityPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendLuminosityFragmentShader >
 
using BlendMultiplyPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendMultiplyFragmentShader >
 
using BlendOverlayPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendOverlayFragmentShader >
 
using BlendSaturationPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendSaturationFragmentShader >
 
using BlendScreenPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendScreenFragmentShader >
 
using BlendSoftLightPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendSoftlightFragmentShader >
 
using FramebufferBlendColorPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendColorFragmentShader >
 
using FramebufferBlendColorBurnPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendColorburnFragmentShader >
 
using FramebufferBlendColorDodgePipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendColordodgeFragmentShader >
 
using FramebufferBlendDarkenPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendDarkenFragmentShader >
 
using FramebufferBlendDifferencePipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendDifferenceFragmentShader >
 
using FramebufferBlendExclusionPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendExclusionFragmentShader >
 
using FramebufferBlendHardLightPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendHardlightFragmentShader >
 
using FramebufferBlendHuePipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendHueFragmentShader >
 
using FramebufferBlendLightenPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendLightenFragmentShader >
 
using FramebufferBlendLuminosityPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendLuminosityFragmentShader >
 
using FramebufferBlendMultiplyPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendMultiplyFragmentShader >
 
using FramebufferBlendOverlayPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendOverlayFragmentShader >
 
using FramebufferBlendSaturationPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendSaturationFragmentShader >
 
using FramebufferBlendScreenPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendScreenFragmentShader >
 
using FramebufferBlendSoftLightPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendSoftlightFragmentShader >
 
using PointsComputeShaderPipeline = ComputePipelineBuilder< PointsComputeShader >
 Geometry Pipelines. More...
 
using UvComputeShaderPipeline = ComputePipelineBuilder< UvComputeShader >
 
using PipelineProc = std::shared_ptr< Pipeline< PipelineDescriptor > >(ContentContext::*)(ContentContextOptions) const
 
using PathComponentVariant = std::variant< std::monostate, const LinearPathComponent *, const QuadraticPathComponent *, const CubicPathComponent * >
 
using Point = TPoint< Scalar >
 
using IPoint = TPoint< int64_t >
 
using IPoint32 = TPoint< int32_t >
 
using UintPoint32 = TPoint< uint32_t >
 
using Vector2 = Point
 
using Rect = TRect< Scalar >
 
using IRect = TRect< int64_t >
 
using Scalar = float
 
using Size = TSize< Scalar >
 
using ISize = TSize< int64_t >
 
template<class F , class I >
using MixedOp = typename MixedOp_< F, I >::type
 
using CommandPoolMap = std::unordered_map< uint64_t, std::shared_ptr< CommandPoolVK > >
 
using WaitSet = std::vector< std::shared_ptr< WaitSetEntry > >
 
template<class T >
using SharedHandleVK = std::shared_ptr< SharedObjectVKT< T > >
 
using UniqueAllocatorVMA = fml::UniqueObject< VmaAllocator, AllocatorVMATraits >
 
using UniquePoolVMA = fml::UniqueObject< PoolVMA, PoolVMATraits >
 
using UniqueBufferVMA = fml::UniqueObject< BufferVMA, BufferVMATraits >
 
using UniqueImageVMA = fml::UniqueObject< ImageVMA, ImageVMATraits >
 
using BufferResource = Resource< BufferView >
 
using TextureResource = Resource< std::shared_ptr< const Texture > >
 
using SamplerResource = Resource< std::shared_ptr< const Sampler > >
 
using PipelineMap = std::unordered_map< PipelineDescriptor, PipelineFuture< PipelineDescriptor >, ComparableHash< PipelineDescriptor >, ComparableEqual< PipelineDescriptor > >
 
using ComputePipelineMap = std::unordered_map< ComputePipelineDescriptor, PipelineFuture< ComputePipelineDescriptor >, ComparableHash< ComputePipelineDescriptor >, ComparableEqual< ComputePipelineDescriptor > >
 
using ShaderFunctionMap = std::unordered_map< ShaderKey, std::shared_ptr< const ShaderFunction >, ShaderKey::Hash, ShaderKey::Equal >
 
using CTessellator = std::unique_ptr< TESStesselator, decltype(&DestroyTessellator)>
 
using UniqueEGLImage = fml::UniqueObject< EGLImageWithDisplay, EGLImageWithDisplayTraits >
 
using UniqueEGLImageKHR = fml::UniqueObject< EGLImageKHRWithDisplay, EGLImageKHRWithDisplayTraits >
 
using UniqueGLTexture = fml::UniqueObject< GLTexture, GLTextureTraits >
 
using FontGlyphMap = std::unordered_map< ScaledFont, std::unordered_set< Glyph > >
 

Enumerations

enum  PointStyle {
  PointStyle::kRound,
  PointStyle::kSquare
}
 
enum  BlobShaderType {
  BlobShaderType::kVertex,
  BlobShaderType::kFragment,
  BlobShaderType::kCompute
}
 
enum  StorageMode {
  StorageMode::kHostVisible,
  StorageMode::kDevicePrivate,
  StorageMode::kDeviceTransient
}
 Specified where the allocation resides and how it is used. More...
 
enum  PixelFormat {
  PixelFormat::kUnknown,
  PixelFormat::kA8UNormInt,
  PixelFormat::kR8UNormInt,
  PixelFormat::kR8G8UNormInt,
  PixelFormat::kR8G8B8A8UNormInt,
  PixelFormat::kR8G8B8A8UNormIntSRGB,
  PixelFormat::kB8G8R8A8UNormInt,
  PixelFormat::kB8G8R8A8UNormIntSRGB,
  PixelFormat::kR32G32B32A32Float,
  PixelFormat::kR16G16B16A16Float,
  PixelFormat::kB10G10R10XR,
  PixelFormat::kB10G10R10XRSRGB,
  PixelFormat::kB10G10R10A10XR,
  PixelFormat::kS8UInt,
  PixelFormat::kD24UnormS8Uint,
  PixelFormat::kD32FloatS8UInt
}
 The Pixel formats supported by Impeller. The naming convention denotes the usage of the component, the bit width of that component, and then one or more qualifiers to its interpretation. More...
 
enum  BlendFactor {
  BlendFactor::kZero,
  BlendFactor::kOne,
  BlendFactor::kSourceColor,
  BlendFactor::kOneMinusSourceColor,
  BlendFactor::kSourceAlpha,
  BlendFactor::kOneMinusSourceAlpha,
  BlendFactor::kDestinationColor,
  BlendFactor::kOneMinusDestinationColor,
  BlendFactor::kDestinationAlpha,
  BlendFactor::kOneMinusDestinationAlpha,
  BlendFactor::kSourceAlphaSaturated,
  BlendFactor::kBlendColor,
  BlendFactor::kOneMinusBlendColor,
  BlendFactor::kBlendAlpha,
  BlendFactor::kOneMinusBlendAlpha
}
 
enum  BlendOperation {
  BlendOperation::kAdd,
  BlendOperation::kSubtract,
  BlendOperation::kReverseSubtract
}
 
enum  LoadAction {
  LoadAction::kDontCare,
  LoadAction::kLoad,
  LoadAction::kClear
}
 
enum  StoreAction {
  StoreAction::kDontCare,
  StoreAction::kStore,
  StoreAction::kMultisampleResolve,
  StoreAction::kStoreAndMultisampleResolve
}
 
enum  TextureType {
  TextureType::kTexture2D,
  TextureType::kTexture2DMultisample,
  TextureType::kTextureCube,
  TextureType::kTextureExternalOES
}
 
enum  SampleCount {
  SampleCount::kCount1 = 1,
  SampleCount::kCount4 = 4
}
 
enum  TextureUsage : TextureUsageMask {
  TextureUsage::kUnknown = 0,
  TextureUsage::kShaderRead = 1 << 0,
  TextureUsage::kShaderWrite = 1 << 1,
  TextureUsage::kRenderTarget = 1 << 2
}
 
enum  TextureCoordinateSystem {
  TextureCoordinateSystem::kUploadFromHost,
  TextureCoordinateSystem::kRenderToTexture
}
 
enum  CullMode {
  CullMode::kNone,
  CullMode::kFrontFace,
  CullMode::kBackFace
}
 
enum  IndexType {
  IndexType::kUnknown,
  IndexType::k16bit,
  IndexType::k32bit,
  IndexType::kNone
}
 
enum  PrimitiveType {
  PrimitiveType::kTriangle,
  PrimitiveType::kTriangleStrip,
  PrimitiveType::kLine,
  PrimitiveType::kLineStrip,
  PrimitiveType::kPoint
}
 
enum  PolygonMode {
  PolygonMode::kFill,
  PolygonMode::kLine
}
 
enum  MinMagFilter {
  MinMagFilter::kNearest,
  MinMagFilter::kLinear
}
 
enum  MipFilter {
  MipFilter::kNearest,
  MipFilter::kLinear
}
 
enum  SamplerAddressMode {
  SamplerAddressMode::kClampToEdge,
  SamplerAddressMode::kRepeat,
  SamplerAddressMode::kMirror,
  SamplerAddressMode::kDecal
}
 
enum  ColorWriteMask : uint64_t {
  ColorWriteMask::kNone = 0,
  ColorWriteMask::kRed = 1 << 0,
  ColorWriteMask::kGreen = 1 << 1,
  ColorWriteMask::kBlue = 1 << 2,
  ColorWriteMask::kAlpha = 1 << 3,
  ColorWriteMask::kAll = kRed | kGreen | kBlue | kAlpha
}
 
enum  CompareFunction {
  CompareFunction::kNever,
  CompareFunction::kAlways,
  CompareFunction::kLess,
  CompareFunction::kEqual,
  CompareFunction::kLessEqual,
  CompareFunction::kGreater,
  CompareFunction::kNotEqual,
  CompareFunction::kGreaterEqual
}
 
enum  StencilOperation {
  StencilOperation::kKeep,
  StencilOperation::kZero,
  StencilOperation::kSetToReferenceValue,
  StencilOperation::kIncrementClamp,
  StencilOperation::kDecrementClamp,
  StencilOperation::kInvert,
  StencilOperation::kIncrementWrap,
  StencilOperation::kDecrementWrap
}
 
enum  RuntimeUniformType {
  kBoolean,
  kSignedByte,
  kUnsignedByte,
  kSignedShort,
  kUnsignedShort,
  kSignedInt,
  kUnsignedInt,
  kSignedInt64,
  kUnsignedInt64,
  kHalfFloat,
  kFloat,
  kDouble,
  kSampledImage
}
 
enum  RuntimeShaderStage {
  RuntimeShaderStage::kVertex,
  RuntimeShaderStage::kFragment,
  RuntimeShaderStage::kCompute,
  RuntimeShaderStage::kTessellationControl,
  RuntimeShaderStage::kTessellationEvaluation
}
 
enum  ShaderStage {
  ShaderStage::kUnknown,
  ShaderStage::kVertex,
  ShaderStage::kFragment,
  ShaderStage::kTessellationControl,
  ShaderStage::kTessellationEvaluation,
  ShaderStage::kCompute
}
 
enum  ShaderType {
  ShaderType::kUnknown,
  ShaderType::kVoid,
  ShaderType::kBoolean,
  ShaderType::kSignedByte,
  ShaderType::kUnsignedByte,
  ShaderType::kSignedShort,
  ShaderType::kUnsignedShort,
  ShaderType::kSignedInt,
  ShaderType::kUnsignedInt,
  ShaderType::kSignedInt64,
  ShaderType::kUnsignedInt64,
  ShaderType::kAtomicCounter,
  ShaderType::kHalfFloat,
  ShaderType::kFloat,
  ShaderType::kDouble,
  ShaderType::kStruct,
  ShaderType::kImage,
  ShaderType::kSampledImage,
  ShaderType::kSampler
}
 
enum  DescriptorType {
  DescriptorType::kUniformBuffer,
  DescriptorType::kStorageBuffer,
  DescriptorType::kSampledImage,
  DescriptorType::kImage,
  DescriptorType::kSampler
}
 
enum  CompressionType {
  CompressionType::kLossless,
  CompressionType::kLossy
}
 Additional compression to apply to a texture. This value is ignored on platforms which do not support it. More...
 
enum  GeometryVertexType {
  kPosition,
  kColor,
  kUV
}
 
enum  YUVColorSpace {
  YUVColorSpace::kBT601LimitedRange,
  YUVColorSpace::kBT601FullRange
}
 
enum  BlendMode {
  BlendMode::kClear = 0,
  BlendMode::kSource,
  BlendMode::kDestination,
  BlendMode::kSourceOver,
  BlendMode::kDestinationOver,
  BlendMode::kSourceIn,
  BlendMode::kDestinationIn,
  BlendMode::kSourceOut,
  BlendMode::kDestinationOut,
  BlendMode::kSourceATop,
  BlendMode::kDestinationATop,
  BlendMode::kXor,
  BlendMode::kPlus,
  BlendMode::kModulate,
  BlendMode::kScreen,
  BlendMode::kOverlay,
  BlendMode::kDarken,
  BlendMode::kLighten,
  BlendMode::kColorDodge,
  BlendMode::kColorBurn,
  BlendMode::kHardLight,
  BlendMode::kSoftLight,
  BlendMode::kDifference,
  BlendMode::kExclusion,
  BlendMode::kMultiply,
  BlendMode::kHue,
  BlendMode::kSaturation,
  BlendMode::kColor,
  BlendMode::kLuminosity,
  BlendMode::kLast = kLuminosity
}
 
enum  Cap {
  Cap::kButt,
  Cap::kRound,
  Cap::kSquare
}
 
enum  Join {
  Join::kMiter,
  Join::kRound,
  Join::kBevel
}
 
enum  FillType {
  FillType::kNonZero,
  FillType::kOdd,
  FillType::kPositive,
  FillType::kNegative,
  FillType::kAbsGeqTwo
}
 
enum  Convexity {
  Convexity::kUnknown,
  Convexity::kConvex
}
 
enum  PlaygroundBackend {
  PlaygroundBackend::kMetal,
  PlaygroundBackend::kOpenGLES,
  PlaygroundBackend::kVulkan
}
 
enum  HandleType {
  HandleType::kUnknown,
  HandleType::kTexture,
  HandleType::kBuffer,
  HandleType::kProgram,
  HandleType::kRenderBuffer,
  HandleType::kFrameBuffer
}
 
enum  DebugResourceType {
  DebugResourceType::kTexture,
  DebugResourceType::kBuffer,
  DebugResourceType::kProgram,
  DebugResourceType::kShader,
  DebugResourceType::kRenderBuffer,
  DebugResourceType::kFrameBuffer
}
 
enum  OptionalDeviceExtensionVK : uint32_t {
  OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback,
  OptionalDeviceExtensionVK::kLast
}
 
enum  AttachmentKind {
  AttachmentKind::kColor,
  AttachmentKind::kDepth,
  AttachmentKind::kStencil,
  AttachmentKind::kDepthStencil
}
 
enum  WindingOrder {
  WindingOrder::kClockwise,
  WindingOrder::kCounterClockwise
}
 

Functions

static bool UseColorSourceContents (const std::shared_ptr< VerticesGeometry > &vertices, const Paint &paint)
 
static const ArchiveClassRegistration * RegistrationIfReady (const ArchiveClassRegistration *registration)
 
static constexpr int ToParam (size_t index)
 
static constexpr int ToColumn (size_t index)
 
std::shared_ptr< fml::Mapping > CreateMappingWithCopy (const uint8_t *contents, size_t length)
 
std::shared_ptr< fml::Mapping > CreateMappingFromAllocation (const std::shared_ptr< Allocation > &allocation)
 
std::shared_ptr< fml::Mapping > CreateMappingWithString (std::string string)
 
std::shared_ptr< fml::Mapping > CreateMappingWithString (std::shared_ptr< const std::string > string)
 
template<class ComparableType , class = std::enable_if_t<std::is_base_of_v<ComparableBase, ComparableType>>>
bool DeepComparePointer (const std::shared_ptr< ComparableType > &lhs, const std::shared_ptr< ComparableType > &rhs)
 
template<class Key , class ComparableType , class = std::enable_if_t<std::is_base_of_v<ComparableBase, ComparableType>>>
bool DeepCompareMap (const std::map< Key, std::shared_ptr< ComparableType >> &lhs, const std::map< Key, std::shared_ptr< ComparableType >> &rhs)
 
void ImpellerUnimplemented (const char *method, const char *file, int line)
 
template<class T >
std::future< T > RealizedFuture (T t)
 
std::string SPrintF (const char *format,...)
 
bool HasPrefix (const std::string &string, const std::string &prefix)
 
bool HasSuffix (const std::string &string, const std::string &suffix)
 
std::string StripPrefix (const std::string &string, const std::string &to_strip)
 
class IPLR_CAPABILITY ("mutex") Mutex
 
void ImpellerValidationErrorsSetFatal (bool fatal)
 
void ImpellerValidationBreak (const char *message)
 
constexpr BlobShaderType ToShaderType (fb::Stage stage)
 
std::optional< BlobShaderType > InferShaderTypefromFileExtension (const std::filesystem::path &path)
 
constexpr fb::Stage ToStage (BlobShaderType type)
 
bool Main (const fml::CommandLine &command_line)
 
std::vector< spirv_cross::ID > SortUniforms (const spirv_cross::ParsedIR *ir, const spirv_cross::Compiler *compiler, std::optional< spirv_cross::SPIRType::BaseType > type_filter=std::nullopt, bool include=true)
 Sorts uniform declarations in an IR according to decoration order. More...
 
 _FOR_EACH_CAPTURE_PROPERTY (_CAPTURE_PROPERTY_CAST_DEFINITION)
 
 _FOR_EACH_CAPTURE_PROPERTY (_CAPTURE_PROPERTY_DEFINITION)
 
 _FOR_EACH_CAPTURE_PROPERTY (_CAPTURE_PROPERTY_DECLARATION)
 
constexpr bool StoreActionNeedsResolveTexture (StoreAction action)
 
std::string TextureUsageMaskToString (TextureUsageMask mask)
 
std::string AttachmentToString (const Attachment &attachment)
 
std::string ColorAttachmentToString (const ColorAttachment &color)
 
std::string DepthAttachmentToString (const DepthAttachment &depth)
 
std::string StencilAttachmentToString (const StencilAttachment &stencil)
 
constexpr const char * StorageModeToString (StorageMode mode)
 
constexpr const char * PixelFormatToString (PixelFormat format)
 
constexpr const char * LoadActionToString (LoadAction action)
 
constexpr const char * StoreActionToString (StoreAction action)
 
constexpr bool CanClearAttachment (LoadAction action)
 
constexpr bool CanDiscardAttachmentWhenDone (StoreAction action)
 
constexpr const char * TextureTypeToString (TextureType type)
 
constexpr bool IsMultisampleCapable (TextureType type)
 
constexpr bool TextureUsageIsRenderTarget (TextureUsageMask mask)
 
constexpr const char * TextureUsageToString (TextureUsage usage)
 
constexpr size_t BytesPerPixelForPixelFormat (PixelFormat format)
 
constexpr size_t DefaultUniformAlignment ()
 
constexpr ShaderStage ToShaderStage (RuntimeShaderStage stage)
 
constexpr Vector4 ToVector (Color color)
 
std::string TextureDescriptorToString (const TextureDescriptor &desc)
 
constexpr const char * CompressionTypeToString (CompressionType type)
 
static BlendMode ToBlendMode (flutter::DlBlendMode mode)
 
static Entity::TileMode ToTileMode (flutter::DlTileMode tile_mode)
 
static impeller::SamplerDescriptor ToSamplerDescriptor (const flutter::DlImageSampling options)
 
static impeller::SamplerDescriptor ToSamplerDescriptor (const flutter::DlFilterMode options)
 
static Matrix ToMatrix (const SkMatrix &m)
 
static Paint::Style ToStyle (flutter::DlDrawStyle style)
 
static std::vector< Color > ToColors (const flutter::DlColor colors[], int count)
 
static std::optional< ColorSource::Type > ToColorSourceType (flutter::DlColorSourceType type)
 
static std::shared_ptr< ColorFilter > ToColorFilter (const flutter::DlColorFilter *filter)
 
static FilterContents::BlurStyle ToBlurStyle (flutter::DlBlurStyle blur_style)
 
static std::shared_ptr< ImageFilter > ToImageFilter (const flutter::DlImageFilter *filter)
 
static Entity::ClipOperation ToClipOperation (flutter::DlCanvas::ClipOp clip_op)
 
static sk_sp< SkData > OpenFixtureAsSkData (const char *fixture_name)
 
static Rect ToRect (const SkRect &rect)
 
static VerticesGeometry::VertexMode ToVertexMode (flutter::DlVertexMode mode)
 
std::shared_ptr< impeller::VerticesGeometry > MakeVertices (const flutter::DlVertices *vertices)
 
template<typename PipelineT >
static std::unique_ptr< PipelineT > CreateDefaultPipeline (const Context &context)
 
ContentContextOptions OptionsFromPass (const RenderPass &pass)
 
ContentContextOptions OptionsFromPassAndEntity (const RenderPass &pass, const Entity &entity)
 
std::optional< BlendMode > InvertPorterDuffBlend (BlendMode blend_mode)
 
template<typename TPipeline >
static std::optional< Entity > AdvancedBlend (const FilterInput::Vector &inputs, const ContentContext &renderer, const Entity &entity, const Rect &coverage, BlendMode blend_mode, std::optional< Color > foreground_color, ColorFilterContents::AbsorbOpacity absorb_opacity, PipelineProc pipeline_proc, std::optional< Scalar > alpha)
 
static std::optional< Entity > PipelineBlend (const FilterInput::Vector &inputs, const ContentContext &renderer, const Entity &entity, const Rect &coverage, BlendMode blend_mode, std::optional< Color > foreground_color, ColorFilterContents::AbsorbOpacity absorb_opacity, std::optional< Scalar > alpha)
 
std::shared_ptr< Texture > CreateGradientTexture (const GradientData &gradient_data, const std::shared_ptr< impeller::Context > &context)
 Create a host visible texture that contains the gradient defined by the provided gradient data. More...
 
std::vector< StopData > CreateGradientColors (const std::vector< Color > &colors, const std::vector< Scalar > &stops)
 Populate a vector with the color and stop data for a gradient. More...
 
static std::optional< SamplerAddressMode > TileModeToAddressMode (Entity::TileMode tile_mode, const Capabilities &capabilities)
 
static RenderTarget::AttachmentConfig GetDefaultStencilConfig (bool readable)
 
static EntityPassTarget CreateRenderTarget (ContentContext &renderer, ISize size, bool readable, const Color &clear_color)
 
std::pair< std::vector< Point >, std::vector< uint16_t > > TessellateConvex (Path::Polyline polyline)
 Given a convex polyline, create a triangle fan structure. More...
 
VertexBufferBuilder< TextureFillVertexShader::PerVertexData > ComputeUVGeometryCPU (VertexBufferBuilder< SolidFillVertexShader::PerVertexData > &input, Point texture_origin, Size texture_coverage, Matrix effect_transform)
 Compute UV geometry for a VBB that contains only position geometry. More...
 
GeometryResult ComputeUVGeometryForRect (Rect source_rect, Rect texture_coverage, Matrix effect_transform, const ContentContext &renderer, const Entity &entity, RenderPass &pass)
 
static std::vector< uint16_t > fromFanIndices (const std::vector< Point > &vertices, const std::vector< uint16_t > &indices)
 
static constexpr bool ValidateBlendModes ()
 
const char * BlendModeToString (BlendMode blend_mode)
 
static constexpr Color Min (Color c, float threshold)
 
static constexpr Scalar Luminosity (Vector3 color)
 
static constexpr Vector3 ClipColor (Vector3 color)
 
static constexpr Vector3 SetLuminosity (Vector3 color, Scalar luminosity)
 
static constexpr Scalar Saturation (Vector3 color)
 
static constexpr Vector3 SetSaturation (Vector3 color, Scalar saturation)
 
static constexpr Vector3 ComponentChoose (Vector3 a, Vector3 b, Vector3 value, Scalar cutoff)
 
static constexpr Vector3 ToRGB (Color color)
 
static constexpr Color FromRGB (Vector3 color, Scalar alpha)
 
static constexpr Color DoColorBlend (Color d, Color s, const std::function< Vector3(Vector3, Vector3)> &blend_rgb_func)
 
static constexpr Color DoColorBlendComponents (Color d, Color s, const std::function< Scalar(Scalar, Scalar)> &blend_func)
 
std::string ColorToString (const Color &color)
 
template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color operator+ (T value, const Color &c)
 
template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color operator- (T value, const Color &c)
 
template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color operator* (T value, const Color &c)
 
template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color operator/ (T value, const Color &c)
 
template<class... Args>
static void BM_Polyline (benchmark::State &state, Args &&... args)
 
 BENCHMARK_CAPTURE (BM_Polyline, cubic_polyline, CreateCubic(), false)
 
 BENCHMARK_CAPTURE (BM_Polyline, cubic_polyline_tess, CreateCubic(), true)
 
 BENCHMARK_CAPTURE (BM_Polyline, quad_polyline, CreateQuadratic(), false)
 
 BENCHMARK_CAPTURE (BM_Polyline, quad_polyline_tess, CreateQuadratic(), true)
 
static void AppendColor (const Color &color, GradientData *data)
 
GradientData CreateGradientBuffer (const std::vector< Color > &colors, const std::vector< Scalar > &stops)
 Populate a vector with the interpolated color bytes for the linear gradient described by colors and stops. More...
 
constexpr InternalHalf ScalarToHalf (Scalar f)
 Convert a scalar to a half precision float. More...
 
static Scalar LinearSolve (Scalar t, Scalar p0, Scalar p1)
 
static Scalar QuadraticSolve (Scalar t, Scalar p0, Scalar p1, Scalar p2)
 
static Scalar QuadraticSolveDerivative (Scalar t, Scalar p0, Scalar p1, Scalar p2)
 
static Scalar CubicSolve (Scalar t, Scalar p0, Scalar p1, Scalar p2, Scalar p3)
 
static Scalar CubicSolveDerivative (Scalar t, Scalar p0, Scalar p1, Scalar p2, Scalar p3)
 
static Scalar ApproximateParabolaIntegral (Scalar x)
 
static bool NearEqual (Scalar a, Scalar b, Scalar epsilon)
 
static bool NearZero (Scalar a)
 
static void CubicPathBoundingPopulateValues (std::vector< Scalar > &values, Scalar p1, Scalar p2, Scalar p3, Scalar p4)
 
template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint< F > operator+ (const TPoint< F > &p1, const TPoint< I > &p2)
 
template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint< F > operator+ (const TPoint< I > &p1, const TPoint< F > &p2)
 
template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint< F > operator- (const TPoint< F > &p1, const TPoint< I > &p2)
 
template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint< F > operator- (const TPoint< I > &p1, const TPoint< F > &p2)
 
template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint< F > operator* (const TPoint< F > &p1, const TPoint< I > &p2)
 
template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint< F > operator* (const TPoint< I > &p1, const TPoint< F > &p2)
 
template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint< F > operator/ (const TPoint< F > &p1, const TPoint< I > &p2)
 
template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint< F > operator/ (const TPoint< I > &p1, const TPoint< F > &p2)
 
template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TPoint< T > operator* (U s, const TPoint< T > &p)
 
template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TPoint< T > operator/ (U s, const TPoint< T > &p)
 
template<class T , class U >
constexpr TPoint< T > operator+ (const TSize< U > &s, const TPoint< T > &p)
 
template<class T , class U >
constexpr TPoint< T > operator- (const TSize< U > &s, const TPoint< T > &p)
 
template<class T , class U >
constexpr TPoint< T > operator* (const TSize< U > &s, const TPoint< T > &p)
 
template<class T , class U >
constexpr TPoint< T > operator/ (const TSize< U > &s, const TPoint< T > &p)
 
template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr T Absolute (const T &val)
 
constexpr bool ScalarNearlyZero (Scalar x, Scalar tolerance=kEhCloseEnough)
 
constexpr bool ScalarNearlyEqual (Scalar x, Scalar y, Scalar tolerance=kEhCloseEnough)
 
template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TSize< T > operator* (U s, const TSize< T > &p)
 
template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TSize< T > operator/ (U s, const TSize< T > &p)
 
template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 operator* (U s, const Vector3 &p)
 
template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 operator+ (U s, const Vector3 &p)
 
template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 operator- (U s, const Vector3 &p)
 
template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 operator/ (U s, const Vector3 &p)
 
static size_t GetBytesPerPixel (DecompressedImage::Format format)
 
static std::vector< std::shared_ptr< fml::Mapping > > ShaderLibraryMappingsForPlayground ()
 
static std::vector< std::shared_ptr< fml::Mapping > > ShaderLibraryMappingsForPlayground ()
 
static std::vector< std::shared_ptr< fml::Mapping > > ShaderLibraryMappingsForPlayground ()
 
static std::string FormatWindowTitle (const std::string &test_name)
 
std::string PlaygroundBackendToString (PlaygroundBackend backend)
 
static void PlaygroundKeyCallback (GLFWwindow *window, int key, int scancode, int action, int mods)
 
static std::shared_ptr< Texture > CreateTextureForDecompressedImage (const std::shared_ptr< Context > &context, DecompressedImage &decompressed_image, bool enable_mipmapping)
 
static std::string FormatWindowTitle (const std::string &test_name)
 
static void DeleteFBO (const ProcTableGLES &gl, GLuint fbo, GLenum type)
 
static std::optional< GLuint > ConfigureFBO (const ProcTableGLES &gl, const std::shared_ptr< Texture > &texture, GLenum fbo_type)
 
bool EncodeCommandsInReactor (const std::shared_ptr< Allocator > &transients_allocator, const ReactorGLES &reactor, const std::vector< std::unique_ptr< BlitEncodeGLES >> &commands, const std::string &label)
 
static std::string NormalizeUniformKey (const std::string &key)
 
static std::string CreateUniformMemberKey (const std::string &struct_name, const std::string &member, bool is_array)
 
static std::string CreateUniformMemberKey (const std::string &non_struct_member)
 
static std::string GetGLString (const ProcTableGLES &gl, GLenum name)
 
static std::string GetGLStringi (const ProcTableGLES &gl, GLenum name, int index)
 
static bool DetermineIfES (const std::string &version)
 
static std::optional< Version > DetermineVersion (std::string version)
 
static GLenum ToTarget (DeviceBufferGLES::BindingType type)
 
constexpr GLenum ToMode (PrimitiveType primitive_type)
 
constexpr GLenum ToIndexType (IndexType type)
 
constexpr GLenum ToStencilOp (StencilOperation op)
 
constexpr GLenum ToCompareFunction (CompareFunction func)
 
constexpr GLenum ToBlendFactor (BlendFactor factor)
 
constexpr GLenum ToBlendOperation (BlendOperation op)
 
constexpr std::optional< GLenum > ToVertexAttribType (ShaderType type)
 
constexpr GLenum ToTextureType (TextureType type)
 
constexpr std::optional< GLenum > ToTextureTarget (TextureType type)
 
std::string HandleTypeToString (HandleType type)
 
static std::string GetShaderInfoLog (const ProcTableGLES &gl, GLuint shader)
 
static void LogShaderCompilationFailure (const ProcTableGLES &gl, GLuint shader, const std::string &name, const fml::Mapping &source_mapping, ShaderStage stage)
 
static bool LinkProgram (const ReactorGLES &reactor, const std::shared_ptr< PipelineGLES > &pipeline, const std::shared_ptr< const ShaderFunction > &vert_function, const std::shared_ptr< const ShaderFunction > &frag_function)
 
const char * GLErrorToString (GLenum value)
 
ProcTableGLES::Resolver WrappedResolver (const ProcTableGLES::Resolver &resolver)
 
static const char * FramebufferStatusToString (GLenum status)
 
static const char * AttachmentTypeString (GLint type)
 
static std::string DescribeFramebufferAttachment (const ProcTableGLES &gl, GLenum attachment)
 
static std::optional< GLenum > ToDebugIdentifier (DebugResourceType type)
 
static bool ResourceIsLive (const ProcTableGLES &gl, DebugResourceType type, GLint name)
 
static std::optional< GLuint > CreateGLHandle (const ProcTableGLES &gl, HandleType type)
 
static bool CollectGLHandle (const ProcTableGLES &gl, HandleType type, GLuint handle)
 
static DebugResourceType ToDebugResourceType (HandleType type)
 
void ConfigureBlending (const ProcTableGLES &gl, const ColorAttachmentDescriptor *color)
 
void ConfigureStencil (GLenum face, const ProcTableGLES &gl, const StencilAttachmentDescriptor &stencil, uint32_t stencil_reference)
 
void ConfigureStencil (const ProcTableGLES &gl, const PipelineDescriptor &pipeline, uint32_t stencil_reference)
 
bool EncodeCommandsInReactor (const RenderPassData &pass_data, const std::shared_ptr< Allocator > &transients_allocator, const ReactorGLES &reactor, const std::vector< Command > &commands)
 
static GLint ToParam (MinMagFilter minmag_filter, std::optional< MipFilter > mip_filter=std::nullopt)
 
static GLint ToAddressMode (SamplerAddressMode mode)
 
static ShaderStage ToShaderStage (BlobShaderType type)
 
static std::string GLESShaderNameToShaderKeyName (const std::string &name, ShaderStage stage)
 
static TextureGLES::Type GetTextureTypeFromDescriptor (const TextureDescriptor &desc)
 
HandleType ToHandleType (TextureGLES::Type type)
 
static std::optional< GLenum > ToRenderBufferFormat (PixelFormat format)
 
static GLenum ToAttachmentPoint (TextureGLES::AttachmentPoint point)
 
static bool DeviceSupportsDeviceTransientTargets (id< MTLDevice > device)
 
static bool DeviceHasUnifiedMemoryArchitecture (id< MTLDevice > device)
 
static ISize DeviceMaxTextureSizeSupported (id< MTLDevice > device)
 
static bool SupportsLossyTextureCompression (id< MTLDevice > device)
 
static MTLResourceOptions ToMTLResourceOptions (StorageMode type, bool supports_memoryless_targets, bool supports_uma)
 
static MTLStorageMode ToMTLStorageMode (StorageMode mode, bool supports_memoryless_targets, bool supports_uma)
 
 API_AVAILABLE (ios(14.0), macos(11.0)) static NSString *MTLCommandEncoderErrorStateToString(MTLCommandEncoderErrorState state)
 
static NSString * MTLCommandBufferErrorToString (MTLCommandBufferError code)
 
static bool LogMTLCommandBufferErrorIfPresent (id< MTLCommandBuffer > buffer)
 
static id< MTLCommandBuffer > CreateCommandBuffer (id< MTLCommandQueue > queue)
 
static CommandBuffer::Status ToCommitResult (MTLCommandBufferStatus status)
 
static bool Bind (ComputePassBindingsCache &pass, Allocator &allocator, size_t bind_index, const BufferView &view)
 
static bool Bind (ComputePassBindingsCache &pass, size_t bind_index, const Sampler &sampler, const Texture &texture)
 
static bool DeviceSupportsFramebufferFetch (id< MTLDevice > device)
 
static bool DeviceSupportsComputeSubgroups (id< MTLDevice > device)
 
static std::unique_ptr< Capabilities > InferMetalCapabilities (id< MTLDevice > device, PixelFormat color_format)
 
static NSArray< id< MTLLibrary > > * MTLShaderLibraryFromFilePaths (id< MTLDevice > device, const std::vector< std::string > &libraries_paths)
 
static NSArray< id< MTLLibrary > > * MTLShaderLibraryFromFileData (id< MTLDevice > device, const std::vector< std::shared_ptr< fml::Mapping >> &libraries_data, const std::string &label)
 
static id< MTLDevice > CreateMetalDevice ()
 
static id< MTLCommandQueue > CreateMetalCommandQueue (id< MTLDevice > device)
 
constexpr PixelFormat FromMTLPixelFormat (MTLPixelFormat format)
 
MTLPixelFormat SafeMTLPixelFormatDepth24Unorm_Stencil8 ()
 
MTLPixelFormat SafeMTLPixelFormatBGR10_XR_sRGB ()
 
MTLPixelFormat SafeMTLPixelFormatBGR10_XR ()
 
MTLPixelFormat SafeMTLPixelFormatBGRA10_XR ()
 
constexpr MTLPixelFormat ToMTLPixelFormat (PixelFormat format)
 
constexpr MTLBlendFactor ToMTLBlendFactor (BlendFactor type)
 
constexpr MTLPrimitiveType ToMTLPrimitiveType (PrimitiveType type)
 
constexpr MTLTriangleFillMode ToMTLTriangleFillMode (PolygonMode mode)
 
constexpr MTLIndexType ToMTLIndexType (IndexType type)
 
constexpr MTLCullMode ToMTLCullMode (CullMode mode)
 
constexpr MTLBlendOperation ToMTLBlendOperation (BlendOperation type)
 
constexpr MTLColorWriteMask ToMTLColorWriteMask (std::underlying_type_t< ColorWriteMask > type)
 
constexpr MTLCompareFunction ToMTLCompareFunction (CompareFunction func)
 
constexpr MTLStencilOperation ToMTLStencilOperation (StencilOperation op)
 
constexpr MTLLoadAction ToMTLLoadAction (LoadAction action)
 
constexpr LoadAction FromMTLLoadAction (MTLLoadAction action)
 
constexpr MTLStoreAction ToMTLStoreAction (StoreAction action)
 
constexpr StoreAction FromMTLStoreAction (MTLStoreAction action)
 
constexpr MTLSamplerMinMagFilter ToMTLSamplerMinMagFilter (MinMagFilter filter)
 
constexpr MTLSamplerMipFilter ToMTLSamplerMipFilter (MipFilter filter)
 
constexpr MTLSamplerAddressMode ToMTLSamplerAddressMode (SamplerAddressMode mode)
 
MTLClearColor ToMTLClearColor (const Color &color)
 
constexpr MTLTextureType ToMTLTextureType (TextureType type)
 
MTLRenderPipelineColorAttachmentDescriptor * ToMTLRenderPipelineColorAttachmentDescriptor (ColorAttachmentDescriptor descriptor)
 
MTLDepthStencilDescriptor * ToMTLDepthStencilDescriptor (std::optional< DepthAttachmentDescriptor > depth, std::optional< StencilAttachmentDescriptor > front, std::optional< StencilAttachmentDescriptor > back)
 
MTLTextureDescriptor * ToMTLTextureDescriptor (const TextureDescriptor &desc)
 
MTLStencilDescriptor * ToMTLStencilDescriptor (const StencilAttachmentDescriptor &descriptor)
 
static MTLRenderPipelineDescriptor * GetMTLRenderPipelineDescriptor (const PipelineDescriptor &desc)
 
static MTLComputePipelineDescriptor * GetMTLComputePipelineDescriptor (const ComputePipelineDescriptor &desc)
 
static id< MTLDepthStencilState > CreateDepthStencilDescriptor (const PipelineDescriptor &desc, id< MTLDevice > device)
 
static bool ConfigureResolveTextureAttachment (const Attachment &desc, MTLRenderPassAttachmentDescriptor *attachment)
 
static bool ConfigureAttachment (const Attachment &desc, MTLRenderPassAttachmentDescriptor *attachment)
 
static bool ConfigureColorAttachment (const ColorAttachment &desc, MTLRenderPassColorAttachmentDescriptor *attachment)
 
static bool ConfigureDepthAttachment (const DepthAttachment &desc, MTLRenderPassDepthAttachmentDescriptor *attachment)
 
static bool ConfigureStencilAttachment (const StencilAttachment &desc, MTLRenderPassStencilAttachmentDescriptor *attachment)
 
static MTLRenderPassDescriptor * ToMTLRenderPassDescriptor (const RenderTarget &desc)
 
static bool Bind (PassBindingsCache &pass, Allocator &allocator, ShaderStage stage, size_t bind_index, const BufferView &view)
 
static bool Bind (PassBindingsCache &pass, ShaderStage stage, size_t bind_index, const Sampler &sampler, const Texture &texture)
 
static MTLFunctionType ToMTLFunctionType (ShaderStage stage)
 
static std::optional< RenderTarget > WrapTextureWithRenderTarget (Allocator &allocator, id< MTLTexture > texture, bool requires_blit, std::optional< IRect > clip_rect)
 
std::shared_ptr< Texture > WrapperMTL (TextureDescriptor desc, const void *mtl_texture, std::function< void()> deletion_proc)
 
std::shared_ptr< Texture > WrapTextureMTL (TextureDescriptor desc, const void *mtl_texture, std::function< void()> deletion_proc=nullptr)
 
static MTLVertexFormat ReadStageInputFormat (const ShaderStageIOSlot &input)
 
static constexpr vk::Flags< vk::MemoryPropertyFlagBits > ToVKBufferMemoryPropertyFlags (StorageMode mode)
 
static VmaAllocationCreateFlags ToVmaAllocationBufferCreateFlags (StorageMode mode)
 
static PoolVMA CreateBufferPool (VmaAllocator allocator)
 
static constexpr vk::ImageUsageFlags ToVKImageUsageFlags (PixelFormat format, TextureUsageMask usage, StorageMode mode, bool supports_memoryless_textures)
 
static constexpr VmaMemoryUsage ToVMAMemoryUsage ()
 
static constexpr vk::Flags< vk::MemoryPropertyFlagBits > ToVKTextureMemoryPropertyFlags (StorageMode mode, bool supports_memoryless_textures)
 
static VmaAllocationCreateFlags ToVmaAllocationCreateFlags (StorageMode mode)
 
static void InsertImageMemoryBarrier (const vk::CommandBuffer &cmd, const vk::Image &image, vk::AccessFlags src_access_mask, vk::AccessFlags dst_access_mask, vk::ImageLayout old_layout, vk::ImageLayout new_layout, vk::PipelineStageFlags src_stage, vk::PipelineStageFlags dst_stage, uint32_t base_mip_level, uint32_t mip_level_count=1u)
 
static const char * GetDeviceExtensionName (OptionalDeviceExtensionVK ext)
 
static void IterateOptionalDeviceExtensions (const std::function< void(OptionalDeviceExtensionVK)> &it)
 
static std::optional< std::set< std::string > > GetSupportedDeviceExtensions (const vk::PhysicalDevice &physical_device)
 
static bool HasSuitableColorFormat (const vk::PhysicalDevice &device, vk::Format format)
 
static bool HasSuitableDepthStencilFormat (const vk::PhysicalDevice &device, vk::Format format)
 
static bool PhysicalDeviceSupportsRequiredFormats (const vk::PhysicalDevice &device)
 
static bool HasRequiredProperties (const vk::PhysicalDevice &physical_device)
 
static bool HasRequiredQueues (const vk::PhysicalDevice &physical_device)
 
static std::unordered_map< const ContextVK *, std::vector< std::weak_ptr< CommandPoolVK > > > g_all_pools_map IPLR_GUARDED_BY (g_all_pools_map_mutex)
 
static bool UpdateBindingLayouts (const Bindings &bindings, const vk::CommandBuffer &buffer)
 
static bool UpdateBindingLayouts (const ComputeCommand &command, const vk::CommandBuffer &buffer)
 
static bool UpdateBindingLayouts (const std::vector< ComputeCommand > &commands, const vk::CommandBuffer &buffer)
 
static bool AllocateAndBindDescriptorSets (const ContextVK &context, const ComputeCommand &command, CommandEncoderVK &encoder, const ComputePipelineVK &pipeline, size_t command_count)
 
bool HasValidationLayers ()
 
static std::optional< vk::PhysicalDevice > PickPhysicalDevice (const CapabilitiesVK &caps, const vk::Instance &instance)
 
static std::vector< vk::DeviceQueueCreateInfo > GetQueueCreateInfos (std::initializer_list< QueueIndexVK > queues)
 
static std::optional< QueueIndexVK > PickQueue (const vk::PhysicalDevice &device, vk::QueueFlagBits flags)
 
static std::string JoinLabels (const VkDebugUtilsLabelEXT *labels, size_t count)
 
static std::string JoinVKDebugUtilsObjectNameInfoEXT (const VkDebugUtilsObjectNameInfoEXT *names, size_t count)
 
static vk::UniqueDescriptorPool CreatePool (const vk::Device &device, uint32_t pool_count)
 
static std::vector< vk::Fence > GetFencesForWaitSet (const WaitSet &set)
 
vk::PipelineDepthStencilStateCreateInfo ToVKPipelineDepthStencilStateCreateInfo (std::optional< DepthAttachmentDescriptor > depth, std::optional< StencilAttachmentDescriptor > front, std::optional< StencilAttachmentDescriptor > back)
 
constexpr vk::SampleCountFlagBits ToVKSampleCountFlagBits (SampleCount count)
 
constexpr vk::BlendFactor ToVKBlendFactor (BlendFactor factor)
 
constexpr vk::BlendOp ToVKBlendOp (BlendOperation op)
 
constexpr vk::ColorComponentFlags ToVKColorComponentFlags (std::underlying_type_t< ColorWriteMask > type)
 
constexpr vk::PipelineColorBlendAttachmentState ToVKPipelineColorBlendAttachmentState (const ColorAttachmentDescriptor &desc)
 
constexpr std::optional< vk::ShaderStageFlagBits > ToVKShaderStageFlagBits (ShaderStage stage)
 
constexpr vk::Format ToVKImageFormat (PixelFormat format)
 
constexpr PixelFormat ToPixelFormat (vk::Format format)
 
constexpr vk::SampleCountFlagBits ToVKSampleCount (SampleCount sample_count)
 
constexpr vk::Filter ToVKSamplerMinMagFilter (MinMagFilter filter)
 
constexpr vk::SamplerMipmapMode ToVKSamplerMipmapMode (MipFilter filter)
 
constexpr vk::SamplerAddressMode ToVKSamplerAddressMode (SamplerAddressMode mode)
 
constexpr vk::ShaderStageFlags ToVkShaderStage (ShaderStage stage)
 
constexpr vk::DescriptorType ToVKDescriptorType (DescriptorType type)
 
constexpr vk::DescriptorSetLayoutBinding ToVKDescriptorSetLayoutBinding (const DescriptorSetLayout &layout)
 
constexpr vk::AttachmentLoadOp ToVKAttachmentLoadOp (LoadAction load_action)
 
constexpr vk::AttachmentStoreOp ToVKAttachmentStoreOp (StoreAction store_action)
 
constexpr vk::IndexType ToVKIndexType (IndexType index_type)
 
constexpr vk::PolygonMode ToVKPolygonMode (PolygonMode mode)
 
constexpr vk::PrimitiveTopology ToVKPrimitiveTopology (PrimitiveType primitive)
 
constexpr bool PixelFormatIsDepthStencil (PixelFormat format)
 
constexpr AttachmentKind AttachmentKindFromFormat (PixelFormat format)
 
constexpr vk::AttachmentDescription CreateAttachmentDescription (PixelFormat format, SampleCount sample_count, LoadAction load_action, StoreAction store_action, vk::ImageLayout current_layout)
 
constexpr vk::CullModeFlags ToVKCullModeFlags (CullMode mode)
 
constexpr vk::CompareOp ToVKCompareOp (CompareFunction op)
 
constexpr vk::StencilOp ToVKStencilOp (StencilOperation op)
 
constexpr vk::StencilOpState ToVKStencilOpState (const StencilAttachmentDescriptor &desc)
 
constexpr vk::ImageAspectFlags ToVKImageAspectFlags (PixelFormat format)
 
constexpr uint32_t ToArrayLayerCount (TextureType type)
 
constexpr vk::ImageViewType ToVKImageViewType (TextureType type)
 
constexpr vk::ImageCreateFlags ToVKImageCreateFlags (TextureType type)
 
constexpr vk::ImageAspectFlags ToImageAspectFlags (PixelFormat format)
 
static bool VerifyExistingCache (const fml::Mapping &mapping, const CapabilitiesVK &caps)
 
static std::shared_ptr< fml::Mapping > DecorateCacheWithMetadata (std::shared_ptr< fml::Mapping > data)
 
static std::unique_ptr< fml::Mapping > RemoveMetadataFromCache (std::unique_ptr< fml::Mapping > data)
 
static std::unique_ptr< fml::Mapping > OpenCacheFile (const fml::UniqueFD &base_directory, const std::string &cache_file_name, const CapabilitiesVK &caps)
 
static vk::AttachmentDescription CreatePlaceholderAttachmentDescription (PixelFormat format, SampleCount sample_count)
 Creates an attachment description that does just enough to ensure render pass compatibility with the pass associated later with the framebuffer. More...
 
static vk::UniqueRenderPass CreateCompatRenderPassForPipeline (const vk::Device &device, const PipelineDescriptor &desc)
 
constexpr vk::FrontFace ToVKFrontFace (WindingOrder order)
 
static vk::PipelineCreationFeedbackEXT EmptyFeedback ()
 
static void ReportPipelineCreationFeedbackToLog (std::stringstream &stream, const vk::PipelineCreationFeedbackEXT &feedback)
 
static void ReportPipelineCreationFeedbackToLog (const PipelineDescriptor &desc, const vk::PipelineCreationFeedbackCreateInfoEXT &feedback)
 
static void ReportPipelineCreationFeedbackToTrace (const PipelineDescriptor &desc, const vk::PipelineCreationFeedbackCreateInfoEXT &feedback)
 
static void ReportPipelineCreationFeedback (const PipelineDescriptor &desc, const vk::PipelineCreationFeedbackCreateInfoEXT &feedback)
 
static vk::AttachmentDescription CreateAttachmentDescription (const Attachment &attachment, const std::shared_ptr< Texture > Attachment::*texture_ptr)
 
static void SetTextureLayout (const Attachment &attachment, const vk::AttachmentDescription &attachment_desc, const std::shared_ptr< CommandBufferVK > &command_buffer, const std::shared_ptr< Texture > Attachment::*texture_ptr)
 
static vk::ClearColorValue VKClearValueFromColor (Color color)
 
static vk::ClearDepthStencilValue VKClearValueFromDepthStencil (uint32_t stencil, Scalar depth)
 
static std::vector< vk::ClearValue > GetVKClearValues (const RenderTarget &target)
 
static bool UpdateBindingLayouts (const Bindings &bindings, const vk::CommandBuffer &buffer)
 
static bool UpdateBindingLayouts (const Command &command, const vk::CommandBuffer &buffer)
 
static bool UpdateBindingLayouts (const std::vector< Command > &commands, const vk::CommandBuffer &buffer)
 
static bool AllocateAndBindDescriptorSets (const ContextVK &context, const Command &command, CommandEncoderVK &encoder, const PipelineVK &pipeline, size_t command_count)
 
static void SetViewportAndScissor (const Command &command, const vk::CommandBuffer &cmd_buffer, PassBindingsCache &cmd_buffer_cache, const ISize &target_size)
 
static bool EncodeCommand (const Context &context, const Command &command, CommandEncoderVK &encoder, PassBindingsCache &command_buffer_cache, const ISize &target_size, size_t command_count)
 
static ShaderStage ToShaderStage (BlobShaderType type)
 
static std::string VKShaderNameToShaderKeyName (const std::string &name, ShaderStage stage)
 
static bool IsMappingSPIRV (const fml::Mapping &mapping)
 
template<class T >
auto MakeSharedVK (vk::UniqueHandle< T, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE > handle)
 
static bool ContainsFormat (const std::vector< vk::SurfaceFormatKHR > &formats, vk::SurfaceFormatKHR format)
 
static std::optional< vk::SurfaceFormatKHR > ChooseSurfaceFormat (const std::vector< vk::SurfaceFormatKHR > &formats, PixelFormat preference)
 
static std::optional< vk::CompositeAlphaFlagBitsKHR > ChooseAlphaCompositionMode (vk::CompositeAlphaFlagsKHR flags)
 
static std::optional< vk::Queue > ChoosePresentQueue (const vk::PhysicalDevice &physical_device, const vk::Device &device, const vk::SurfaceKHR &surface)
 
vk::Format ToVertexDescriptorFormat (const ShaderStageIOSlot &input)
 
template<typename T >
static std::shared_ptr< DeviceBuffer > CreateDeviceBuffer (const std::shared_ptr< Context > &context, const std::string &label, StorageMode storage_mode=StorageMode::kDevicePrivate)
 
PipelineFuture< PipelineDescriptor > CreatePipelineFuture (const Context &context, std::optional< PipelineDescriptor > desc)
 
PipelineFuture< ComputePipelineDescriptor > CreatePipelineFuture (const Context &context, std::optional< ComputePipelineDescriptor > desc)
 
static RuntimeUniformType ToType (fb::UniformDataType type)
 
static RuntimeShaderStage ToShaderStage (fb::Stage stage)
 
PathBuilder * CreatePathBuilder ()
 
void DestroyPathBuilder (PathBuilder *builder)
 
void MoveTo (PathBuilder *builder, Scalar x, Scalar y)
 
void LineTo (PathBuilder *builder, Scalar x, Scalar y)
 
void CubicTo (PathBuilder *builder, Scalar x1, Scalar y1, Scalar x2, Scalar y2, Scalar x3, Scalar y3)
 
void Close (PathBuilder *builder)
 
struct Vertices * Tessellate (PathBuilder *builder, int fill_type, Scalar tolerance)
 
void DestroyVertices (Vertices *vertices)
 
static void * HeapAlloc (void *userData, unsigned int size)
 
static void * HeapRealloc (void *userData, void *ptr, unsigned int size)
 
static void HeapFree (void *userData, void *ptr)
 
static int ToTessWindingRule (FillType fill_type)
 
void DestroyTessellator (TESStesselator *tessellator)
 
static Font ToFont (const SkTextBlobRunIterator &run)
 
static Rect ToRect (const SkRect &rect)
 
std::shared_ptr< TextFrame > MakeTextFrameFromTextBlobSkia (const sk_sp< SkTextBlob > &blob)
 
static size_t PairsFitInAtlasOfSize (const std::vector< FontGlyphPair > &pairs, const ISize &atlas_size, std::vector< Rect > &glyph_positions, const std::shared_ptr< RectanglePacker > &rect_packer)
 
static bool CanAppendToExistingAtlas (const std::shared_ptr< GlyphAtlas > &atlas, const std::vector< FontGlyphPair > &extra_pairs, std::vector< Rect > &glyph_positions, ISize atlas_size, const std::shared_ptr< RectanglePacker > &rect_packer)
 
static ISize OptimumAtlasSizeForFontGlyphPairs (const std::vector< FontGlyphPair > &pairs, std::vector< Rect > &glyph_positions, const std::shared_ptr< GlyphAtlasContext > &atlas_context, GlyphAtlas::Type type, const ISize &max_texture_size)
 
static void DrawGlyph (SkCanvas *canvas, const ScaledFont &scaled_font, const Glyph &glyph, const Rect &location, bool has_color)
 
static bool UpdateAtlasBitmap (const GlyphAtlas &atlas, const std::shared_ptr< SkBitmap > &bitmap, const std::vector< FontGlyphPair > &new_pairs)
 
static std::shared_ptr< SkBitmap > CreateAtlasBitmap (const GlyphAtlas &atlas, const ISize &atlas_size)
 
static bool UpdateGlyphTextureAtlas (std::shared_ptr< SkBitmap > bitmap, const std::shared_ptr< Texture > &texture)
 
static std::shared_ptr< Texture > UploadGlyphTextureAtlas (const std::shared_ptr< Allocator > &allocator, std::shared_ptr< SkBitmap > bitmap, const ISize &atlas_size, PixelFormat format)
 
std::shared_ptr< TextFrame > MakeTextFrameSTB (const std::shared_ptr< TypefaceSTB > &typeface_stb, Font::Metrics metrics, const std::string &text)
 
static size_t PairsFitInAtlasOfSize (const std::vector< FontGlyphPair > &pairs, const ISize &atlas_size, std::vector< Rect > &glyph_positions, const std::shared_ptr< RectanglePacker > &rect_packer)
 
static bool CanAppendToExistingAtlas (const std::shared_ptr< GlyphAtlas > &atlas, const std::vector< FontGlyphPair > &extra_pairs, std::vector< Rect > &glyph_positions, ISize atlas_size, const std::shared_ptr< RectanglePacker > &rect_packer)
 
static ISize OptimumAtlasSizeForFontGlyphPairs (const std::vector< FontGlyphPair > &pairs, std::vector< Rect > &glyph_positions, const std::shared_ptr< GlyphAtlasContext > &atlas_context, GlyphAtlas::Type type, const ISize &max_texture_size)
 
static void DrawGlyph (BitmapSTB *bitmap, const ScaledFont &scaled_font, const Glyph &glyph, const Rect &location, bool has_color)
 
static bool UpdateAtlasBitmap (const GlyphAtlas &atlas, const std::shared_ptr< BitmapSTB > &bitmap, const std::vector< FontGlyphPair > &new_pairs)
 
static std::shared_ptr< BitmapSTB > CreateAtlasBitmap (const GlyphAtlas &atlas, const ISize &atlas_size)
 
static bool UpdateGlyphTextureAtlas (std::shared_ptr< BitmapSTB > &bitmap, const std::shared_ptr< Texture > &texture)
 
static std::shared_ptr< Texture > UploadGlyphTextureAtlas (const std::shared_ptr< Allocator > &allocator, std::shared_ptr< BitmapSTB > &bitmap, const ISize &atlas_size, PixelFormat format)
 

Variables

static const char * kElementsWindowName = "Elements"
 
static const char * kPropertiesWindowName = "Properties"
 
static const std::initializer_list< std::string > kSupportedDocuments
 
static const auto kPropertiesProcTable
 
constexpr ColorMatrix kColorInversion
 A color matrix which inverts colors. More...
 
static constexpr const char * kArchivePrimaryKeyColumnName = "primary_key"
 
static constexpr const char * kVectorKeys = "keys"
 
static std::atomic_size_t sLastID
 
static std::atomic_int32_t sValidationLogsDisabledCount = 0
 
static bool sValidationLogsAreFatal = false
 
constexpr std::array< std::array< Scalar, 5 >, 15 > kPorterDuffCoefficients
 
constexpr Matrix kMatrixBT601LimitedRange
 
constexpr Matrix kMatrixBT601FullRange
 
static constexpr const char * kBlendModeNames []
 
constexpr float kE = 2.7182818284590452354f
 
constexpr float kLog2_E = 1.4426950408889634074f
 
constexpr float kLog10_E = 0.43429448190325182765f
 
constexpr float klogE_2 = 0.69314718055994530942f
 
constexpr float klogE_10 = 2.30258509299404568402f
 
constexpr float kPi = 3.14159265358979323846f
 
constexpr float k2Pi = 6.28318530717958647693f
 
constexpr float kPiOver2 = 1.57079632679489661923f
 
constexpr float kPiOver4 = 0.78539816339744830962f
 
constexpr float k1OverPi = 0.31830988618379067154f
 
constexpr float k2OverPi = 0.63661977236758134308f
 
constexpr float k2OverSqrtPi = 1.12837916709551257390f
 
constexpr float kSqrt2 = 1.41421356237309504880f
 
constexpr float k1OverSqrt2 = 0.70710678118654752440f
 
constexpr float kPhi = 1.61803398874989484820f
 
constexpr float kEhCloseEnough = 1e-3f
 
static Tessellator tess
 
static constexpr Scalar kDefaultCurveTolerance = .1f
 
constexpr static float kKernelRadiusPerSigma = 1.73205080757
 
static const std::vector< std::string > kSkipTests
 
static std::atomic_bool gShouldOpenNewPlaygrounds = true
 
static constexpr const char * kInstanceLayer = "ImpellerInstance"
 
static bool kResetOnBackgroundThread = false
 
FML_THREAD_LOCAL fml::ThreadLocalUniquePtr< CommandPoolMap > tls_command_pool_map
 
static Mutex g_all_pools_map_mutex
 
static bool gHasValidationLayers = false
 
static constexpr vk::AttachmentReference kUnusedAttachmentReference
 
constexpr size_t kImageSizeThresholdForDedicatedMemoryAllocation
 
static constexpr const char * kPipelineCacheFileName
 
static constexpr size_t kMaxFramesInFlight = 3u
 
static constexpr size_t kPollFramesForOrientation = 1u
 
static const TESSalloc kAlloc
 
static constexpr Scalar kScaleSize = 100000.0f
 
constexpr auto kPadding = 2
 

Typedef Documentation

◆ BlendColorBurnPipeline

using impeller::BlendColorBurnPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendColorburnFragmentShader>

Definition at line 199 of file content_context.h.

◆ BlendColorDodgePipeline

using impeller::BlendColorDodgePipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendColordodgeFragmentShader>

Definition at line 202 of file content_context.h.

◆ BlendColorPipeline

using impeller::BlendColorPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendColorFragmentShader>

Definition at line 196 of file content_context.h.

◆ BlendDarkenPipeline

using impeller::BlendDarkenPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendDarkenFragmentShader>

Definition at line 204 of file content_context.h.

◆ BlendDifferencePipeline

using impeller::BlendDifferencePipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendDifferenceFragmentShader>

Definition at line 207 of file content_context.h.

◆ BlendExclusionPipeline

using impeller::BlendExclusionPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendExclusionFragmentShader>

Definition at line 210 of file content_context.h.

◆ BlendHardLightPipeline

using impeller::BlendHardLightPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendHardlightFragmentShader>

Definition at line 213 of file content_context.h.

◆ BlendHuePipeline

using impeller::BlendHuePipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendHueFragmentShader>

Definition at line 215 of file content_context.h.

◆ BlendLightenPipeline

using impeller::BlendLightenPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendLightenFragmentShader>

Definition at line 218 of file content_context.h.

◆ BlendLuminosityPipeline

using impeller::BlendLuminosityPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendLuminosityFragmentShader>

Definition at line 221 of file content_context.h.

◆ BlendMultiplyPipeline

using impeller::BlendMultiplyPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendMultiplyFragmentShader>

Definition at line 224 of file content_context.h.

◆ BlendOverlayPipeline

using impeller::BlendOverlayPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendOverlayFragmentShader>

Definition at line 227 of file content_context.h.

◆ BlendPipeline

using impeller::BlendPipeline = typedef RenderPipelineT<BlendVertexShader, BlendFragmentShader>

Definition at line 152 of file content_context.h.

◆ BlendSaturationPipeline

using impeller::BlendSaturationPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendSaturationFragmentShader>

Definition at line 230 of file content_context.h.

◆ BlendScreenPipeline

using impeller::BlendScreenPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendScreenFragmentShader>

Definition at line 232 of file content_context.h.

◆ BlendSoftLightPipeline

using impeller::BlendSoftLightPipeline = typedef RenderPipelineT<AdvancedBlendVertexShader, AdvancedBlendSoftlightFragmentShader>

Definition at line 235 of file content_context.h.

◆ BorderMaskBlurPipeline

using impeller::BorderMaskBlurPipeline = typedef RenderPipelineT<BorderMaskBlurVertexShader, BorderMaskBlurFragmentShader>

Definition at line 166 of file content_context.h.

◆ BufferResource

using impeller::BufferResource = typedef Resource<BufferView>

Definition at line 60 of file command.h.

◆ ClipPipeline

using impeller::ClipPipeline = typedef RenderPipelineT<ClipVertexShader, ClipFragmentShader>

Definition at line 187 of file content_context.h.

◆ Clock

using impeller::Clock = typedef std::chrono::high_resolution_clock

Definition at line 13 of file timing.h.

◆ ColorMatrixColorFilterPipeline

using impeller::ColorMatrixColorFilterPipeline = typedef RenderPipelineT<ColorMatrixColorFilterVertexShader, ColorMatrixColorFilterFragmentShader>

Definition at line 172 of file content_context.h.

◆ CommandPoolMap

using impeller::CommandPoolMap = typedef std::unordered_map<uint64_t, std::shared_ptr<CommandPoolVK> >

Definition at line 133 of file command_pool_vk.cc.

◆ ComputePipelineMap

using impeller::ComputePipelineMap = typedef std::unordered_map<ComputePipelineDescriptor, PipelineFuture<ComputePipelineDescriptor>, ComparableHash<ComputePipelineDescriptor>, ComparableEqual<ComputePipelineDescriptor> >

Definition at line 27 of file pipeline_library.h.

◆ ConicalGradientFillPipeline

using impeller::ConicalGradientFillPipeline = typedef RenderPipelineT<GradientFillVertexShader, ConicalGradientFillFragmentShader>

Definition at line 135 of file content_context.h.

◆ ConicalGradientSSBOFillPipeline

using impeller::ConicalGradientSSBOFillPipeline = typedef RenderPipelineT<GradientFillVertexShader, ConicalGradientSsboFillFragmentShader>

Definition at line 143 of file content_context.h.

◆ CTessellator

using impeller::CTessellator = typedef std::unique_ptr<TESStesselator, decltype(&DestroyTessellator)>

Definition at line 22 of file tessellator.h.

◆ FontGlyphMap

using impeller::FontGlyphMap = typedef std::unordered_map<ScaledFont, std::unordered_set<Glyph> >

Definition at line 28 of file font_glyph_pair.h.

◆ FramebufferBlendColorBurnPipeline

using impeller::FramebufferBlendColorBurnPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendColorburnFragmentShader>

Definition at line 242 of file content_context.h.

◆ FramebufferBlendColorDodgePipeline

using impeller::FramebufferBlendColorDodgePipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendColordodgeFragmentShader>

Definition at line 245 of file content_context.h.

◆ FramebufferBlendColorPipeline

using impeller::FramebufferBlendColorPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendColorFragmentShader>

Definition at line 239 of file content_context.h.

◆ FramebufferBlendDarkenPipeline

using impeller::FramebufferBlendDarkenPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendDarkenFragmentShader>

Definition at line 248 of file content_context.h.

◆ FramebufferBlendDifferencePipeline

using impeller::FramebufferBlendDifferencePipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendDifferenceFragmentShader>

Definition at line 251 of file content_context.h.

◆ FramebufferBlendExclusionPipeline

using impeller::FramebufferBlendExclusionPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendExclusionFragmentShader>

Definition at line 254 of file content_context.h.

◆ FramebufferBlendHardLightPipeline

using impeller::FramebufferBlendHardLightPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendHardlightFragmentShader>

Definition at line 257 of file content_context.h.

◆ FramebufferBlendHuePipeline

using impeller::FramebufferBlendHuePipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendHueFragmentShader>

Definition at line 260 of file content_context.h.

◆ FramebufferBlendLightenPipeline

using impeller::FramebufferBlendLightenPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendLightenFragmentShader>

Definition at line 263 of file content_context.h.

◆ FramebufferBlendLuminosityPipeline

using impeller::FramebufferBlendLuminosityPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendLuminosityFragmentShader>

Definition at line 266 of file content_context.h.

◆ FramebufferBlendMultiplyPipeline

using impeller::FramebufferBlendMultiplyPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendMultiplyFragmentShader>

Definition at line 269 of file content_context.h.

◆ FramebufferBlendOverlayPipeline

using impeller::FramebufferBlendOverlayPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendOverlayFragmentShader>

Definition at line 272 of file content_context.h.

◆ FramebufferBlendSaturationPipeline

using impeller::FramebufferBlendSaturationPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendSaturationFragmentShader>

Definition at line 275 of file content_context.h.

◆ FramebufferBlendScreenPipeline

using impeller::FramebufferBlendScreenPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendScreenFragmentShader>

Definition at line 278 of file content_context.h.

◆ FramebufferBlendSoftLightPipeline

using impeller::FramebufferBlendSoftLightPipeline = typedef RenderPipelineT<FramebufferBlendVertexShader, FramebufferBlendSoftlightFragmentShader>

Definition at line 281 of file content_context.h.

◆ GaussianBlurDecalPipeline

using impeller::GaussianBlurDecalPipeline = typedef RenderPipelineT<GaussianBlurVertexShader, GaussianBlurNoalphaDecalFragmentShader>

Definition at line 161 of file content_context.h.

◆ GaussianBlurPipeline

using impeller::GaussianBlurPipeline = typedef RenderPipelineT<GaussianBlurVertexShader, GaussianBlurNoalphaNodecalFragmentShader>

Definition at line 164 of file content_context.h.

◆ GeometryColorPipeline

using impeller::GeometryColorPipeline = typedef RenderPipelineT<PositionColorVertexShader, VerticesFragmentShader>

Definition at line 190 of file content_context.h.

◆ GlyphAtlasColorPipeline

using impeller::GlyphAtlasColorPipeline = typedef RenderPipelineT<GlyphAtlasVertexShader, GlyphAtlasColorFragmentShader>

Definition at line 182 of file content_context.h.

◆ GlyphAtlasPipeline

using impeller::GlyphAtlasPipeline = typedef RenderPipelineT<GlyphAtlasVertexShader, GlyphAtlasFragmentShader>

Definition at line 180 of file content_context.h.

◆ IPoint

using impeller::IPoint = typedef TPoint<int64_t>

Definition at line 307 of file point.h.

◆ IPoint32

using impeller::IPoint32 = typedef TPoint<int32_t>

Definition at line 308 of file point.h.

◆ IRect

using impeller::IRect = typedef TRect<int64_t>

Definition at line 307 of file rect.h.

◆ ISize

using impeller::ISize = typedef TSize<int64_t>

Definition at line 136 of file size.h.

◆ LinearGradientFillPipeline

using impeller::LinearGradientFillPipeline = typedef RenderPipelineT<GradientFillVertexShader, LinearGradientFillFragmentShader>

Definition at line 128 of file content_context.h.

◆ LinearGradientSSBOFillPipeline

using impeller::LinearGradientSSBOFillPipeline = typedef RenderPipelineT<GradientFillVertexShader, LinearGradientSsboFillFragmentShader>

Definition at line 140 of file content_context.h.

◆ LinearToSrgbFilterPipeline

using impeller::LinearToSrgbFilterPipeline = typedef RenderPipelineT<LinearToSrgbFilterVertexShader, LinearToSrgbFilterFragmentShader>

Definition at line 175 of file content_context.h.

◆ MillisecondsF

using impeller::MillisecondsF = typedef std::chrono::duration<float, std::milli>

Definition at line 11 of file timing.h.

◆ MixedOp

template<class F , class I >
using impeller::MixedOp = typedef typename MixedOp_<F, I>::type

Definition at line 18 of file type_traits.h.

◆ MorphologyFilterPipeline

using impeller::MorphologyFilterPipeline = typedef RenderPipelineT<MorphologyFilterVertexShader, MorphologyFilterFragmentShader>

Definition at line 169 of file content_context.h.

◆ PathComponentVariant

using impeller::PathComponentVariant = typedef std::variant<std::monostate, const LinearPathComponent*, const QuadraticPathComponent*, const CubicPathComponent*>

Definition at line 154 of file path_component.h.

◆ PipelineMap

using impeller::PipelineMap = typedef std::unordered_map<PipelineDescriptor, PipelineFuture<PipelineDescriptor>, ComparableHash<PipelineDescriptor>, ComparableEqual<PipelineDescriptor> >

Definition at line 21 of file pipeline_library.h.

◆ PipelineProc

using impeller::PipelineProc = typedef std::shared_ptr<Pipeline<PipelineDescriptor> > ( ContentContext::*)(ContentContextOptions) const

Definition at line 70 of file blend_filter_contents.cc.

◆ Point

using impeller::Point = typedef TPoint<Scalar>

Definition at line 306 of file point.h.

◆ PointsComputeShaderPipeline

using impeller::PointsComputeShaderPipeline = typedef ComputePipelineBuilder<PointsComputeShader>

Geometry Pipelines.

Definition at line 284 of file content_context.h.

◆ PorterDuffBlendPipeline

using impeller::PorterDuffBlendPipeline = typedef RenderPipelineT<PorterDuffBlendVertexShader, PorterDuffBlendFragmentShader>

Definition at line 184 of file content_context.h.

◆ PositionUVPipeline

using impeller::PositionUVPipeline = typedef RenderPipelineT<TextureFillVertexShader, TiledTextureFillFragmentShader>

Definition at line 156 of file content_context.h.

◆ PrimaryKey

using impeller::PrimaryKey = typedef std::optional<int64_t>

Definition at line 21 of file archivable.h.

◆ RadialGradientFillPipeline

using impeller::RadialGradientFillPipeline = typedef RenderPipelineT<GradientFillVertexShader, RadialGradientFillFragmentShader>

Definition at line 132 of file content_context.h.

◆ RadialGradientSSBOFillPipeline

using impeller::RadialGradientSSBOFillPipeline = typedef RenderPipelineT<GradientFillVertexShader, RadialGradientSsboFillFragmentShader>

Definition at line 146 of file content_context.h.

◆ Rect

using impeller::Rect = typedef TRect<Scalar>

Definition at line 306 of file rect.h.

◆ RRectBlurPipeline

using impeller::RRectBlurPipeline = typedef RenderPipelineT<RrectBlurVertexShader, RrectBlurFragmentShader>

Definition at line 151 of file content_context.h.

◆ SamplerMap

using impeller::SamplerMap = typedef std::unordered_map<SamplerDescriptor, std::shared_ptr<const Sampler>, ComparableHash<SamplerDescriptor>, ComparableEqual<SamplerDescriptor> >

Definition at line 56 of file sampler_descriptor.h.

◆ SamplerResource

using impeller::SamplerResource = typedef Resource<std::shared_ptr<const Sampler> >

Definition at line 62 of file command.h.

◆ Scalar

using impeller::Scalar = typedef float

Definition at line 15 of file scalar.h.

◆ SecondsF

using impeller::SecondsF = typedef std::chrono::duration<float>

Definition at line 12 of file timing.h.

◆ ShaderFunctionMap

using impeller::ShaderFunctionMap = typedef std::unordered_map<ShaderKey, std::shared_ptr<const ShaderFunction>, ShaderKey::Hash, ShaderKey::Equal>

Definition at line 43 of file shader_key.h.

◆ SharedHandleVK

template<class T >
using impeller::SharedHandleVK = typedef std::shared_ptr<SharedObjectVKT<T> >

Definition at line 48 of file shared_object_vk.h.

◆ Size

using impeller::Size = typedef TSize<Scalar>

Definition at line 135 of file size.h.

◆ SolidFillPipeline

using impeller::SolidFillPipeline = typedef RenderPipelineT<SolidFillVertexShader, SolidFillFragmentShader>

Definition at line 130 of file content_context.h.

◆ SrgbToLinearFilterPipeline

using impeller::SrgbToLinearFilterPipeline = typedef RenderPipelineT<SrgbToLinearFilterVertexShader, SrgbToLinearFilterFragmentShader>

Definition at line 178 of file content_context.h.

◆ SweepGradientFillPipeline

using impeller::SweepGradientFillPipeline = typedef RenderPipelineT<GradientFillVertexShader, SweepGradientFillFragmentShader>

Definition at line 137 of file content_context.h.

◆ SweepGradientSSBOFillPipeline

using impeller::SweepGradientSSBOFillPipeline = typedef RenderPipelineT<GradientFillVertexShader, SweepGradientSsboFillFragmentShader>

Definition at line 149 of file content_context.h.

◆ TexturePipeline

using impeller::TexturePipeline = typedef RenderPipelineT<TextureFillVertexShader, TextureFillFragmentShader>

Definition at line 154 of file content_context.h.

◆ TextureResource

using impeller::TextureResource = typedef Resource<std::shared_ptr<const Texture> >

Definition at line 61 of file command.h.

◆ TextureUsageMask

using impeller::TextureUsageMask = typedef uint64_t

Definition at line 274 of file formats.h.

◆ TiledTexturePipeline

using impeller::TiledTexturePipeline = typedef RenderPipelineT<TextureFillVertexShader, TiledTextureFillFragmentShader>

Definition at line 158 of file content_context.h.

◆ TimePoint

using impeller::TimePoint = typedef std::chrono::time_point<std::chrono::high_resolution_clock>

Definition at line 14 of file timing.h.

◆ UintPoint32

using impeller::UintPoint32 = typedef TPoint<uint32_t>

Definition at line 309 of file point.h.

◆ UniqueAllocatorVMA

using impeller::UniqueAllocatorVMA = typedef fml::UniqueObject<VmaAllocator, AllocatorVMATraits>

Definition at line 30 of file vma.h.

◆ UniqueBufferVMA

using impeller::UniqueBufferVMA = typedef fml::UniqueObject<BufferVMA, BufferVMATraits>

Definition at line 97 of file vma.h.

◆ UniqueEGLImage

using impeller::UniqueEGLImage = typedef fml::UniqueObject<EGLImageWithDisplay, EGLImageWithDisplayTraits>

Definition at line 41 of file image.h.

◆ UniqueEGLImageKHR

using impeller::UniqueEGLImageKHR = typedef fml::UniqueObject<EGLImageKHRWithDisplay, EGLImageKHRWithDisplayTraits>

Definition at line 72 of file image.h.

◆ UniqueGLTexture

using impeller::UniqueGLTexture = typedef fml::UniqueObject<GLTexture, GLTextureTraits>

Definition at line 37 of file texture.h.

◆ UniqueImageVMA

using impeller::UniqueImageVMA = typedef fml::UniqueObject<ImageVMA, ImageVMATraits>

Definition at line 132 of file vma.h.

◆ UniquePoolVMA

using impeller::UniquePoolVMA = typedef fml::UniqueObject<PoolVMA, PoolVMATraits>

Definition at line 62 of file vma.h.

◆ UvComputeShaderPipeline

using impeller::UvComputeShaderPipeline = typedef ComputePipelineBuilder<UvComputeShader>

Definition at line 285 of file content_context.h.

◆ Vector2

using impeller::Vector2 = typedef Point

Definition at line 310 of file point.h.

◆ WaitSet

using impeller::WaitSet = typedef std::vector<std::shared_ptr<WaitSetEntry> >

Definition at line 24 of file fence_waiter_vk.h.

◆ YUVToRGBFilterPipeline

using impeller::YUVToRGBFilterPipeline = typedef RenderPipelineT<YuvToRgbFilterVertexShader, YuvToRgbFilterFragmentShader>

Definition at line 192 of file content_context.h.

Enumeration Type Documentation

◆ AttachmentKind

enum impeller::AttachmentKind
strong
Enumerator
kColor 
kDepth 
kStencil 
kDepthStencil 

Definition at line 399 of file formats_vk.h.

399  {
400  kColor,
401  kDepth,
402  kStencil,
403  kDepthStencil,
404 };

◆ BlendFactor

enum impeller::BlendFactor
strong
Enumerator
kZero 
kOne 
kSourceColor 
kOneMinusSourceColor 
kSourceAlpha 
kOneMinusSourceAlpha 
kDestinationColor 
kOneMinusDestinationColor 
kDestinationAlpha 
kOneMinusDestinationAlpha 
kSourceAlphaSaturated 
kBlendColor 
kOneMinusBlendColor 
kBlendAlpha 
kOneMinusBlendAlpha 

Definition at line 152 of file formats.h.

152  {
153  kZero,
154  kOne,
155  kSourceColor,
156  kOneMinusSourceColor,
157  kSourceAlpha,
158  kOneMinusSourceAlpha,
159  kDestinationColor,
160  kOneMinusDestinationColor,
161  kDestinationAlpha,
162  kOneMinusDestinationAlpha,
163  kSourceAlphaSaturated,
164  kBlendColor,
165  kOneMinusBlendColor,
166  kBlendAlpha,
167  kOneMinusBlendAlpha,
168 };

◆ BlendMode

enum impeller::BlendMode
strong

All blend modes assume that both the source (fragment output) and destination (first color attachment) have colors with premultiplied alpha.

Enumerator
kClear 
kSource 
kDestination 
kSourceOver 
kDestinationOver 
kSourceIn 
kDestinationIn 
kSourceOut 
kDestinationOut 
kSourceATop 
kDestinationATop 
kXor 
kPlus 
kModulate 
kScreen 
kOverlay 
kDarken 
kLighten 
kColorDodge 
kColorBurn 
kHardLight 
kSoftLight 
kDifference 
kExclusion 
kMultiply 
kHue 
kSaturation 
kColor 
kLuminosity 
kLast 

Definition at line 57 of file color.h.

57  {
58  // The following blend modes are able to be used as pipeline blend modes or
59  // via `BlendFilterContents`.
60  kClear = 0,
61  kSource,
62  kDestination,
63  kSourceOver,
64  kDestinationOver,
65  kSourceIn,
66  kDestinationIn,
67  kSourceOut,
68  kDestinationOut,
69  kSourceATop,
70  kDestinationATop,
71  kXor,
72  kPlus,
73  kModulate,
74 
75  // The following blend modes use equations that are not available for
76  // pipelines on most graphics devices without extensions, and so they are
77  // only able to be used via `BlendFilterContents`.
78  kScreen,
79  kOverlay,
80  kDarken,
81  kLighten,
82  kColorDodge,
83  kColorBurn,
84  kHardLight,
85  kSoftLight,
86  kDifference,
87  kExclusion,
88  kMultiply,
89  kHue,
90  kSaturation,
91  kColor,
92  kLuminosity,
93 
94  kLast = kLuminosity,
95 };

◆ BlendOperation

enum impeller::BlendOperation
strong
Enumerator
kAdd 
kSubtract 
kReverseSubtract 

Definition at line 170 of file formats.h.

170  {
171  kAdd,
172  kSubtract,
173  kReverseSubtract,
174 };

◆ BlobShaderType

enum impeller::BlobShaderType
strong
Enumerator
kVertex 
kFragment 
kCompute 

Definition at line 9 of file blob_types.h.

9  {
10  kVertex,
11  kFragment,
12  kCompute,
13 };

◆ Cap

enum impeller::Cap
strong
Enumerator
kButt 
kRound 
kSquare 

Definition at line 17 of file path.h.

17  {
18  kButt,
19  kRound,
20  kSquare,
21 };

◆ ColorWriteMask

enum impeller::ColorWriteMask : uint64_t
strong
Enumerator
kNone 
kRed 
kGreen 
kBlue 
kAlpha 
kAll 

Definition at line 390 of file formats.h.

390  : uint64_t {
391  kNone = 0,
392  kRed = 1 << 0,
393  kGreen = 1 << 1,
394  kBlue = 1 << 2,
395  kAlpha = 1 << 3,
396  kAll = kRed | kGreen | kBlue | kAlpha,
397 };

◆ CompareFunction

enum impeller::CompareFunction
strong
Enumerator
kNever 

Comparison test never passes.

kAlways 

Comparison test passes always passes.

kLess 

Comparison test passes if new_value < current_value.

kEqual 

Comparison test passes if new_value == current_value.

kLessEqual 

Comparison test passes if new_value <= current_value.

kGreater 

Comparison test passes if new_value > current_value.

kNotEqual 

Comparison test passes if new_value != current_value.

kGreaterEqual 

Comparison test passes if new_value >= current_value.

Definition at line 486 of file formats.h.

486  {
487  /// Comparison test never passes.
488  kNever,
489  /// Comparison test passes always passes.
490  kAlways,
491  /// Comparison test passes if new_value < current_value.
492  kLess,
493  /// Comparison test passes if new_value == current_value.
494  kEqual,
495  /// Comparison test passes if new_value <= current_value.
496  kLessEqual,
497  /// Comparison test passes if new_value > current_value.
498  kGreater,
499  /// Comparison test passes if new_value != current_value.
500  kNotEqual,
501  /// Comparison test passes if new_value >= current_value.
502  kGreaterEqual,
503 };

◆ CompressionType

enum impeller::CompressionType
strong

Additional compression to apply to a texture. This value is ignored on platforms which do not support it.

Lossy compression is only supported on iOS 15+ on A15 chips.

Enumerator
kLossless 
kLossy 

Definition at line 20 of file texture_descriptor.h.

20  {
21  kLossless,
22  kLossy,
23 };

◆ Convexity

enum impeller::Convexity
strong
Enumerator
kUnknown 
kConvex 

Definition at line 37 of file path.h.

37  {
38  kUnknown,
39  kConvex,
40 };

◆ CullMode

enum impeller::CullMode
strong
Enumerator
kNone 
kFrontFace 
kBackFace 

Definition at line 314 of file formats.h.

314  {
315  kNone,
316  kFrontFace,
317  kBackFace,
318 };

◆ DebugResourceType

enum impeller::DebugResourceType
strong
Enumerator
kTexture 
kBuffer 
kProgram 
kShader 
kRenderBuffer 
kFrameBuffer 

Definition at line 179 of file proc_table_gles.h.

179  {
180  kTexture,
181  kBuffer,
182  kProgram,
183  kShader,
184  kRenderBuffer,
185  kFrameBuffer,
186 };

◆ DescriptorType

enum impeller::DescriptorType
strong
Enumerator
kUniformBuffer 
kStorageBuffer 
kSampledImage 
kImage 
kSampler 

Definition at line 141 of file shader_types.h.

141  {
142  kUniformBuffer,
143  kStorageBuffer,
144  kSampledImage,
145  kImage,
146  kSampler,
147 };

◆ FillType

enum impeller::FillType
strong
Enumerator
kNonZero 
kOdd 
kPositive 
kNegative 
kAbsGeqTwo 

Definition at line 29 of file path.h.

29  {
30  kNonZero, // The default winding order.
31  kOdd,
32  kPositive,
33  kNegative,
34  kAbsGeqTwo,
35 };

◆ GeometryVertexType

enum impeller::GeometryVertexType
Enumerator
kPosition 
kColor 
kUV 

Definition at line 25 of file geometry.h.

25  {
26  kPosition,
27  kColor,
28  kUV,
29 };

◆ HandleType

enum impeller::HandleType
strong
Enumerator
kUnknown 
kTexture 
kBuffer 
kProgram 
kRenderBuffer 
kFrameBuffer 

Definition at line 21 of file handle_gles.h.

21  {
22  kUnknown,
23  kTexture,
24  kBuffer,
25  kProgram,
26  kRenderBuffer,
27  kFrameBuffer,
28 };

◆ IndexType

enum impeller::IndexType
strong
Enumerator
kUnknown 
k16bit 
k32bit 
kNone 

Does not use the index buffer.

Definition at line 320 of file formats.h.

320  {
321  kUnknown,
322  k16bit,
323  k32bit,
324  /// Does not use the index buffer.
325  kNone,
326 };

◆ Join

enum impeller::Join
strong
Enumerator
kMiter 
kRound 
kBevel 

Definition at line 23 of file path.h.

23  {
24  kMiter,
25  kRound,
26  kBevel,
27 };

◆ LoadAction

enum impeller::LoadAction
strong
Enumerator
kDontCare 
kLoad 
kClear 

Definition at line 176 of file formats.h.

176  {
177  kDontCare,
178  kLoad,
179  kClear,
180 };

◆ MinMagFilter

enum impeller::MinMagFilter
strong
Enumerator
kNearest 

Select nearest to the sample point. Most widely supported.

kLinear 

Select two points and linearly interpolate between them. Some formats may not support this.

Definition at line 361 of file formats.h.

361  {
362  /// Select nearest to the sample point. Most widely supported.
363  kNearest,
364  /// Select two points and linearly interpolate between them. Some formats
365  /// may not support this.
366  kLinear,
367 };

◆ MipFilter

enum impeller::MipFilter
strong
Enumerator
kNearest 

Sample from the nearest mip level.

kLinear 

Sample from the two nearest mip levels and linearly interpolate between them.

Definition at line 369 of file formats.h.

369  {
370  /// Sample from the nearest mip level.
371  kNearest,
372  /// Sample from the two nearest mip levels and linearly interpolate between
373  /// them.
374  kLinear,
375 };

◆ OptionalDeviceExtensionVK

enum impeller::OptionalDeviceExtensionVK : uint32_t
strong
Enumerator
kEXTPipelineCreationFeedback 
kLast 

Definition at line 21 of file capabilities_vk.h.

21  : uint32_t {
22  // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_pipeline_creation_feedback.html
23  kEXTPipelineCreationFeedback,
24  kLast,
25 };

◆ PixelFormat

enum impeller::PixelFormat
strong

The Pixel formats supported by Impeller. The naming convention denotes the usage of the component, the bit width of that component, and then one or more qualifiers to its interpretation.

For instance, kR8G8B8A8UNormIntSRGB is a 32 bits-per-pixel format ordered in RGBA with 8 bits per component with each component expressed as an unsigned normalized integer and a conversion from sRGB to linear color space.

Key: R -> Red Component G -> Green Component B -> Blue Component D -> Depth Component S -> Stencil Component U -> Unsigned (Lack of this denotes a signed component) Norm -> Normalized SRGB -> sRGB to linear interpretation

While the effective bit width of the pixel can be determined by adding up the widths of each component, only the non-esoteric formats are tightly packed. Do not assume tight packing for the esoteric formats and use blit passes to convert to a non-esoteric pass.

Enumerator
kUnknown 
kA8UNormInt 
kR8UNormInt 
kR8G8UNormInt 
kR8G8B8A8UNormInt 
kR8G8B8A8UNormIntSRGB 
kB8G8R8A8UNormInt 
kB8G8R8A8UNormIntSRGB 
kR32G32B32A32Float 
kR16G16B16A16Float 
kB10G10R10XR 
kB10G10R10XRSRGB 
kB10G10R10A10XR 
kS8UInt 
kD24UnormS8Uint 
kD32FloatS8UInt 

Definition at line 94 of file formats.h.

94  {
95  kUnknown,
96  kA8UNormInt,
97  kR8UNormInt,
98  kR8G8UNormInt,
99  kR8G8B8A8UNormInt,
100  kR8G8B8A8UNormIntSRGB,
101  kB8G8R8A8UNormInt,
102  kB8G8R8A8UNormIntSRGB,
103  kR32G32B32A32Float,
104  kR16G16B16A16Float,
105  kB10G10R10XR,
106  kB10G10R10XRSRGB,
107  kB10G10R10A10XR,
108  // Depth and stencil formats.
109  kS8UInt,
110  kD24UnormS8Uint,
111  kD32FloatS8UInt,
112 };

◆ PlaygroundBackend

enum impeller::PlaygroundBackend
strong
Enumerator
kMetal 
kOpenGLES 
kVulkan 

Definition at line 25 of file playground.h.

25  {
26  kMetal,
27  kOpenGLES,
28  kVulkan,
29 };

◆ PointStyle

enum impeller::PointStyle
strong
Enumerator
kRound 

Points are drawn as squares.

kSquare 

Points are drawn as circles.

Definition at line 42 of file canvas.h.

42  {
43  /// @brief Points are drawn as squares.
44  kRound,
45 
46  /// @brief Points are drawn as circles.
47  kSquare,
48 };

◆ PolygonMode

enum impeller::PolygonMode
strong
Enumerator
kFill 
kLine 

Definition at line 338 of file formats.h.

338  {
339  kFill,
340  kLine,
341 };

◆ PrimitiveType

enum impeller::PrimitiveType
strong
Enumerator
kTriangle 
kTriangleStrip 
kLine 
kLineStrip 
kPoint 

Definition at line 328 of file formats.h.

328  {
329  kTriangle,
330  kTriangleStrip,
331  kLine,
332  kLineStrip,
333  kPoint,
334  // Triangle fans are implementation dependent and need extra extensions
335  // checks. Hence, they are not supported here.
336 };

◆ RuntimeShaderStage

enum impeller::RuntimeShaderStage
strong
Enumerator
kVertex 
kFragment 
kCompute 
kTessellationControl 
kTessellationEvaluation 

Definition at line 29 of file runtime_types.h.

29  {
30  kVertex,
31  kFragment,
32  kCompute,
33  kTessellationControl,
34  kTessellationEvaluation,
35 };

◆ RuntimeUniformType

enum impeller::RuntimeUniformType
Enumerator
kBoolean 
kSignedByte 
kUnsignedByte 
kSignedShort 
kUnsignedShort 
kSignedInt 
kUnsignedInt 
kSignedInt64 
kUnsignedInt64 
kHalfFloat 
kFloat 
kDouble 
kSampledImage 

Definition at line 13 of file runtime_types.h.

13  {
14  kBoolean,
15  kSignedByte,
16  kUnsignedByte,
17  kSignedShort,
18  kUnsignedShort,
19  kSignedInt,
20  kUnsignedInt,
21  kSignedInt64,
22  kUnsignedInt64,
23  kHalfFloat,
24  kFloat,
25  kDouble,
26  kSampledImage,
27 };

◆ SampleCount

enum impeller::SampleCount
strong
Enumerator
kCount1 
kCount4 

Definition at line 269 of file formats.h.

269  {
270  kCount1 = 1,
271  kCount4 = 4,
272 };

◆ SamplerAddressMode

enum impeller::SamplerAddressMode
strong
Enumerator
kClampToEdge 
kRepeat 
kMirror 
kDecal 

decal sampling mode is only supported on devices that pass the Capabilities.SupportsDecalSamplerAddressMode check.

Definition at line 377 of file formats.h.

377  {
378  kClampToEdge,
379  kRepeat,
380  kMirror,
381  // More modes are almost always supported but they are usually behind
382  // extensions checks. The ones current in these structs are safe (always
383  // supported) defaults.
384 
385  /// @brief decal sampling mode is only supported on devices that pass
386  /// the `Capabilities.SupportsDecalSamplerAddressMode` check.
387  kDecal,
388 };

◆ ShaderStage

enum impeller::ShaderStage
strong
Enumerator
kUnknown 
kVertex 
kFragment 
kTessellationControl 
kTessellationEvaluation 
kCompute 

Definition at line 20 of file shader_types.h.

20  {
21  kUnknown,
22  kVertex,
23  kFragment,
24  kTessellationControl,
25  kTessellationEvaluation,
26  kCompute,
27 };

◆ ShaderType

enum impeller::ShaderType
strong
Enumerator
kUnknown 
kVoid 
kBoolean 
kSignedByte 
kUnsignedByte 
kSignedShort 
kUnsignedShort 
kSignedInt 
kUnsignedInt 
kSignedInt64 
kUnsignedInt64 
kAtomicCounter 
kHalfFloat 
kFloat 
kDouble 
kStruct 
kImage 
kSampledImage 
kSampler 

Definition at line 45 of file shader_types.h.

45  {
46  kUnknown,
47  kVoid,
48  kBoolean,
49  kSignedByte,
50  kUnsignedByte,
51  kSignedShort,
52  kUnsignedShort,
53  kSignedInt,
54  kUnsignedInt,
55  kSignedInt64,
56  kUnsignedInt64,
57  kAtomicCounter,
58  kHalfFloat,
59  kFloat,
60  kDouble,
61  kStruct,
62  kImage,
63  kSampledImage,
64  kSampler,
65 };

◆ StencilOperation

enum impeller::StencilOperation
strong
Enumerator
kKeep 

Don't modify the current stencil value.

kZero 

Reset the stencil value to zero.

kSetToReferenceValue 

Reset the stencil value to the reference value.

kIncrementClamp 

Increment the current stencil value by 1. Clamp it to the maximum.

kDecrementClamp 

Decrement the current stencil value by 1. Clamp it to zero.

kInvert 

Perform a logical bitwise invert on the current stencil value.

kIncrementWrap 

Increment the current stencil value by 1. If at maximum, set to zero.

kDecrementWrap 

Decrement the current stencil value by 1. If at zero, set to maximum.

Definition at line 505 of file formats.h.

505  {
506  /// Don't modify the current stencil value.
507  kKeep,
508  /// Reset the stencil value to zero.
509  kZero,
510  /// Reset the stencil value to the reference value.
511  kSetToReferenceValue,
512  /// Increment the current stencil value by 1. Clamp it to the maximum.
513  kIncrementClamp,
514  /// Decrement the current stencil value by 1. Clamp it to zero.
515  kDecrementClamp,
516  /// Perform a logical bitwise invert on the current stencil value.
517  kInvert,
518  /// Increment the current stencil value by 1. If at maximum, set to zero.
519  kIncrementWrap,
520  /// Decrement the current stencil value by 1. If at zero, set to maximum.
521  kDecrementWrap,
522 };

◆ StorageMode

enum impeller::StorageMode
strong

Specified where the allocation resides and how it is used.

Enumerator
kHostVisible 

Allocations can be mapped onto the hosts address space and also be used by the device.

kDevicePrivate 

Allocations can only be used by the device. This location is optimal for use by the device. If the host needs to access these allocations, the transfer queue must be used to transfer this allocation onto the a host visible buffer.

kDeviceTransient 

Used by the device for temporary render targets. These allocations cannot be transferred from and to other allocations using the transfer queue. Render pass cannot initialize the contents of these buffers using load and store actions.

These allocations reside in tile memory which has higher bandwidth, lower latency and lower power consumption. The total device memory usage is also lower as a separate allocation does not need to be created in device memory. Prefer using these allocations for intermediates like depth and stencil buffers.

Definition at line 27 of file formats.h.

27  {
28  //----------------------------------------------------------------------------
29  /// Allocations can be mapped onto the hosts address space and also be used by
30  /// the device.
31  ///
32  kHostVisible,
33  //----------------------------------------------------------------------------
34  /// Allocations can only be used by the device. This location is optimal for
35  /// use by the device. If the host needs to access these allocations, the
36  /// transfer queue must be used to transfer this allocation onto the a host
37  /// visible buffer.
38  ///
39  kDevicePrivate,
40  //----------------------------------------------------------------------------
41  /// Used by the device for temporary render targets. These allocations cannot
42  /// be transferred from and to other allocations using the transfer queue.
43  /// Render pass cannot initialize the contents of these buffers using load and
44  /// store actions.
45  ///
46  /// These allocations reside in tile memory which has higher bandwidth, lower
47  /// latency and lower power consumption. The total device memory usage is
48  /// also lower as a separate allocation does not need to be created in
49  /// device memory. Prefer using these allocations for intermediates like depth
50  /// and stencil buffers.
51  ///
52  kDeviceTransient,
53 };

◆ StoreAction

enum impeller::StoreAction
strong
Enumerator
kDontCare 
kStore 
kMultisampleResolve 
kStoreAndMultisampleResolve 

Definition at line 182 of file formats.h.

182  {
183  kDontCare,
184  kStore,
185  kMultisampleResolve,
186  kStoreAndMultisampleResolve,
187 };

◆ TextureCoordinateSystem

enum impeller::TextureCoordinateSystem
strong
Enumerator
kUploadFromHost 
kRenderToTexture 

Definition at line 304 of file formats.h.

304  {
305  // Alternative coordinate system used when uploading texture data from the
306  // host.
307  // (0, 0) is the bottom-left of the image with +Y going up.
308  kUploadFromHost,
309  // Default coordinate system.
310  // (0, 0) is the top-left of the image with +Y going down.
311  kRenderToTexture,
312 };

◆ TextureType

enum impeller::TextureType
strong
Enumerator
kTexture2D 
kTexture2DMultisample 
kTextureCube 
kTextureExternalOES 

Definition at line 236 of file formats.h.

236  {
237  kTexture2D,
238  kTexture2DMultisample,
239  kTextureCube,
240  kTextureExternalOES,
241 };

◆ TextureUsage

enum impeller::TextureUsage : TextureUsageMask
strong
Enumerator
kUnknown 
kShaderRead 
kShaderWrite 
kRenderTarget 

Definition at line 276 of file formats.h.

276  : TextureUsageMask {
277  kUnknown = 0,
278  kShaderRead = 1 << 0,
279  kShaderWrite = 1 << 1,
280  kRenderTarget = 1 << 2,
281 };

◆ WindingOrder

enum impeller::WindingOrder
strong
Enumerator
kClockwise 
kCounterClockwise 

Definition at line 24 of file tessellator.h.

24  {
25  kClockwise,
26  kCounterClockwise,
27 };

◆ YUVColorSpace

enum impeller::YUVColorSpace
strong
Enumerator
kBT601LimitedRange 
kBT601FullRange 

Definition at line 53 of file color.h.

53 { kBT601LimitedRange, kBT601FullRange };

Function Documentation

◆ _FOR_EACH_CAPTURE_PROPERTY() [1/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY ( _CAPTURE_PROPERTY_CAST_DEFINITION  )

◆ _FOR_EACH_CAPTURE_PROPERTY() [2/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY ( _CAPTURE_PROPERTY_DECLARATION  )

◆ _FOR_EACH_CAPTURE_PROPERTY() [3/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY ( _CAPTURE_PROPERTY_DEFINITION  )

◆ Absolute()

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr T impeller::Absolute ( const T &  val)
constexpr

Definition at line 18 of file scalar.h.

18  {
19  return val >= T{} ? val : -val;
20 }

Referenced by ScalarNearlyZero().

◆ AdvancedBlend()

template<typename TPipeline >
static std::optional<Entity> impeller::AdvancedBlend ( const FilterInput::Vector &  inputs,
const ContentContext &  renderer,
const Entity &  entity,
const Rect &  coverage,
BlendMode  blend_mode,
std::optional< Color >  foreground_color,
ColorFilterContents::AbsorbOpacity  absorb_opacity,
PipelineProc  pipeline_proc,
std::optional< Scalar >  alpha 
)
static

Handle inputs.

Render to texture.

Definition at line 73 of file blend_filter_contents.cc.

82  {
83  using VS = typename TPipeline::VertexShader;
84  using FS = typename TPipeline::FragmentShader;
85 
86  //----------------------------------------------------------------------------
87  /// Handle inputs.
88  ///
89 
90  const size_t total_inputs =
91  inputs.size() + (foreground_color.has_value() ? 1 : 0);
92  if (total_inputs < 2) {
93  return std::nullopt;
94  }
95 
96  auto dst_snapshot =
97  inputs[0]->GetSnapshot("AdvancedBlend(Dst)", renderer, entity);
98  if (!dst_snapshot.has_value()) {
99  return std::nullopt;
100  }
101  auto maybe_dst_uvs = dst_snapshot->GetCoverageUVs(coverage);
102  if (!maybe_dst_uvs.has_value()) {
103  return std::nullopt;
104  }
105  auto dst_uvs = maybe_dst_uvs.value();
106 
107  std::optional<Snapshot> src_snapshot;
108  std::array<Point, 4> src_uvs;
109  if (!foreground_color.has_value()) {
110  src_snapshot =
111  inputs[1]->GetSnapshot("AdvancedBlend(Src)", renderer, entity);
112  if (!src_snapshot.has_value()) {
113  if (!dst_snapshot.has_value()) {
114  return std::nullopt;
115  }
116  return Entity::FromSnapshot(dst_snapshot, entity.GetBlendMode(),
117  entity.GetStencilDepth());
118  }
119  auto maybe_src_uvs = src_snapshot->GetCoverageUVs(coverage);
120  if (!maybe_src_uvs.has_value()) {
121  if (!dst_snapshot.has_value()) {
122  return std::nullopt;
123  }
124  return Entity::FromSnapshot(dst_snapshot, entity.GetBlendMode(),
125  entity.GetStencilDepth());
126  }
127  src_uvs = maybe_src_uvs.value();
128  }
129 
130  Rect subpass_coverage = coverage;
131  if (entity.GetContents()) {
132  auto coverage_hint = entity.GetContents()->GetCoverageHint();
133 
134  if (coverage_hint.has_value()) {
135  auto maybe_subpass_coverage =
136  subpass_coverage.Intersection(*coverage_hint);
137  if (!maybe_subpass_coverage.has_value()) {
138  return std::nullopt; // Nothing to render.
139  }
140 
141  subpass_coverage = *maybe_subpass_coverage;
142  }
143  }
144 
145  //----------------------------------------------------------------------------
146  /// Render to texture.
147  ///
148 
149  ContentContext::SubpassCallback callback = [&](const ContentContext& renderer,
150  RenderPass& pass) {
151  auto& host_buffer = pass.GetTransientsBuffer();
152 
153  auto size = pass.GetRenderTargetSize();
154  VertexBufferBuilder<typename VS::PerVertexData> vtx_builder;
155  vtx_builder.AddVertices({
156  {Point(0, 0), dst_uvs[0], src_uvs[0]},
157  {Point(size.width, 0), dst_uvs[1], src_uvs[1]},
158  {Point(size.width, size.height), dst_uvs[3], src_uvs[3]},
159  {Point(0, 0), dst_uvs[0], src_uvs[0]},
160  {Point(size.width, size.height), dst_uvs[3], src_uvs[3]},
161  {Point(0, size.height), dst_uvs[2], src_uvs[2]},
162  });
163  auto vtx_buffer = vtx_builder.CreateVertexBuffer(host_buffer);
164 
165  auto options = OptionsFromPass(pass);
166  options.blend_mode = BlendMode::kSource;
167  std::shared_ptr<Pipeline<PipelineDescriptor>> pipeline =
168  std::invoke(pipeline_proc, renderer, options);
169 
170  Command cmd;
171  DEBUG_COMMAND_INFO(cmd, SPrintF("Advanced Blend Filter (%s)",
172  BlendModeToString(blend_mode)));
173  cmd.BindVertices(vtx_buffer);
174  cmd.pipeline = std::move(pipeline);
175 
176  typename FS::BlendInfo blend_info;
177  typename VS::FrameInfo frame_info;
178 
179  auto dst_sampler_descriptor = dst_snapshot->sampler_descriptor;
180  if (renderer.GetDeviceCapabilities().SupportsDecalSamplerAddressMode()) {
181  dst_sampler_descriptor.width_address_mode = SamplerAddressMode::kDecal;
182  dst_sampler_descriptor.height_address_mode = SamplerAddressMode::kDecal;
183  }
184  auto dst_sampler = renderer.GetContext()->GetSamplerLibrary()->GetSampler(
185  dst_sampler_descriptor);
186  FS::BindTextureSamplerDst(cmd, dst_snapshot->texture, dst_sampler);
187  frame_info.dst_y_coord_scale = dst_snapshot->texture->GetYCoordScale();
188  blend_info.dst_input_alpha =
189  absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
190  ? dst_snapshot->opacity
191  : 1.0;
192 
193  if (foreground_color.has_value()) {
194  blend_info.color_factor = 1;
195  blend_info.color = foreground_color.value();
196  // This texture will not be sampled from due to the color factor. But
197  // this is present so that validation doesn't trip on a missing
198  // binding.
199  FS::BindTextureSamplerSrc(cmd, dst_snapshot->texture, dst_sampler);
200  } else {
201  auto src_sampler_descriptor = src_snapshot->sampler_descriptor;
202  if (renderer.GetDeviceCapabilities().SupportsDecalSamplerAddressMode()) {
203  src_sampler_descriptor.width_address_mode = SamplerAddressMode::kDecal;
204  src_sampler_descriptor.height_address_mode = SamplerAddressMode::kDecal;
205  }
206  auto src_sampler = renderer.GetContext()->GetSamplerLibrary()->GetSampler(
207  src_sampler_descriptor);
208  blend_info.color_factor = 0;
209  blend_info.src_input_alpha = src_snapshot->opacity;
210  FS::BindTextureSamplerSrc(cmd, src_snapshot->texture, src_sampler);
211  frame_info.src_y_coord_scale = src_snapshot->texture->GetYCoordScale();
212  }
213  auto blend_uniform = host_buffer.EmplaceUniform(blend_info);
214  FS::BindBlendInfo(cmd, blend_uniform);
215 
216  frame_info.mvp =
217  Matrix::MakeOrthographic(size) *
218  Matrix::MakeTranslation(coverage.origin - subpass_coverage.origin);
219 
220  auto uniform_view = host_buffer.EmplaceUniform(frame_info);
221  VS::BindFrameInfo(cmd, uniform_view);
222  pass.AddCommand(std::move(cmd));
223 
224  return true;
225  };
226 
227  auto out_texture = renderer.MakeSubpass(
228  "Advanced Blend Filter", ISize(subpass_coverage.size), callback);
229  if (!out_texture) {
230  return std::nullopt;
231  }
232 
233  return Entity::FromSnapshot(
234  Snapshot{
235  .texture = out_texture,
236  .transform = Matrix::MakeTranslation(subpass_coverage.origin),
237  // Since we absorbed the transform of the inputs and used the
238  // respective snapshot sampling modes when blending, pass on
239  // the default NN clamp sampler.
240  .sampler_descriptor = {},
241  .opacity = (absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
242  ? 1.0f
243  : dst_snapshot->opacity) *
244  alpha.value_or(1.0)},
245  entity.GetBlendMode(), entity.GetStencilDepth());
246 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::Command::BindVertices(), BlendModeToString(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), DEBUG_COMMAND_INFO, impeller::Entity::FromSnapshot(), impeller::Entity::GetBlendMode(), impeller::Entity::GetContents(), impeller::ContentContext::GetContext(), impeller::ContentContext::GetDeviceCapabilities(), impeller::Entity::GetStencilDepth(), impeller::TRect< T >::Intersection(), kDecal, kSource, impeller::ColorFilterContents::kYes, impeller::Matrix::MakeOrthographic(), impeller::ContentContext::MakeSubpass(), impeller::Matrix::MakeTranslation(), OptionsFromPass(), impeller::TRect< T >::origin, impeller::Command::pipeline, impeller::TRect< T >::size, SPrintF(), impeller::Capabilities::SupportsDecalSamplerAddressMode(), and impeller::Snapshot::texture.

◆ AllocateAndBindDescriptorSets() [1/2]

static bool impeller::AllocateAndBindDescriptorSets ( const ContextVK &  context,
const Command &  command,
CommandEncoderVK &  encoder,
const PipelineVK &  pipeline,
size_t  command_count 
)
static

Definition at line 326 of file render_pass_vk.cc.

330  {
331  auto desc_set =
332  pipeline.GetDescriptor().GetVertexDescriptor()->GetDescriptorSetLayouts();
333  auto vk_desc_set = encoder.AllocateDescriptorSet(
334  pipeline.GetDescriptorSetLayout(), command_count);
335  if (!vk_desc_set) {
336  return false;
337  }
338 
339  auto& allocator = *context.GetResourceAllocator();
340 
341  std::vector<vk::DescriptorImageInfo> images;
342  std::vector<vk::DescriptorBufferInfo> buffers;
343  std::vector<vk::WriteDescriptorSet> writes;
344  writes.reserve(command.vertex_bindings.buffers.size() +
345  command.fragment_bindings.buffers.size() +
346  command.fragment_bindings.sampled_images.size());
347  images.reserve(command.fragment_bindings.sampled_images.size());
348  buffers.reserve(command.vertex_bindings.buffers.size() +
349  command.fragment_bindings.buffers.size());
350 
351  auto bind_images = [&encoder, //
352  &images, //
353  &writes, //
354  &vk_desc_set //
355  ](const Bindings& bindings) -> bool {
356  for (const auto& [index, data] : bindings.sampled_images) {
357  auto texture = data.texture.resource;
358  const auto& texture_vk = TextureVK::Cast(*texture);
359  const SamplerVK& sampler = SamplerVK::Cast(*data.sampler.resource);
360 
361  if (!encoder.Track(texture) ||
362  !encoder.Track(sampler.GetSharedSampler())) {
363  return false;
364  }
365 
366  const SampledImageSlot& slot = data.slot;
367 
368  vk::DescriptorImageInfo image_info;
369  image_info.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
370  image_info.sampler = sampler.GetSampler();
371  image_info.imageView = texture_vk.GetImageView();
372  images.push_back(image_info);
373 
374  vk::WriteDescriptorSet write_set;
375  write_set.dstSet = vk_desc_set.value();
376  write_set.dstBinding = slot.binding;
377  write_set.descriptorCount = 1u;
378  write_set.descriptorType = vk::DescriptorType::eCombinedImageSampler;
379  write_set.pImageInfo = &images.back();
380 
381  writes.push_back(write_set);
382  }
383 
384  return true;
385  };
386 
387  auto bind_buffers = [&allocator, //
388  &encoder, //
389  &buffers, //
390  &writes, //
391  &desc_set, //
392  &vk_desc_set //
393  ](const Bindings& bindings) -> bool {
394  for (const auto& [buffer_index, data] : bindings.buffers) {
395  const auto& buffer_view = data.view.resource.buffer;
396 
397  auto device_buffer = buffer_view->GetDeviceBuffer(allocator);
398  if (!device_buffer) {
399  VALIDATION_LOG << "Failed to get device buffer for vertex binding";
400  return false;
401  }
402 
403  auto buffer = DeviceBufferVK::Cast(*device_buffer).GetBuffer();
404  if (!buffer) {
405  return false;
406  }
407 
408  if (!encoder.Track(device_buffer)) {
409  return false;
410  }
411 
412  uint32_t offset = data.view.resource.range.offset;
413 
414  vk::DescriptorBufferInfo buffer_info;
415  buffer_info.buffer = buffer;
416  buffer_info.offset = offset;
417  buffer_info.range = data.view.resource.range.length;
418  buffers.push_back(buffer_info);
419 
420  const ShaderUniformSlot& uniform = data.slot;
421  auto layout_it = std::find_if(desc_set.begin(), desc_set.end(),
422  [&uniform](DescriptorSetLayout& layout) {
423  return layout.binding == uniform.binding;
424  });
425  if (layout_it == desc_set.end()) {
426  VALIDATION_LOG << "Failed to get descriptor set layout for binding "
427  << uniform.binding;
428  return false;
429  }
430  auto layout = *layout_it;
431 
432  vk::WriteDescriptorSet write_set;
433  write_set.dstSet = vk_desc_set.value();
434  write_set.dstBinding = uniform.binding;
435  write_set.descriptorCount = 1u;
436  write_set.descriptorType = ToVKDescriptorType(layout.descriptor_type);
437  write_set.pBufferInfo = &buffers.back();
438 
439  writes.push_back(write_set);
440  }
441  return true;
442  };
443 
444  if (!bind_buffers(command.vertex_bindings) ||
445  !bind_buffers(command.fragment_bindings) ||
446  !bind_images(command.fragment_bindings)) {
447  return false;
448  }
449 
450  context.GetDevice().updateDescriptorSets(writes, {});
451 
452  encoder.GetCommandBuffer().bindDescriptorSets(
453  vk::PipelineBindPoint::eGraphics, // bind point
454  pipeline.GetPipelineLayout(), // layout
455  0, // first set
456  {vk::DescriptorSet{*vk_desc_set}}, // sets
457  nullptr // offsets
458  );
459  return true;
460 }

References impeller::CommandEncoderVK::AllocateDescriptorSet(), impeller::ShaderUniformSlot::binding, impeller::SampledImageSlot::binding, impeller::Bindings::buffers, impeller::DescriptorSetLayout::descriptor_type, impeller::Command::fragment_bindings, impeller::Pipeline< T >::GetDescriptor(), impeller::PipelineVK::GetDescriptorSetLayout(), impeller::ContextVK::GetDevice(), impeller::PipelineVK::GetPipelineLayout(), impeller::ContextVK::GetResourceAllocator(), impeller::SamplerVK::GetSampler(), impeller::SamplerVK::GetSharedSampler(), impeller::PipelineDescriptor::GetVertexDescriptor(), impeller::Bindings::sampled_images, ToVKDescriptorType(), impeller::CommandEncoderVK::Track(), VALIDATION_LOG, and impeller::Command::vertex_bindings.

Referenced by EncodeCommand().

◆ AllocateAndBindDescriptorSets() [2/2]

static bool impeller::AllocateAndBindDescriptorSets ( const ContextVK &  context,
const ComputeCommand &  command,
CommandEncoderVK &  encoder,
const ComputePipelineVK &  pipeline,
size_t  command_count 
)
static

Definition at line 69 of file compute_pass_vk.cc.

73  {
74  auto desc_set = pipeline.GetDescriptor().GetDescriptorSetLayouts();
75  auto vk_desc_set = encoder.AllocateDescriptorSet(
76  pipeline.GetDescriptorSetLayout(), command_count);
77  if (!vk_desc_set) {
78  return false;
79  }
80 
81  auto& allocator = *context.GetResourceAllocator();
82 
83  std::unordered_map<uint32_t, vk::DescriptorBufferInfo> buffers;
84  std::unordered_map<uint32_t, vk::DescriptorImageInfo> images;
85  std::vector<vk::WriteDescriptorSet> writes;
86  auto bind_images = [&encoder, //
87  &images, //
88  &writes, //
89  &vk_desc_set //
90  ](const Bindings& bindings) -> bool {
91  for (const auto& [index, data] : bindings.sampled_images) {
92  auto texture = data.texture.resource;
93  const auto& texture_vk = TextureVK::Cast(*texture);
94  const SamplerVK& sampler = SamplerVK::Cast(*data.sampler.resource);
95 
96  if (!encoder.Track(texture) ||
97  !encoder.Track(sampler.GetSharedSampler())) {
98  return false;
99  }
100 
101  const SampledImageSlot& slot = data.slot;
102 
103  vk::DescriptorImageInfo image_info;
104  image_info.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
105  image_info.sampler = sampler.GetSampler();
106  image_info.imageView = texture_vk.GetImageView();
107 
108  vk::WriteDescriptorSet write_set;
109  write_set.dstSet = vk_desc_set.value();
110  write_set.dstBinding = slot.binding;
111  write_set.descriptorCount = 1u;
112  write_set.descriptorType = vk::DescriptorType::eCombinedImageSampler;
113  write_set.pImageInfo = &(images[slot.binding] = image_info);
114 
115  writes.push_back(write_set);
116  }
117 
118  return true;
119  };
120 
121  auto bind_buffers = [&allocator, //
122  &encoder, //
123  &buffers, //
124  &writes, //
125  &desc_set, //
126  &vk_desc_set //
127  ](const Bindings& bindings) -> bool {
128  for (const auto& [buffer_index, data] : bindings.buffers) {
129  const auto& buffer_view = data.view.resource.buffer;
130 
131  auto device_buffer = buffer_view->GetDeviceBuffer(allocator);
132  if (!device_buffer) {
133  VALIDATION_LOG << "Failed to get device buffer for vertex binding";
134  return false;
135  }
136 
137  auto buffer = DeviceBufferVK::Cast(*device_buffer).GetBuffer();
138  if (!buffer) {
139  return false;
140  }
141 
142  if (!encoder.Track(device_buffer)) {
143  return false;
144  }
145 
146  uint32_t offset = data.view.resource.range.offset;
147 
148  vk::DescriptorBufferInfo buffer_info;
149  buffer_info.buffer = buffer;
150  buffer_info.offset = offset;
151  buffer_info.range = data.view.resource.range.length;
152 
153  const ShaderUniformSlot& uniform = data.slot;
154  auto layout_it = std::find_if(desc_set.begin(), desc_set.end(),
155  [&uniform](DescriptorSetLayout& layout) {
156  return layout.binding == uniform.binding;
157  });
158  if (layout_it == desc_set.end()) {
159  VALIDATION_LOG << "Failed to get descriptor set layout for binding "
160  << uniform.binding;
161  return false;
162  }
163  auto layout = *layout_it;
164 
165  vk::WriteDescriptorSet write_set;
166  write_set.dstSet = vk_desc_set.value();
167  write_set.dstBinding = uniform.binding;
168  write_set.descriptorCount = 1u;
169  write_set.descriptorType = ToVKDescriptorType(layout.descriptor_type);
170  write_set.pBufferInfo = &(buffers[uniform.binding] = buffer_info);
171 
172  writes.push_back(write_set);
173  }
174  return true;
175  };
176 
177  if (!bind_buffers(command.bindings) || !bind_images(command.bindings)) {
178  return false;
179  }
180 
181  context.GetDevice().updateDescriptorSets(writes, {});
182 
183  encoder.GetCommandBuffer().bindDescriptorSets(
184  vk::PipelineBindPoint::eCompute, // bind point
185  pipeline.GetPipelineLayout(), // layout
186  0, // first set
187  {vk::DescriptorSet{*vk_desc_set}}, // sets
188  nullptr // offsets
189  );
190  return true;
191 }

References impeller::CommandEncoderVK::AllocateDescriptorSet(), impeller::ShaderUniformSlot::binding, impeller::SampledImageSlot::binding, impeller::ComputeCommand::bindings, impeller::BackendCast< DeviceBufferVK, Buffer >::Cast(), impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::BackendCast< SamplerVK, Sampler >::Cast(), impeller::DescriptorSetLayout::descriptor_type, impeller::DeviceBufferVK::GetBuffer(), impeller::Pipeline< T >::GetDescriptor(), impeller::ComputePipelineVK::GetDescriptorSetLayout(), impeller::ComputePipelineDescriptor::GetDescriptorSetLayouts(), impeller::ContextVK::GetDevice(), impeller::ComputePipelineVK::GetPipelineLayout(), impeller::ContextVK::GetResourceAllocator(), impeller::SamplerVK::GetSampler(), impeller::SamplerVK::GetSharedSampler(), ToVKDescriptorType(), impeller::CommandEncoderVK::Track(), and VALIDATION_LOG.

◆ API_AVAILABLE()

impeller::API_AVAILABLE ( ios(14.0)  ,
macos(11.0)   
)

Definition at line 18 of file command_buffer_mtl.mm.

20  {
21  switch (state) {
22  case MTLCommandEncoderErrorStateUnknown:
23  return @"unknown";
24  case MTLCommandEncoderErrorStateCompleted:
25  return @"completed";
26  case MTLCommandEncoderErrorStateAffected:
27  return @"affected";
28  case MTLCommandEncoderErrorStatePending:
29  return @"pending";
30  case MTLCommandEncoderErrorStateFaulted:
31  return @"faulted";
32  }
33  return @"unknown";
34 }

◆ AppendColor()

static void impeller::AppendColor ( const Color &  color,
GradientData *  data 
)
static

Definition at line 12 of file gradient.cc.

12  {
13  auto converted = color.ToR8G8B8A8();
14  data->color_bytes.push_back(converted[0]);
15  data->color_bytes.push_back(converted[1]);
16  data->color_bytes.push_back(converted[2]);
17  data->color_bytes.push_back(converted[3]);
18 }

References impeller::GradientData::color_bytes, and impeller::Color::ToR8G8B8A8().

Referenced by CreateGradientBuffer().

◆ ApproximateParabolaIntegral()

static Scalar impeller::ApproximateParabolaIntegral ( Scalar  x)
static

Definition at line 98 of file path_component.cc.

98  {
99  constexpr Scalar d = 0.67;
100  return x / (1.0 - d + sqrt(sqrt(pow(d, 4) + 0.25 * x * x)));
101 }

Referenced by impeller::QuadraticPathComponent::FillPointsForPolyline().

◆ AttachmentKindFromFormat()

constexpr AttachmentKind impeller::AttachmentKindFromFormat ( PixelFormat  format)
constexpr

Definition at line 406 of file formats_vk.h.

406  {
407  switch (format) {
408  case PixelFormat::kUnknown:
409  case PixelFormat::kA8UNormInt:
410  case PixelFormat::kR8UNormInt:
411  case PixelFormat::kR8G8UNormInt:
412  case PixelFormat::kR8G8B8A8UNormInt:
413  case PixelFormat::kR8G8B8A8UNormIntSRGB:
414  case PixelFormat::kB8G8R8A8UNormInt:
415  case PixelFormat::kB8G8R8A8UNormIntSRGB:
416  case PixelFormat::kR32G32B32A32Float:
417  case PixelFormat::kR16G16B16A16Float:
418  case PixelFormat::kB10G10R10XR:
419  case PixelFormat::kB10G10R10XRSRGB:
420  case PixelFormat::kB10G10R10A10XR:
421  return AttachmentKind::kColor;
422  case PixelFormat::kS8UInt:
423  return AttachmentKind::kStencil;
424  case PixelFormat::kD24UnormS8Uint:
425  case PixelFormat::kD32FloatS8UInt:
426  return AttachmentKind::kDepthStencil;
427  }
428  FML_UNREACHABLE();
429 }

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kColor, kD24UnormS8Uint, kD32FloatS8UInt, kDepthStencil, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, kStencil, and kUnknown.

Referenced by CreateAttachmentDescription().

◆ AttachmentToString()

std::string impeller::AttachmentToString ( const Attachment &  attachment)

Definition at line 104 of file formats.cc.

104  {
105  std::stringstream stream;
106  if (attachment.texture) {
107  stream << "Texture=("
108  << TextureDescriptorToString(
109  attachment.texture->GetTextureDescriptor())
110  << "),";
111  }
112  if (attachment.resolve_texture) {
113  stream << "ResolveTexture=("
114  << TextureDescriptorToString(
115  attachment.resolve_texture->GetTextureDescriptor())
116  << "),";
117  }
118  stream << "LoadAction=" << LoadActionToString(attachment.load_action) << ",";
119  stream << "StoreAction=" << StoreActionToString(attachment.store_action);
120  return stream.str();
121 }

References impeller::Attachment::load_action, LoadActionToString(), impeller::Attachment::resolve_texture, impeller::Attachment::store_action, StoreActionToString(), impeller::Attachment::texture, and TextureDescriptorToString().

Referenced by ColorAttachmentToString(), DepthAttachmentToString(), and StencilAttachmentToString().

◆ AttachmentTypeString()

static const char* impeller::AttachmentTypeString ( GLint  type)
static

Definition at line 162 of file proc_table_gles.cc.

162  {
163  switch (type) {
164  case GL_RENDERBUFFER:
165  return "GL_RENDERBUFFER";
166  case GL_TEXTURE:
167  return "GL_TEXTURE";
168  case GL_NONE:
169  return "GL_NONE";
170  }
171 
172  return "Unknown Type";
173 }

Referenced by DescribeFramebufferAttachment().

◆ BENCHMARK_CAPTURE() [1/4]

impeller::BENCHMARK_CAPTURE ( BM_Polyline  ,
cubic_polyline  ,
CreateCubic()  ,
false   
)

◆ BENCHMARK_CAPTURE() [2/4]

impeller::BENCHMARK_CAPTURE ( BM_Polyline  ,
cubic_polyline_tess  ,
CreateCubic()  ,
true   
)

◆ BENCHMARK_CAPTURE() [3/4]

impeller::BENCHMARK_CAPTURE ( BM_Polyline  ,
quad_polyline  ,
CreateQuadratic()  ,
false   
)

◆ BENCHMARK_CAPTURE() [4/4]

impeller::BENCHMARK_CAPTURE ( BM_Polyline  ,
quad_polyline_tess  ,
CreateQuadratic()  ,
true   
)

◆ Bind() [1/4]

static bool impeller::Bind ( ComputePassBindingsCache &  pass,
Allocator &  allocator,
size_t  bind_index,
const BufferView &  view 
)
static

Definition at line 165 of file compute_pass_mtl.mm.

168  {
169  if (!view.buffer) {
170  return false;
171  }
172 
173  auto device_buffer = view.buffer->GetDeviceBuffer(allocator);
174  if (!device_buffer) {
175  return false;
176  }
177 
178  auto buffer = DeviceBufferMTL::Cast(*device_buffer).GetMTLBuffer();
179  // The Metal call is a void return and we don't want to make it on nil.
180  if (!buffer) {
181  return false;
182  }
183 
184  pass.SetBuffer(bind_index, view.range.offset, buffer);
185  return true;
186 }

References impeller::BufferView::buffer, impeller::BackendCast< DeviceBufferMTL, Buffer >::Cast(), impeller::DeviceBufferMTL::GetMTLBuffer(), impeller::Range::offset, impeller::BufferView::range, and impeller::ComputePassBindingsCache::SetBuffer().

◆ Bind() [2/4]

static bool impeller::Bind ( ComputePassBindingsCache &  pass,
size_t  bind_index,
const Sampler &  sampler,
const Texture &  texture 
)
static

Definition at line 188 of file compute_pass_mtl.mm.

191  {
192  if (!sampler.IsValid() || !texture.IsValid()) {
193  return false;
194  }
195 
196  pass.SetTexture(bind_index, TextureMTL::Cast(texture).GetMTLTexture());
197  pass.SetSampler(bind_index, SamplerMTL::Cast(sampler).GetMTLSamplerState());
198  return true;
199 }

References impeller::BackendCast< TextureMTL, Texture >::Cast(), impeller::BackendCast< SamplerMTL, Sampler >::Cast(), impeller::Sampler::IsValid(), impeller::Texture::IsValid(), impeller::ComputePassBindingsCache::SetSampler(), and impeller::ComputePassBindingsCache::SetTexture().

◆ Bind() [3/4]

static bool impeller::Bind ( PassBindingsCache &  pass,
Allocator &  allocator,
ShaderStage  stage,
size_t  bind_index,
const BufferView &  view 
)
static

Definition at line 357 of file render_pass_mtl.mm.

361  {
362  if (!view.buffer) {
363  return false;
364  }
365 
366  auto device_buffer = view.buffer->GetDeviceBuffer(allocator);
367  if (!device_buffer) {
368  return false;
369  }
370 
371  auto buffer = DeviceBufferMTL::Cast(*device_buffer).GetMTLBuffer();
372  // The Metal call is a void return and we don't want to make it on nil.
373  if (!buffer) {
374  return false;
375  }
376 
377  return pass.SetBuffer(stage, bind_index, view.range.offset, buffer);
378 }

References impeller::BufferView::buffer, impeller::Range::offset, impeller::BufferView::range, and impeller::PassBindingsCache::SetBuffer().

◆ Bind() [4/4]

static bool impeller::Bind ( PassBindingsCache &  pass,
ShaderStage  stage,
size_t  bind_index,
const Sampler &  sampler,
const Texture &  texture 
)
static

Definition at line 380 of file render_pass_mtl.mm.

384  {
385  if (!sampler.IsValid() || !texture.IsValid()) {
386  return false;
387  }
388 
389  if (texture.NeedsMipmapGeneration()) {
390  // TODO(127697): generate mips when the GPU is available on iOS.
391 #if !FML_OS_IOS
392  VALIDATION_LOG
393  << "Texture at binding index " << bind_index
394  << " has a mip count > 1, but the mipmap has not been generated.";
395  return false;
396 #endif // !FML_OS_IOS
397  }
398 
399  return pass.SetTexture(stage, bind_index,
400  TextureMTL::Cast(texture).GetMTLTexture()) &&
401  pass.SetSampler(stage, bind_index,
402  SamplerMTL::Cast(sampler).GetMTLSamplerState());
403 }

References impeller::Sampler::IsValid(), impeller::Texture::IsValid(), impeller::Texture::NeedsMipmapGeneration(), impeller::PassBindingsCache::SetSampler(), impeller::PassBindingsCache::SetTexture(), and VALIDATION_LOG.

◆ BlendModeToString()

const char * impeller::BlendModeToString ( BlendMode  blend_mode)

Definition at line 47 of file color.cc.

47  {
48  return kBlendModeNames[static_cast<std::underlying_type_t<BlendMode>>(
49  blend_mode)];
50 }

References kBlendModeNames.

Referenced by AdvancedBlend(), PipelineBlend(), impeller::AtlasContents::Render(), and impeller::testing::TEST().

◆ BM_Polyline()

template<class... Args>
static void impeller::BM_Polyline ( benchmark::State &  state,
Args &&...  args 
)
static

Definition at line 24 of file geometry_benchmarks.cc.

24  {
25  auto args_tuple = std::make_tuple(std::move(args)...);
26  auto path = std::get<Path>(args_tuple);
27  bool tessellate = std::get<bool>(args_tuple);
28 
29  size_t point_count = 0u;
30  size_t single_point_count = 0u;
31  while (state.KeepRunning()) {
32  auto polyline = path.CreatePolyline(1.0f);
33  single_point_count = polyline.points.size();
34  point_count += single_point_count;
35  if (tessellate) {
36  tess.Tessellate(
37  FillType::kNonZero, polyline,
38  [](const float* vertices, size_t vertices_count,
39  const uint16_t* indices, size_t indices_count) { return true; });
40  }
41  }
42  state.counters["SinglePointCount"] = single_point_count;
43  state.counters["TotalPointCount"] = point_count;
44 }

References kNonZero, tess, and impeller::Tessellator::Tessellate().

◆ BytesPerPixelForPixelFormat()

constexpr size_t impeller::BytesPerPixelForPixelFormat ( PixelFormat  format)
constexpr

Definition at line 399 of file formats.h.

399  {
400  switch (format) {
401  case PixelFormat::kUnknown:
402  return 0u;
403  case PixelFormat::kA8UNormInt:
404  case PixelFormat::kR8UNormInt:
405  case PixelFormat::kS8UInt:
406  return 1u;
407  case PixelFormat::kR8G8UNormInt:
408  return 2u;
409  case PixelFormat::kR8G8B8A8UNormInt:
410  case PixelFormat::kR8G8B8A8UNormIntSRGB:
411  case PixelFormat::kB8G8R8A8UNormInt:
412  case PixelFormat::kB8G8R8A8UNormIntSRGB:
413  case PixelFormat::kB10G10R10XRSRGB:
414  case PixelFormat::kB10G10R10XR:
415  return 4u;
416  case PixelFormat::kD24UnormS8Uint:
417  return 4u;
418  case PixelFormat::kD32FloatS8UInt:
419  return 5u;
420  case PixelFormat::kR16G16B16A16Float:
421  case PixelFormat::kB10G10R10A10XR:
422  return 8u;
423  case PixelFormat::kR32G32B32A32Float:
424  return 16u;
425  }
426  return 0u;
427 }

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, and kUnknown.

Referenced by impeller::BlitPass::AddCopy(), impeller::BlitCopyTextureToBufferCommandMTL::Encode(), impeller::BlitCopyBufferToTextureCommandMTL::Encode(), impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), impeller::TextureDescriptor::GetBytesPerRow(), and impeller::Allocator::MinimumBytesPerRow().

◆ CanAppendToExistingAtlas() [1/2]

static bool impeller::CanAppendToExistingAtlas ( const std::shared_ptr< GlyphAtlas > &  atlas,
const std::vector< FontGlyphPair > &  extra_pairs,
std::vector< Rect > &  glyph_positions,
ISize  atlas_size,
const std::shared_ptr< RectanglePacker > &  rect_packer 
)
static

Definition at line 78 of file typographer_context_skia.cc.

83  {
84  TRACE_EVENT0("impeller", __FUNCTION__);
85  if (!rect_packer || atlas_size.IsEmpty()) {
86  return false;
87  }
88 
89  // We assume that all existing glyphs will fit. After all, they fit before.
90  // The glyph_positions only contains the values for the additional glyphs
91  // from extra_pairs.
92  FML_DCHECK(glyph_positions.size() == 0);
93  glyph_positions.reserve(extra_pairs.size());
94  for (size_t i = 0; i < extra_pairs.size(); i++) {
95  const FontGlyphPair& pair = extra_pairs[i];
96 
97  const auto glyph_size =
98  ISize::Ceil(pair.glyph.bounds.size * pair.scaled_font.scale);
99  IPoint16 location_in_atlas;
100  if (!rect_packer->addRect(glyph_size.width + kPadding, //
101  glyph_size.height + kPadding, //
102  &location_in_atlas //
103  )) {
104  return false;
105  }
106  glyph_positions.emplace_back(Rect::MakeXYWH(location_in_atlas.x(), //
107  location_in_atlas.y(), //
108  glyph_size.width, //
109  glyph_size.height //
110  ));
111  }
112 
113  return true;
114 }

References impeller::Glyph::bounds, impeller::TSize< int64_t >::Ceil(), impeller::FontGlyphPair::glyph, impeller::TSize< T >::IsEmpty(), kPadding, impeller::TRect< Scalar >::MakeXYWH(), impeller::ScaledFont::scale, impeller::FontGlyphPair::scaled_font, impeller::TRect< T >::size, impeller::IPoint16::x(), and impeller::IPoint16::y().

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas(), and impeller::TypographerContextSTB::CreateGlyphAtlas().

◆ CanAppendToExistingAtlas() [2/2]

static bool impeller::CanAppendToExistingAtlas ( const std::shared_ptr< GlyphAtlas > &  atlas,
const std::vector< FontGlyphPair > &  extra_pairs,
std::vector< Rect > &  glyph_positions,
ISize  atlas_size,
const std::shared_ptr< RectanglePacker > &  rect_packer 
)
static

Definition at line 100 of file typographer_context_stb.cc.

105  {
106  TRACE_EVENT0("impeller", __FUNCTION__);
107  if (!rect_packer || atlas_size.IsEmpty()) {
108  return false;
109  }
110 
111  // We assume that all existing glyphs will fit. After all, they fit before.
112  // The glyph_positions only contains the values for the additional glyphs
113  // from extra_pairs.
114  FML_DCHECK(glyph_positions.size() == 0);
115  glyph_positions.reserve(extra_pairs.size());
116  for (size_t i = 0; i < extra_pairs.size(); i++) {
117  const FontGlyphPair& pair = extra_pairs[i];
118  const Font& font = pair.scaled_font.font;
119 
120  // We downcast to the correct typeface type to access `stb` specific methods
121  std::shared_ptr<TypefaceSTB> typeface_stb =
122  std::reinterpret_pointer_cast<TypefaceSTB>(font.GetTypeface());
123  // Conversion factor to scale font size in Points to pixels.
124  // Note this assumes typical DPI.
125  float text_size_pixels =
126  font.GetMetrics().point_size * TypefaceSTB::kPointsToPixels;
127 
128  ISize glyph_size;
129  {
130  int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
131  // NOTE: We increase the size of the glyph by one pixel in all dimensions
132  // to allow us to cut out padding later.
133  float scale_y = stbtt_ScaleForPixelHeight(typeface_stb->GetFontInfo(),
134  text_size_pixels);
135  float scale_x = scale_y;
136  stbtt_GetGlyphBitmapBox(typeface_stb->GetFontInfo(), pair.glyph.index,
137  scale_x, scale_y, &x0, &y0, &x1, &y1);
138 
139  glyph_size = ISize(x1 - x0, y1 - y0);
140  }
141 
142  IPoint16 location_in_atlas;
143  if (!rect_packer->addRect(glyph_size.width + kPadding, //
144  glyph_size.height + kPadding, //
145  &location_in_atlas //
146  )) {
147  return false;
148  }
149  glyph_positions.emplace_back(Rect::MakeXYWH(location_in_atlas.x(), //
150  location_in_atlas.y(), //
151  glyph_size.width, //
152  glyph_size.height //
153  ));
154  }
155 
156  return true;
157 }

References impeller::ScaledFont::font, impeller::Font::GetMetrics(), impeller::Font::GetTypeface(), impeller::FontGlyphPair::glyph, impeller::TSize< T >::height, impeller::Glyph::index, impeller::TSize< T >::IsEmpty(), kPadding, impeller::TypefaceSTB::kPointsToPixels, impeller::TRect< Scalar >::MakeXYWH(), impeller::Font::Metrics::point_size, impeller::FontGlyphPair::scaled_font, impeller::TSize< T >::width, impeller::IPoint16::x(), and impeller::IPoint16::y().

◆ CanClearAttachment()

constexpr bool impeller::CanClearAttachment ( LoadAction  action)
constexpr

Definition at line 213 of file formats.h.

213  {
214  switch (action) {
215  case LoadAction::kLoad:
216  return false;
217  case LoadAction::kDontCare:
218  case LoadAction::kClear:
219  return true;
220  }
221  FML_UNREACHABLE();
222 }

References kClear, kDontCare, and kLoad.

Referenced by EncodeCommandsInReactor().

◆ CanDiscardAttachmentWhenDone()

constexpr bool impeller::CanDiscardAttachmentWhenDone ( StoreAction  action)
constexpr

Definition at line 224 of file formats.h.

224  {
225  switch (action) {
226  case StoreAction::kStore:
227  case StoreAction::kStoreAndMultisampleResolve:
228  return false;
229  case StoreAction::kDontCare:
230  case StoreAction::kMultisampleResolve:
231  return true;
232  }
233  FML_UNREACHABLE();
234 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by EncodeCommandsInReactor().

◆ ChooseAlphaCompositionMode()

static std::optional<vk::CompositeAlphaFlagBitsKHR> impeller::ChooseAlphaCompositionMode ( vk::CompositeAlphaFlagsKHR  flags)
static

Definition at line 96 of file swapchain_impl_vk.cc.

97  {
98  if (flags & vk::CompositeAlphaFlagBitsKHR::eInherit) {
99  return vk::CompositeAlphaFlagBitsKHR::eInherit;
100  }
101  if (flags & vk::CompositeAlphaFlagBitsKHR::ePreMultiplied) {
102  return vk::CompositeAlphaFlagBitsKHR::ePreMultiplied;
103  }
104  if (flags & vk::CompositeAlphaFlagBitsKHR::ePostMultiplied) {
105  return vk::CompositeAlphaFlagBitsKHR::ePostMultiplied;
106  }
107  if (flags & vk::CompositeAlphaFlagBitsKHR::eOpaque) {
108  return vk::CompositeAlphaFlagBitsKHR::eOpaque;
109  }
110 
111  return std::nullopt;
112 }

◆ ChoosePresentQueue()

static std::optional<vk::Queue> impeller::ChoosePresentQueue ( const vk::PhysicalDevice &  physical_device,
const vk::Device &  device,
const vk::SurfaceKHR &  surface 
)
static

Definition at line 114 of file swapchain_impl_vk.cc.

117  {
118  const auto families = physical_device.getQueueFamilyProperties();
119  for (size_t family_index = 0u; family_index < families.size();
120  family_index++) {
121  auto [result, supported] =
122  physical_device.getSurfaceSupportKHR(family_index, surface);
123  if (result == vk::Result::eSuccess && supported) {
124  return device.getQueue(family_index, 0u);
125  }
126  }
127  return std::nullopt;
128 }

◆ ChooseSurfaceFormat()

static std::optional<vk::SurfaceFormatKHR> impeller::ChooseSurfaceFormat ( const std::vector< vk::SurfaceFormatKHR > &  formats,
PixelFormat  preference 
)
static

Definition at line 74 of file swapchain_impl_vk.cc.

76  {
77  const auto colorspace = vk::ColorSpaceKHR::eSrgbNonlinear;
78  const auto vk_preference =
79  vk::SurfaceFormatKHR{ToVKImageFormat(preference), colorspace};
80  if (ContainsFormat(formats, vk_preference)) {
81  return vk_preference;
82  }
83 
84  std::vector<vk::SurfaceFormatKHR> options = {
85  {vk::Format::eB8G8R8A8Unorm, colorspace},
86  {vk::Format::eR8G8B8A8Unorm, colorspace}};
87  for (const auto& format : options) {
88  if (ContainsFormat(formats, format)) {
89  return format;
90  }
91  }
92 
93  return std::nullopt;
94 }

References ContainsFormat(), and ToVKImageFormat().

◆ ClipColor()

static constexpr Vector3 impeller::ClipColor ( Vector3  color)
inlinestaticconstexpr

Definition at line 144 of file color.cc.

144  {
145  Scalar lum = Luminosity(color);
146  Scalar mn = std::min(std::min(color.x, color.y), color.z);
147  Scalar mx = std::max(std::max(color.x, color.y), color.z);
148  // `lum - mn` and `mx - lum` will always be >= 0 in the following conditions,
149  // so adding a tiny value is enough to make these divisions safe.
150  if (mn < 0.0f) {
151  color = lum + (((color - lum) * lum) / (lum - mn + kEhCloseEnough));
152  }
153  if (mx > 1.0) {
154  color =
155  lum + (((color - lum) * (1.0f - lum)) / (mx - lum + kEhCloseEnough));
156  }
157  return color;
158 }

References kEhCloseEnough, Luminosity(), impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by SetLuminosity().

◆ Close()

IMPELLER_API void impeller::Close ( PathBuilder *  builder)

Definition at line 36 of file tessellator.cc.

36  {
37  builder->Close();
38 }

References impeller::PathBuilder::Close().

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

◆ CollectGLHandle()

static bool impeller::CollectGLHandle ( const ProcTableGLES &  gl,
HandleType  type,
GLuint  handle 
)
static

Definition at line 107 of file reactor_gles.cc.

109  {
110  switch (type) {
111  case HandleType::kUnknown:
112  return false;
113  case HandleType::kTexture:
114  gl.DeleteTextures(1u, &handle);
115  return true;
116  case HandleType::kBuffer:
117  gl.DeleteBuffers(1u, &handle);
118  return true;
119  case HandleType::kProgram:
120  gl.DeleteProgram(handle);
121  return true;
122  case HandleType::kRenderBuffer:
123  gl.DeleteRenderbuffers(1u, &handle);
124  return true;
125  case HandleType::kFrameBuffer:
126  gl.DeleteFramebuffers(1u, &handle);
127  return true;
128  }
129  return false;
130 }

References kBuffer, kFrameBuffer, kProgram, kRenderBuffer, kTexture, and kUnknown.

◆ ColorAttachmentToString()

std::string impeller::ColorAttachmentToString ( const ColorAttachment &  color)

Definition at line 123 of file formats.cc.

123  {
124  std::stringstream stream;
125  stream << AttachmentToString(color) << ",";
126  stream << "ClearColor=(" << ColorToString(color.clear_color) << ")";
127  return stream.str();
128 }

References AttachmentToString(), impeller::ColorAttachment::clear_color, and ColorToString().

Referenced by impeller::RenderTarget::ToString().

◆ ColorToString()

std::string impeller::ColorToString ( const Color &  color)

Definition at line 398 of file color.cc.

398  {
399  return SPrintF("R=%.1f,G=%.1f,B=%.1f,A=%.1f", //
400  color.red, //
401  color.green, //
402  color.blue, //
403  color.alpha //
404  );
405 }

References impeller::Color::alpha, impeller::Color::blue, impeller::Color::green, impeller::Color::red, and SPrintF().

Referenced by ColorAttachmentToString().

◆ ComponentChoose()

static constexpr Vector3 impeller::ComponentChoose ( Vector3  a,
Vector3  b,
Vector3  value,
Scalar  cutoff 
)
inlinestaticconstexpr

Definition at line 178 of file color.cc.

181  {
182  return Vector3(value.x > cutoff ? b.x : a.x, //
183  value.y > cutoff ? b.y : a.y, //
184  value.z > cutoff ? b.z : a.z //
185  );
186 }

References impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by impeller::Color::Blend().

◆ CompressionTypeToString()

constexpr const char* impeller::CompressionTypeToString ( CompressionType  type)
constexpr

Definition at line 25 of file texture_descriptor.h.

25  {
26  switch (type) {
27  case CompressionType::kLossless:
28  return "Lossless";
29  case CompressionType::kLossy:
30  return "Lossy";
31  }
32  FML_UNREACHABLE();
33 }

References kLossless, and kLossy.

Referenced by TextureDescriptorToString().

◆ ComputeUVGeometryCPU()

VertexBufferBuilder< TextureFillVertexShader::PerVertexData > impeller::ComputeUVGeometryCPU ( VertexBufferBuilder< SolidFillVertexShader::PerVertexData > &  input,
Point  texture_origin,
Size  texture_coverage,
Matrix  effect_transform 
)

Compute UV geometry for a VBB that contains only position geometry.

texture_origin should be set to 0, 0 for stroke and stroke based geometry, like the point field.

Definition at line 50 of file geometry.cc.

54  {
55  VertexBufferBuilder<TextureFillVertexShader::PerVertexData> vertex_builder;
56  vertex_builder.Reserve(input.GetVertexCount());
57  input.IterateVertices(
58  [&vertex_builder, &texture_coverage, &effect_transform,
59  &texture_origin](SolidFillVertexShader::PerVertexData old_vtx) {
60  TextureFillVertexShader::PerVertexData data;
61  data.position = old_vtx.position;
62  data.texture_coords = effect_transform *
63  (old_vtx.position - texture_origin) /
64  texture_coverage;
65  vertex_builder.AppendVertex(data);
66  });
67  return vertex_builder;
68 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AppendVertex(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetVertexCount(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::IterateVertices(), and impeller::VertexBufferBuilder< VertexType_, IndexType_ >::Reserve().

◆ ComputeUVGeometryForRect()

GeometryResult impeller::ComputeUVGeometryForRect ( Rect  source_rect,
Rect  texture_coverage,
Matrix  effect_transform,
const ContentContext &  renderer,
const Entity &  entity,
RenderPass &  pass 
)

Definition at line 70 of file geometry.cc.

75  {
76  auto& host_buffer = pass.GetTransientsBuffer();
77 
78  std::vector<Point> data(8);
79  auto points = source_rect.GetPoints();
80  for (auto i = 0u, j = 0u; i < 8; i += 2, j++) {
81  data[i] = points[j];
82  data[i + 1] = effect_transform * (points[j] - texture_coverage.origin) /
83  texture_coverage.size;
84  }
85 
86  return GeometryResult{
87  .type = PrimitiveType::kTriangleStrip,
88  .vertex_buffer =
89  {
90  .vertex_buffer = host_buffer.Emplace(
91  data.data(), 16 * sizeof(float), alignof(float)),
92  .vertex_count = 4,
93  .index_type = IndexType::kNone,
94  },
95  .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
96  entity.GetTransformation(),
97  .prevent_overdraw = false,
98  };
99 }

References impeller::TRect< T >::GetPoints(), impeller::RenderPass::GetRenderTargetSize(), impeller::Entity::GetTransformation(), impeller::RenderPass::GetTransientsBuffer(), kNone, kTriangleStrip, impeller::Matrix::MakeOrthographic(), impeller::TRect< T >::origin, impeller::TRect< T >::size, and impeller::GeometryResult::type.

◆ ConfigureAttachment()

static bool impeller::ConfigureAttachment ( const Attachment &  desc,
MTLRenderPassAttachmentDescriptor *  attachment 
)
static

Definition at line 54 of file render_pass_mtl.mm.

55  {
56  if (!desc.texture) {
57  return false;
58  }
59 
60  attachment.texture = TextureMTL::Cast(*desc.texture).GetMTLTexture();
61  attachment.loadAction = ToMTLLoadAction(desc.load_action);
62  attachment.storeAction = ToMTLStoreAction(desc.store_action);
63 
64  if (!ConfigureResolveTextureAttachment(desc, attachment)) {
65  return false;
66  }
67 
68  return true;
69 }

References impeller::BackendCast< TextureMTL, Texture >::Cast(), ConfigureResolveTextureAttachment(), impeller::TextureMTL::GetMTLTexture(), impeller::Attachment::load_action, impeller::Attachment::store_action, impeller::Attachment::texture, ToMTLLoadAction(), and ToMTLStoreAction().

Referenced by ConfigureColorAttachment(), ConfigureDepthAttachment(), and ConfigureStencilAttachment().

◆ ConfigureBlending()

void impeller::ConfigureBlending ( const ProcTableGLES &  gl,
const ColorAttachmentDescriptor *  color 
)

Definition at line 36 of file render_pass_gles.cc.

37  {
38  if (color->blending_enabled) {
39  gl.Enable(GL_BLEND);
40  gl.BlendFuncSeparate(
41  ToBlendFactor(color->src_color_blend_factor), // src color
42  ToBlendFactor(color->dst_color_blend_factor), // dst color
43  ToBlendFactor(color->src_alpha_blend_factor), // src alpha
44  ToBlendFactor(color->dst_alpha_blend_factor) // dst alpha
45  );
46  gl.BlendEquationSeparate(
47  ToBlendOperation(color->color_blend_op), // mode color
48  ToBlendOperation(color->alpha_blend_op) // mode alpha
49  );
50  } else {
51  gl.Disable(GL_BLEND);
52  }
53 
54  {
55  const auto is_set = [](std::underlying_type_t<ColorWriteMask> mask,
56  ColorWriteMask check) -> GLboolean {
57  using RawType = decltype(mask);
58  return (static_cast<RawType>(mask) & static_cast<RawType>(check))
59  ? GL_TRUE
60  : GL_FALSE;
61  };
62 
63  gl.ColorMask(is_set(color->write_mask, ColorWriteMask::kRed), // red
64  is_set(color->write_mask, ColorWriteMask::kGreen), // green
65  is_set(color->write_mask, ColorWriteMask::kBlue), // blue
66  is_set(color->write_mask, ColorWriteMask::kAlpha) // alpha
67  );
68  }
69 }

References impeller::ColorAttachmentDescriptor::alpha_blend_op, impeller::ColorAttachmentDescriptor::blending_enabled, impeller::ColorAttachmentDescriptor::color_blend_op, impeller::ColorAttachmentDescriptor::dst_alpha_blend_factor, impeller::ColorAttachmentDescriptor::dst_color_blend_factor, kAlpha, kBlue, kGreen, kRed, impeller::ColorAttachmentDescriptor::src_alpha_blend_factor, impeller::ColorAttachmentDescriptor::src_color_blend_factor, ToBlendFactor(), ToBlendOperation(), and impeller::ColorAttachmentDescriptor::write_mask.

Referenced by EncodeCommandsInReactor().

◆ ConfigureColorAttachment()

static bool impeller::ConfigureColorAttachment ( const ColorAttachment &  desc,
MTLRenderPassColorAttachmentDescriptor *  attachment 
)
static

Definition at line 71 of file render_pass_mtl.mm.

73  {
74  if (!ConfigureAttachment(desc, attachment)) {
75  return false;
76  }
77  attachment.clearColor = ToMTLClearColor(desc.clear_color);
78  return true;
79 }

References impeller::ColorAttachment::clear_color, ConfigureAttachment(), and ToMTLClearColor().

Referenced by ToMTLRenderPassDescriptor().

◆ ConfigureDepthAttachment()

static bool impeller::ConfigureDepthAttachment ( const DepthAttachment &  desc,
MTLRenderPassDepthAttachmentDescriptor *  attachment 
)
static

Definition at line 81 of file render_pass_mtl.mm.

83  {
84  if (!ConfigureAttachment(desc, attachment)) {
85  return false;
86  }
87  attachment.clearDepth = desc.clear_depth;
88  return true;
89 }

References impeller::DepthAttachment::clear_depth, and ConfigureAttachment().

Referenced by ToMTLRenderPassDescriptor().

◆ ConfigureFBO()

static std::optional<GLuint> impeller::ConfigureFBO ( const ProcTableGLES &  gl,
const std::shared_ptr< Texture > &  texture,
GLenum  fbo_type 
)
static

Definition at line 23 of file blit_command_gles.cc.

26  {
27  auto handle = TextureGLES::Cast(texture.get())->GetGLHandle();
28  if (!handle.has_value()) {
29  return std::nullopt;
30  }
31 
32  if (TextureGLES::Cast(*texture).IsWrapped()) {
33  // The texture is attached to the default FBO, so there's no need to
34  // create/configure one.
35  gl.BindFramebuffer(fbo_type, 0);
36  return 0;
37  }
38 
39  GLuint fbo;
40  gl.GenFramebuffers(1u, &fbo);
41  gl.BindFramebuffer(fbo_type, fbo);
42 
43  if (!TextureGLES::Cast(*texture).SetAsFramebufferAttachment(
44  fbo_type, fbo, TextureGLES::AttachmentPoint::kColor0)) {
45  VALIDATION_LOG << "Could not attach texture to framebuffer.";
46  DeleteFBO(gl, fbo, fbo_type);
47  return std::nullopt;
48  }
49 
50  if (gl.CheckFramebufferStatus(fbo_type) != GL_FRAMEBUFFER_COMPLETE) {
51  VALIDATION_LOG << "Could not create a complete frambuffer.";
52  DeleteFBO(gl, fbo, fbo_type);
53  return std::nullopt;
54  }
55 
56  return fbo;
57 };

References impeller::BackendCast< TextureGLES, Texture >::Cast(), DeleteFBO(), impeller::TextureGLES::GetGLHandle(), impeller::TextureGLES::kColor0, impeller::TextureGLES::SetAsFramebufferAttachment(), and VALIDATION_LOG.

Referenced by impeller::BlitCopyTextureToTextureCommandGLES::Encode(), and impeller::BlitCopyTextureToBufferCommandGLES::Encode().

◆ ConfigureResolveTextureAttachment()

static bool impeller::ConfigureResolveTextureAttachment ( const Attachment &  desc,
MTLRenderPassAttachmentDescriptor *  attachment 
)
static

Definition at line 25 of file render_pass_mtl.mm.

27  {
28  bool needs_resolve =
29  desc.store_action == StoreAction::kMultisampleResolve ||
30  desc.store_action == StoreAction::kStoreAndMultisampleResolve;
31 
32  if (needs_resolve && !desc.resolve_texture) {
33  VALIDATION_LOG << "Resolve store action specified on attachment but no "
34  "resolve texture was specified.";
35  return false;
36  }
37 
38  if (desc.resolve_texture && !needs_resolve) {
39  VALIDATION_LOG << "A resolve texture was specified even though the store "
40  "action doesn't require it.";
41  return false;
42  }
43 
44  if (!desc.resolve_texture) {
45  return true;
46  }
47 
48  attachment.resolveTexture =
49  TextureMTL::Cast(*desc.resolve_texture).GetMTLTexture();
50 
51  return true;
52 }

References impeller::BackendCast< TextureMTL, Texture >::Cast(), impeller::TextureMTL::GetMTLTexture(), kMultisampleResolve, kStoreAndMultisampleResolve, impeller::Attachment::resolve_texture, impeller::Attachment::store_action, and VALIDATION_LOG.

Referenced by ConfigureAttachment().

◆ ConfigureStencil() [1/2]

void impeller::ConfigureStencil ( const ProcTableGLES &  gl,
const PipelineDescriptor &  pipeline,
uint32_t  stencil_reference 
)

Definition at line 89 of file render_pass_gles.cc.

91  {
92  if (!pipeline.HasStencilAttachmentDescriptors()) {
93  gl.Disable(GL_STENCIL_TEST);
94  return;
95  }
96 
97  gl.Enable(GL_STENCIL_TEST);
98  const auto& front = pipeline.GetFrontStencilAttachmentDescriptor();
99  const auto& back = pipeline.GetBackStencilAttachmentDescriptor();
100 
101  if (front.has_value() && back.has_value() && front == back) {
102  ConfigureStencil(GL_FRONT_AND_BACK, gl, *front, stencil_reference);
103  return;
104  }
105  if (front.has_value()) {
106  ConfigureStencil(GL_FRONT, gl, *front, stencil_reference);
107  }
108  if (back.has_value()) {
109  ConfigureStencil(GL_BACK, gl, *back, stencil_reference);
110  }
111 }

References ConfigureStencil(), impeller::PipelineDescriptor::GetBackStencilAttachmentDescriptor(), impeller::PipelineDescriptor::GetFrontStencilAttachmentDescriptor(), and impeller::PipelineDescriptor::HasStencilAttachmentDescriptors().

◆ ConfigureStencil() [2/2]

void impeller::ConfigureStencil ( GLenum  face,
const ProcTableGLES &  gl,
const StencilAttachmentDescriptor &  stencil,
uint32_t  stencil_reference 
)

Definition at line 71 of file render_pass_gles.cc.

74  {
75  gl.StencilOpSeparate(
76  face, // face
77  ToStencilOp(stencil.stencil_failure), // stencil fail
78  ToStencilOp(stencil.depth_failure), // depth fail
79  ToStencilOp(stencil.depth_stencil_pass) // depth stencil pass
80  );
81  gl.StencilFuncSeparate(face, // face
82  ToCompareFunction(stencil.stencil_compare), // func
83  stencil_reference, // ref
84  stencil.read_mask // mask
85  );
86  gl.StencilMaskSeparate(face, stencil.write_mask);
87 }

References impeller::StencilAttachmentDescriptor::depth_failure, impeller::StencilAttachmentDescriptor::depth_stencil_pass, impeller::StencilAttachmentDescriptor::read_mask, impeller::StencilAttachmentDescriptor::stencil_compare, impeller::StencilAttachmentDescriptor::stencil_failure, ToCompareFunction(), ToStencilOp(), and impeller::StencilAttachmentDescriptor::write_mask.

Referenced by ConfigureStencil(), and EncodeCommandsInReactor().

◆ ConfigureStencilAttachment()

static bool impeller::ConfigureStencilAttachment ( const StencilAttachment &  desc,
MTLRenderPassStencilAttachmentDescriptor *  attachment 
)
static

Definition at line 91 of file render_pass_mtl.mm.

93  {
94  if (!ConfigureAttachment(desc, attachment)) {
95  return false;
96  }
97  attachment.clearStencil = desc.clear_stencil;
98  return true;
99 }

References impeller::StencilAttachment::clear_stencil, and ConfigureAttachment().

Referenced by ToMTLRenderPassDescriptor().

◆ ContainsFormat()

static bool impeller::ContainsFormat ( const std::vector< vk::SurfaceFormatKHR > &  formats,
vk::SurfaceFormatKHR  format 
)
static

Definition at line 69 of file swapchain_impl_vk.cc.

70  {
71  return std::find(formats.begin(), formats.end(), format) != formats.end();
72 }

Referenced by ChooseSurfaceFormat().

◆ CreateAtlasBitmap() [1/2]

static std::shared_ptr<SkBitmap> impeller::CreateAtlasBitmap ( const GlyphAtlas &  atlas,
const ISize &  atlas_size 
)
static

Definition at line 215 of file typographer_context_skia.cc.

216  {
217  TRACE_EVENT0("impeller", __FUNCTION__);
218  auto bitmap = std::make_shared<SkBitmap>();
219  SkImageInfo image_info;
220 
221  switch (atlas.GetType()) {
222  case GlyphAtlas::Type::kAlphaBitmap:
223  image_info = SkImageInfo::MakeA8(atlas_size.width, atlas_size.height);
224  break;
225  case GlyphAtlas::Type::kColorBitmap:
226  image_info =
227  SkImageInfo::MakeN32Premul(atlas_size.width, atlas_size.height);
228  break;
229  }
230 
231  if (!bitmap->tryAllocPixels(image_info)) {
232  return nullptr;
233  }
234 
235  auto surface = SkSurfaces::WrapPixels(bitmap->pixmap());
236  if (!surface) {
237  return nullptr;
238  }
239  auto canvas = surface->getCanvas();
240  if (!canvas) {
241  return nullptr;
242  }
243 
244  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
245 
246  atlas.IterateGlyphs([canvas, has_color](const ScaledFont& scaled_font,
247  const Glyph& glyph,
248  const Rect& location) -> bool {
249  DrawGlyph(canvas, scaled_font, glyph, location, has_color);
250  return true;
251  });
252 
253  return bitmap;
254 }

References DrawGlyph(), impeller::GlyphAtlas::GetType(), impeller::TSize< T >::height, impeller::GlyphAtlas::IterateGlyphs(), impeller::GlyphAtlas::kAlphaBitmap, impeller::GlyphAtlas::kColorBitmap, and impeller::TSize< T >::width.

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas(), and impeller::TypographerContextSTB::CreateGlyphAtlas().

◆ CreateAtlasBitmap() [2/2]

static std::shared_ptr<BitmapSTB> impeller::CreateAtlasBitmap ( const GlyphAtlas &  atlas,
const ISize &  atlas_size 
)
static

Definition at line 292 of file typographer_context_stb.cc.

293  {
294  TRACE_EVENT0("impeller", __FUNCTION__);
295 
296  size_t bytes_per_pixel = 1;
297  if (atlas.GetType() == GlyphAtlas::Type::kColorBitmap &&
298  !DISABLE_COLOR_FONT_SUPPORT) {
299  bytes_per_pixel = kColorFontBitsPerPixel;
300  }
301  auto bitmap = std::make_shared<BitmapSTB>(atlas_size.width, atlas_size.height,
302  bytes_per_pixel);
303 
304  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
305 
306  atlas.IterateGlyphs([&bitmap, has_color](const ScaledFont& scaled_font,
307  const Glyph& glyph,
308  const Rect& location) -> bool {
309  DrawGlyph(bitmap.get(), scaled_font, glyph, location, has_color);
310  return true;
311  });
312 
313  return bitmap;
314 }

References DISABLE_COLOR_FONT_SUPPORT, DrawGlyph(), impeller::GlyphAtlas::GetType(), impeller::TSize< T >::height, impeller::GlyphAtlas::IterateGlyphs(), impeller::GlyphAtlas::kColorBitmap, kColorFontBitsPerPixel, and impeller::TSize< T >::width.

◆ CreateAttachmentDescription() [1/2]

static vk::AttachmentDescription impeller::CreateAttachmentDescription ( const Attachment &  attachment,
const std::shared_ptr< Texture > Attachment::*  texture_ptr 
)
static

Definition at line 31 of file render_pass_vk.cc.

33  {
34  const auto& texture = attachment.*texture_ptr;
35  if (!texture) {
36  return {};
37  }
38  const auto& texture_vk = TextureVK::Cast(*texture);
39  const auto& desc = texture->GetTextureDescriptor();
40  auto current_layout = texture_vk.GetLayout();
41 
42  auto load_action = attachment.load_action;
43  auto store_action = attachment.store_action;
44 
45  if (current_layout == vk::ImageLayout::eUndefined) {
46  load_action = LoadAction::kClear;
47  }
48 
49  if (desc.storage_mode == StorageMode::kDeviceTransient) {
50  store_action = StoreAction::kDontCare;
51  } else if (texture_ptr == &Attachment::resolve_texture) {
52  store_action = StoreAction::kStore;
53  }
54 
55  if (current_layout != vk::ImageLayout::ePresentSrcKHR &&
56  current_layout != vk::ImageLayout::eUndefined) {
57  // Note: This should incur a barrier.
58  current_layout = vk::ImageLayout::eGeneral;
59  }
60 
61  return CreateAttachmentDescription(desc.format, //
62  desc.sample_count, //
63  load_action, //
64  store_action, //
65  current_layout //
66  );
67 }

References impeller::BackendCast< TextureVK, Texture >::Cast(), CreateAttachmentDescription(), kClear, kDeviceTransient, kDontCare, kStore, impeller::Attachment::load_action, impeller::Attachment::resolve_texture, and impeller::Attachment::store_action.

◆ CreateAttachmentDescription() [2/2]

constexpr vk::AttachmentDescription impeller::CreateAttachmentDescription ( PixelFormat  format,
SampleCount  sample_count,
LoadAction  load_action,
StoreAction  store_action,
vk::ImageLayout  current_layout 
)
constexpr

Definition at line 431 of file formats_vk.h.

436  {
437  vk::AttachmentDescription vk_attachment;
438 
439  vk_attachment.format = ToVKImageFormat(format);
440  vk_attachment.samples = ToVKSampleCount(sample_count);
441 
442  // The Vulkan spec has somewhat complicated rules for when these ops are used
443  // and ignored. Just set safe defaults.
444  vk_attachment.loadOp = vk::AttachmentLoadOp::eDontCare;
445  vk_attachment.storeOp = vk::AttachmentStoreOp::eDontCare;
446  vk_attachment.stencilLoadOp = vk::AttachmentLoadOp::eDontCare;
447  vk_attachment.stencilStoreOp = vk::AttachmentStoreOp::eDontCare;
448 
449  const auto kind = AttachmentKindFromFormat(format);
450 
451  switch (kind) {
452  case AttachmentKind::kColor:
453  // If the attachment uses a color format, then loadOp and storeOp are
454  // used, and stencilLoadOp and stencilStoreOp are ignored.
455  vk_attachment.loadOp = ToVKAttachmentLoadOp(load_action);
456  vk_attachment.storeOp = ToVKAttachmentStoreOp(store_action);
457  break;
458  case AttachmentKind::kDepth:
459  case AttachmentKind::kDepthStencil:
460  // If the format has depth and/or stencil components, loadOp and storeOp
461  // apply only to the depth data, while stencilLoadOp and stencilStoreOp
462  // define how the stencil data is handled.
463  vk_attachment.loadOp = ToVKAttachmentLoadOp(load_action);
464  vk_attachment.storeOp = ToVKAttachmentStoreOp(store_action);
465  [[fallthrough]];
466  case AttachmentKind::kStencil:
467  vk_attachment.stencilLoadOp = ToVKAttachmentLoadOp(load_action);
468  vk_attachment.stencilStoreOp = ToVKAttachmentStoreOp(store_action);
469  break;
470  }
471 
472  switch (kind) {
473  case AttachmentKind::kColor:
474  vk_attachment.initialLayout = current_layout;
475  vk_attachment.finalLayout = vk::ImageLayout::eColorAttachmentOptimal;
476  break;
477  case AttachmentKind::kDepth:
478  case AttachmentKind::kStencil:
479  case AttachmentKind::kDepthStencil:
480  // Separate depth stencil layouts feature is only available in Vulkan 1.2.
481  vk_attachment.initialLayout = current_layout;
482  vk_attachment.finalLayout =
483  vk::ImageLayout::eDepthStencilAttachmentOptimal;
484  break;
485  }
486 
487  return vk_attachment;
488 }

References AttachmentKindFromFormat(), kColor, kDepth, kDepthStencil, kStencil, ToVKAttachmentLoadOp(), ToVKAttachmentStoreOp(), ToVKImageFormat(), and ToVKSampleCount().

Referenced by CreateAttachmentDescription(), and CreatePlaceholderAttachmentDescription().

◆ CreateBufferPool()

static PoolVMA impeller::CreateBufferPool ( VmaAllocator  allocator)
static

Definition at line 47 of file allocator_vk.cc.

47  {
48  vk::BufferCreateInfo buffer_info;
49  buffer_info.usage = vk::BufferUsageFlagBits::eVertexBuffer |
50  vk::BufferUsageFlagBits::eIndexBuffer |
51  vk::BufferUsageFlagBits::eUniformBuffer |
52  vk::BufferUsageFlagBits::eStorageBuffer |
53  vk::BufferUsageFlagBits::eTransferSrc |
54  vk::BufferUsageFlagBits::eTransferDst;
55  buffer_info.size = 1u; // doesn't matter
56  buffer_info.sharingMode = vk::SharingMode::eExclusive;
57  auto buffer_info_native =
58  static_cast<vk::BufferCreateInfo::NativeType>(buffer_info);
59 
60  VmaAllocationCreateInfo allocation_info = {};
61  allocation_info.usage = VMA_MEMORY_USAGE_AUTO;
62  allocation_info.preferredFlags = static_cast<VkMemoryPropertyFlags>(
63  ToVKBufferMemoryPropertyFlags(StorageMode::kHostVisible));
64  allocation_info.flags =
65  ToVmaAllocationBufferCreateFlags(StorageMode::kHostVisible);
66 
67  uint32_t memTypeIndex;
68  auto result = vk::Result{vmaFindMemoryTypeIndexForBufferInfo(
69  allocator, &buffer_info_native, &allocation_info, &memTypeIndex)};
70  if (result != vk::Result::eSuccess) {
71  return {};
72  }
73 
74  VmaPoolCreateInfo pool_create_info = {};
75  pool_create_info.memoryTypeIndex = memTypeIndex;
76  pool_create_info.flags = VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT;
77 
78  VmaPool pool = {};
79  result = vk::Result{::vmaCreatePool(allocator, &pool_create_info, &pool)};
80  if (result != vk::Result::eSuccess) {
81  return {};
82  }
83  return {allocator, pool};
84 }

References kHostVisible, ToVKBufferMemoryPropertyFlags(), and ToVmaAllocationBufferCreateFlags().

◆ CreateCommandBuffer()

static id<MTLCommandBuffer> impeller::CreateCommandBuffer ( id< MTLCommandQueue >  queue)
static

Definition at line 118 of file command_buffer_mtl.mm.

118  {
119 #ifndef FLUTTER_RELEASE
120  if (@available(iOS 14.0, macOS 11.0, *)) {
121  auto desc = [[MTLCommandBufferDescriptor alloc] init];
122  // Degrades CPU performance slightly but is well worth the cost for typical
123  // Impeller workloads.
124  desc.errorOptions = MTLCommandBufferErrorOptionEncoderExecutionStatus;
125  return [queue commandBufferWithDescriptor:desc];
126  }
127 #endif // FLUTTER_RELEASE
128  return [queue commandBuffer];
129 }

◆ CreateCompatRenderPassForPipeline()

static vk::UniqueRenderPass impeller::CreateCompatRenderPassForPipeline ( const vk::Device &  device,
const PipelineDescriptor &  desc 
)
static

Render Pass We are NOT going to use the same render pass with the framebuffer (later) and the graphics pipeline (here). Instead, we are going to ensure that the sub-passes are compatible. To see the compatibility rules, see the Vulkan spec: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/chap8.html#renderpass-compatibility

Definition at line 78 of file pipeline_library_vk.cc.

80  {
81  std::vector<vk::AttachmentDescription> attachments;
82 
83  std::vector<vk::AttachmentReference> color_refs;
84  vk::AttachmentReference depth_stencil_ref = kUnusedAttachmentReference;
85 
86  color_refs.resize(desc.GetMaxColorAttacmentBindIndex() + 1,
87  kUnusedAttachmentReference);
88 
89  const auto sample_count = desc.GetSampleCount();
90 
91  for (const auto& [bind_point, color] : desc.GetColorAttachmentDescriptors()) {
92  color_refs[bind_point] =
93  vk::AttachmentReference{static_cast<uint32_t>(attachments.size()),
94  vk::ImageLayout::eColorAttachmentOptimal};
95  attachments.emplace_back(
96  CreatePlaceholderAttachmentDescription(color.format, sample_count));
97  }
98 
99  if (auto depth = desc.GetDepthStencilAttachmentDescriptor();
100  depth.has_value()) {
101  depth_stencil_ref = vk::AttachmentReference{
102  static_cast<uint32_t>(attachments.size()),
103  vk::ImageLayout::eDepthStencilAttachmentOptimal};
104  attachments.emplace_back(CreatePlaceholderAttachmentDescription(
105  desc.GetDepthPixelFormat(), sample_count));
106  }
107  if (desc.HasStencilAttachmentDescriptors()) {
108  depth_stencil_ref = vk::AttachmentReference{
109  static_cast<uint32_t>(attachments.size()),
110  vk::ImageLayout::eDepthStencilAttachmentOptimal};
111  attachments.emplace_back(CreatePlaceholderAttachmentDescription(
112  desc.GetStencilPixelFormat(), sample_count));
113  }
114 
115  vk::SubpassDescription subpass_desc;
116  subpass_desc.pipelineBindPoint = vk::PipelineBindPoint::eGraphics;
117  subpass_desc.setColorAttachments(color_refs);
118  subpass_desc.setPDepthStencilAttachment(&depth_stencil_ref);
119 
120  vk::RenderPassCreateInfo render_pass_desc;
121  render_pass_desc.setAttachments(attachments);
122  render_pass_desc.setPSubpasses(&subpass_desc);
123  render_pass_desc.setSubpassCount(1u);
124 
125  auto [result, pass] = device.createRenderPassUnique(render_pass_desc);
126  if (result != vk::Result::eSuccess) {
127  VALIDATION_LOG << "Failed to create render pass for pipeline '"
128  << desc.GetLabel() << "'. Error: " << vk::to_string(result);
129  return {};
130  }
131 
132  // This pass is not used with the render pass. It is only necessary to tell
133  // Vulkan the expected render pass layout. The actual pass will be created
134  // later during render pass setup and will need to be compatible with this
135  // one.
136  ContextVK::SetDebugName(device, pass.get(),
137  "Compat Render Pass: " + desc.GetLabel());
138 
139  return std::move(pass);
140 }

References CreatePlaceholderAttachmentDescription(), impeller::PipelineDescriptor::GetColorAttachmentDescriptors(), impeller::PipelineDescriptor::GetDepthPixelFormat(), impeller::PipelineDescriptor::GetDepthStencilAttachmentDescriptor(), impeller::PipelineDescriptor::GetLabel(), impeller::PipelineDescriptor::GetMaxColorAttacmentBindIndex(), impeller::PipelineDescriptor::GetSampleCount(), impeller::PipelineDescriptor::GetStencilPixelFormat(), impeller::PipelineDescriptor::HasStencilAttachmentDescriptors(), kUnusedAttachmentReference, impeller::ContextVK::SetDebugName(), and VALIDATION_LOG.

◆ CreateDefaultPipeline()

template<typename PipelineT >
static std::unique_ptr<PipelineT> impeller::CreateDefaultPipeline ( const Context &  context)
static

Definition at line 157 of file content_context.cc.

158  {
159  auto desc = PipelineT::Builder::MakeDefaultPipelineDescriptor(context);
160  if (!desc.has_value()) {
161  return nullptr;
162  }
163  // Apply default ContentContextOptions to the descriptor.
164  const auto default_color_format =
165  context.GetCapabilities()->GetDefaultColorFormat();
166  ContentContextOptions{.sample_count = SampleCount::kCount4,
167  .color_attachment_pixel_format = default_color_format}
168  .ApplyToPipelineDescriptor(*desc);
169  return std::make_unique<PipelineT>(context, desc);
170 }

References impeller::Context::GetCapabilities(), kCount4, and impeller::ContentContextOptions::sample_count.

◆ CreateDepthStencilDescriptor()

static id<MTLDepthStencilState> impeller::CreateDepthStencilDescriptor ( const PipelineDescriptor &  desc,
id< MTLDevice >  device 
)
static

Definition at line 75 of file pipeline_library_mtl.mm.

77  {
78  auto descriptor = ToMTLDepthStencilDescriptor(
79  desc.GetDepthStencilAttachmentDescriptor(), //
80  desc.GetFrontStencilAttachmentDescriptor(), //
81  desc.GetBackStencilAttachmentDescriptor() //
82  );
83  return [device newDepthStencilStateWithDescriptor:descriptor];
84 }

References impeller::PipelineDescriptor::GetBackStencilAttachmentDescriptor(), impeller::PipelineDescriptor::GetDepthStencilAttachmentDescriptor(), impeller::PipelineDescriptor::GetFrontStencilAttachmentDescriptor(), and ToMTLDepthStencilDescriptor().

◆ CreateDeviceBuffer()

template<typename T >
static std::shared_ptr<DeviceBuffer> impeller::CreateDeviceBuffer ( const std::shared_ptr< Context > &  context,
const std::string &  label,
StorageMode  storage_mode = StorageMode::kDevicePrivate 
)
static

Definition at line 18 of file compute_tessellator.cc.

21  {
22  DeviceBufferDescriptor desc;
23  desc.storage_mode = storage_mode;
24  desc.size = sizeof(T);
25  auto buffer = context->GetResourceAllocator()->CreateBuffer(desc);
26  buffer->SetLabel(label);
27  return buffer;
28 }

References impeller::DeviceBufferDescriptor::size, and impeller::DeviceBufferDescriptor::storage_mode.

◆ CreateGLHandle()

static std::optional<GLuint> impeller::CreateGLHandle ( const ProcTableGLES &  gl,
HandleType  type 
)
static

Definition at line 83 of file reactor_gles.cc.

84  {
85  GLuint handle = GL_NONE;
86  switch (type) {
87  case HandleType::kUnknown:
88  return std::nullopt;
89  case HandleType::kTexture:
90  gl.GenTextures(1u, &handle);
91  return handle;
92  case HandleType::kBuffer:
93  gl.GenBuffers(1u, &handle);
94  return handle;
95  case HandleType::kProgram:
96  return gl.CreateProgram();
97  case HandleType::kRenderBuffer:
98  gl.GenRenderbuffers(1u, &handle);
99  return handle;
100  case HandleType::kFrameBuffer:
101  gl.GenFramebuffers(1u, &handle);
102  return handle;
103  }
104  return std::nullopt;
105 }

References kBuffer, kFrameBuffer, kProgram, kRenderBuffer, kTexture, and kUnknown.

Referenced by impeller::ReactorGLES::CreateHandle().

◆ CreateGradientBuffer()

GradientData impeller::CreateGradientBuffer ( const std::vector< Color > &  colors,
const std::vector< Scalar > &  stops 
)

Populate a vector with the interpolated color bytes for the linear gradient described by colors and stops.

Parameters
colors
stops
Returns
GradientData

Definition at line 20 of file gradient.cc.

21  {
22  FML_DCHECK(stops.size() == colors.size());
23 
24  uint32_t texture_size;
25  if (stops.size() == 2) {
26  texture_size = colors.size();
27  } else {
28  auto minimum_delta = 1.0;
29  for (size_t i = 1; i < stops.size(); i++) {
30  auto value = stops[i] - stops[i - 1];
31  // Smaller than kEhCloseEnough
32  if (value < 0.0001) {
33  continue;
34  }
35  if (value < minimum_delta) {
36  minimum_delta = value;
37  }
38  }
39  // Avoid creating textures that are absurdly large due to stops that are
40  // very close together.
41  // TODO(jonahwilliams): this should use a platform specific max texture
42  // size.
43  texture_size = std::min(
44  static_cast<uint32_t>(std::round(1.0 / minimum_delta)) + 1, 1024u);
45  }
46  GradientData data = {
47  .color_bytes = {},
48  .texture_size = texture_size,
49  };
50  data.color_bytes.reserve(texture_size * 4);
51 
52  if (texture_size == colors.size() && colors.size() <= 1024) {
53  for (auto i = 0u; i < colors.size(); i++) {
54  AppendColor(colors[i], &data);
55  }
56  } else {
57  Color previous_color = colors[0];
58  auto previous_stop = 0.0;
59  auto previous_color_index = 0;
60 
61  // The first index is always equal to the first color, exactly.
62  AppendColor(previous_color, &data);
63 
64  for (auto i = 1u; i < texture_size - 1; i++) {
65  auto scaled_i = i / (texture_size - 1.0);
66  Color next_color = colors[previous_color_index + 1];
67  auto next_stop = stops[previous_color_index + 1];
68  // We're almost exactly equal to the next stop.
69  if (ScalarNearlyEqual(scaled_i, next_stop)) {
70  AppendColor(next_color, &data);
71 
72  previous_color = next_color;
73  previous_stop = next_stop;
74  previous_color_index += 1;
75  } else if (scaled_i < next_stop) {
76  // We're still between the current stop and the next stop.
77  auto t = (scaled_i - previous_stop) / (next_stop - previous_stop);
78  auto mixed_color = Color::Lerp(previous_color, next_color, t);
79 
80  AppendColor(mixed_color, &data);
81  } else {
82  // We've slightly overshot the previous stop.
83  previous_color = next_color;
84  previous_stop = next_stop;
85  previous_color_index += 1;
86  next_color = colors[previous_color_index + 1];
87  auto next_stop = stops[previous_color_index + 1];
88 
89  auto t = (scaled_i - previous_stop) / (next_stop - previous_stop);
90  auto mixed_color = Color::Lerp(previous_color, next_color, t);
91 
92  AppendColor(mixed_color, &data);
93  }
94  }
95  // The last index is always equal to the last color, exactly.
96  AppendColor(colors.back(), &data);
97  }
98  return data;
99 }

References AppendColor(), impeller::GradientData::color_bytes, impeller::Color::Lerp(), and ScalarNearlyEqual().

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

◆ CreateGradientColors()

std::vector< StopData > impeller::CreateGradientColors ( const std::vector< Color > &  colors,
const std::vector< Scalar > &  stops 
)

Populate a vector with the color and stop data for a gradient.

Parameters
colors
stops
Returns
StopData

Definition at line 45 of file gradient_generator.cc.

46  {
47  FML_DCHECK(stops.size() == colors.size());
48 
49  std::vector<StopData> result(stops.size());
50  for (auto i = 0u; i < stops.size(); i++) {
51  result[i] = {.color = colors[i], .stop = stops[i]};
52  }
53  return result;
54 }

◆ CreateGradientTexture()

std::shared_ptr< Texture > impeller::CreateGradientTexture ( const GradientData &  gradient_data,
const std::shared_ptr< impeller::Context > &  context 
)

Create a host visible texture that contains the gradient defined by the provided gradient data.

Definition at line 17 of file gradient_generator.cc.

19  {
20  if (gradient_data.texture_size == 0) {
21  FML_DLOG(ERROR) << "Invalid gradient data.";
22  return nullptr;
23  }
24 
25  impeller::TextureDescriptor texture_descriptor;
26  texture_descriptor.storage_mode = impeller::StorageMode::kHostVisible;
27  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
28  texture_descriptor.size = {gradient_data.texture_size, 1};
29  auto texture =
30  context->GetResourceAllocator()->CreateTexture(texture_descriptor);
31  if (!texture) {
32  FML_DLOG(ERROR) << "Could not create Impeller texture.";
33  return nullptr;
34  }
35 
36  auto mapping = std::make_shared<fml::DataMapping>(gradient_data.color_bytes);
37  if (!texture->SetContents(mapping)) {
38  FML_DLOG(ERROR) << "Could not copy contents into Impeller texture.";
39  return nullptr;
40  }
41  texture->SetLabel(impeller::SPrintF("Gradient(%p)", texture.get()).c_str());
42  return texture;
43 }

References impeller::GradientData::color_bytes, impeller::TextureDescriptor::format, kHostVisible, kR8G8B8A8UNormInt, impeller::TextureDescriptor::size, SPrintF(), impeller::TextureDescriptor::storage_mode, and impeller::GradientData::texture_size.

◆ CreateMappingFromAllocation()

std::shared_ptr< fml::Mapping > impeller::CreateMappingFromAllocation ( const std::shared_ptr< Allocation > &  allocation)

Definition at line 100 of file allocation.cc.

101  {
102  if (!allocation) {
103  return nullptr;
104  }
105  return std::make_shared<fml::NonOwnedMapping>(
106  reinterpret_cast<const uint8_t*>(allocation->GetBuffer()), //
107  allocation->GetLength(), //
108  [allocation](auto, auto) {} //
109  );
110 }

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

◆ CreateMappingWithCopy()

std::shared_ptr< fml::Mapping > impeller::CreateMappingWithCopy ( const uint8_t *  contents,
size_t  length 
)

Definition at line 84 of file allocation.cc.

85  {
86  if (contents == nullptr) {
87  return nullptr;
88  }
89 
90  auto allocation = std::make_shared<Allocation>();
91  if (!allocation->Truncate(length)) {
92  return nullptr;
93  }
94 
95  std::memmove(allocation->GetBuffer(), contents, length);
96 
97  return CreateMappingFromAllocation(allocation);
98 }

References CreateMappingFromAllocation().

◆ CreateMappingWithString() [1/2]

std::shared_ptr<fml::Mapping> impeller::CreateMappingWithString ( std::shared_ptr< const std::string >  string)

◆ CreateMappingWithString() [2/2]

std::shared_ptr< fml::Mapping > impeller::CreateMappingWithString ( std::string  string)

Definition at line 112 of file allocation.cc.

112  {
113  auto buffer = std::make_shared<std::string>(std::move(string));
114  return std::make_unique<fml::NonOwnedMapping>(
115  reinterpret_cast<const uint8_t*>(buffer->c_str()), buffer->length(),
116  [buffer](auto, auto) {});
117 }

Referenced by impeller::compiler::Compiler::Compiler().

◆ CreateMetalCommandQueue()

static id<MTLCommandQueue> impeller::CreateMetalCommandQueue ( id< MTLDevice >  device)
static

Definition at line 219 of file context_mtl.mm.

219  {
220  auto command_queue = device.newCommandQueue;
221  if (!command_queue) {
222  VALIDATION_LOG << "Could not set up the command queue.";
223  return nullptr;
224  }
225  command_queue.label = @"Impeller Command Queue";
226  return command_queue;
227 }

References VALIDATION_LOG.

Referenced by impeller::ContextMTL::Create().

◆ CreateMetalDevice()

static id<MTLDevice> impeller::CreateMetalDevice ( )
static

Definition at line 215 of file context_mtl.mm.

215  {
216  return ::MTLCreateSystemDefaultDevice();
217 }

Referenced by impeller::ContextMTL::Create().

◆ CreatePathBuilder()

IMPELLER_API PathBuilder * impeller::CreatePathBuilder ( )

Definition at line 10 of file tessellator.cc.

10  {
11  return new PathBuilder();
12 }

◆ CreatePipelineFuture() [1/2]

PipelineFuture< ComputePipelineDescriptor > impeller::CreatePipelineFuture ( const Context &  context,
std::optional< ComputePipelineDescriptor >  desc 
)

Definition at line 35 of file pipeline.cc.

37  {
38  if (!context.IsValid()) {
39  return {
40  desc,
41  RealizedFuture<std::shared_ptr<Pipeline<ComputePipelineDescriptor>>>(
42  nullptr)};
43  }
44 
45  return context.GetPipelineLibrary()->GetPipeline(std::move(desc));
46 }

References impeller::Context::GetPipelineLibrary(), and impeller::Context::IsValid().

◆ CreatePipelineFuture() [2/2]

PipelineFuture< PipelineDescriptor > impeller::CreatePipelineFuture ( const Context &  context,
std::optional< PipelineDescriptor >  desc 
)

Definition at line 24 of file pipeline.cc.

26  {
27  if (!context.IsValid()) {
28  return {desc, RealizedFuture<std::shared_ptr<Pipeline<PipelineDescriptor>>>(
29  nullptr)};
30  }
31 
32  return context.GetPipelineLibrary()->GetPipeline(std::move(desc));
33 }

References impeller::Context::GetPipelineLibrary(), and impeller::Context::IsValid().

◆ CreatePlaceholderAttachmentDescription()

static vk::AttachmentDescription impeller::CreatePlaceholderAttachmentDescription ( PixelFormat  format,
SampleCount  sample_count 
)
static

Creates an attachment description that does just enough to ensure render pass compatibility with the pass associated later with the framebuffer.

See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/chap8.html#renderpass-compatibility

Definition at line 57 of file pipeline_library_vk.cc.

59  {
60  // Load store ops are immaterial for pass compatibility. The right ops will be
61  // picked up when the pass associated with framebuffer.
62  return CreateAttachmentDescription(format, //
63  sample_count, //
64  LoadAction::kDontCare, //
65  StoreAction::kDontCare, //
66  vk::ImageLayout::eUndefined //
67  );
68 }

References CreateAttachmentDescription(), and kDontCare.

Referenced by CreateCompatRenderPassForPipeline().

◆ CreatePool()

static vk::UniqueDescriptorPool impeller::CreatePool ( const vk::Device &  device,
uint32_t  pool_count 
)
static

Definition at line 21 of file descriptor_pool_vk.cc.

22  {
23  TRACE_EVENT0("impeller", "CreateDescriptorPool");
24  std::vector<vk::DescriptorPoolSize> pools = {
25  {vk::DescriptorType::eCombinedImageSampler, pool_count},
26  {vk::DescriptorType::eUniformBuffer, pool_count},
27  {vk::DescriptorType::eStorageBuffer, pool_count}};
28 
29  vk::DescriptorPoolCreateInfo pool_info;
30  pool_info.setMaxSets(pools.size() * pool_count);
31  pool_info.setPoolSizes(pools);
32 
33  auto [result, pool] = device.createDescriptorPoolUnique(pool_info);
34  if (result != vk::Result::eSuccess) {
35  VALIDATION_LOG << "Unable to create a descriptor pool";
36  }
37  return std::move(pool);
38 }

References VALIDATION_LOG.

◆ CreateRenderTarget()

static EntityPassTarget impeller::CreateRenderTarget ( ContentContext &  renderer,
ISize  size,
bool  readable,
const Color &  clear_color 
)
static

All of the load/store actions are managed by InlinePassContext when RenderPasses are created, so we just set them to kDontCare here. What's important is the StorageMode of the textures, which cannot be changed for the lifetime of the textures.

Definition at line 270 of file entity_pass.cc.

273  {
274  auto context = renderer.GetContext();
275 
276  /// All of the load/store actions are managed by `InlinePassContext` when
277  /// `RenderPasses` are created, so we just set them to `kDontCare` here.
278  /// What's important is the `StorageMode` of the textures, which cannot be
279  /// changed for the lifetime of the textures.
280 
281  RenderTarget target;
282  if (context->GetCapabilities()->SupportsOffscreenMSAA()) {
283  target = RenderTarget::CreateOffscreenMSAA(
284  *context, // context
285  *renderer.GetRenderTargetCache(), // allocator
286  size, // size
287  "EntityPass", // label
288  RenderTarget::AttachmentConfigMSAA{
289  .storage_mode = StorageMode::kDeviceTransient,
290  .resolve_storage_mode = StorageMode::kDevicePrivate,
291  .load_action = LoadAction::kDontCare,
292  .store_action = StoreAction::kMultisampleResolve,
293  .clear_color = clear_color}, // color_attachment_config
294  GetDefaultStencilConfig(readable) // stencil_attachment_config
295  );
296  } else {
297  target = RenderTarget::CreateOffscreen(
298  *context, // context
299  *renderer.GetRenderTargetCache(), // allocator
300  size, // size
301  "EntityPass", // label
302  RenderTarget::AttachmentConfig{
303  .storage_mode = StorageMode::kDevicePrivate,
304  .load_action = LoadAction::kDontCare,
305  .store_action = StoreAction::kDontCare,
306  .clear_color = clear_color,
307  }, // color_attachment_config
308  GetDefaultStencilConfig(readable) // stencil_attachment_config
309  );
310  }
311 
312  return EntityPassTarget(
313  target, renderer.GetDeviceCapabilities().SupportsReadFromResolve());
314 }

References impeller::RenderTarget::CreateOffscreen(), impeller::RenderTarget::CreateOffscreenMSAA(), impeller::ContentContext::GetContext(), GetDefaultStencilConfig(), impeller::ContentContext::GetDeviceCapabilities(), impeller::ContentContext::GetRenderTargetCache(), and impeller::Capabilities::SupportsReadFromResolve().

◆ CreateTextureForDecompressedImage()

static std::shared_ptr<Texture> impeller::CreateTextureForDecompressedImage ( const std::shared_ptr< Context > &  context,
DecompressedImage &  decompressed_image,
bool  enable_mipmapping 
)
static

Definition at line 384 of file playground.cc.

387  {
388  // TODO(https://github.com/flutter/flutter/issues/123468): copying buffers to
389  // textures is not implemented for GLES.
390  if (context->GetCapabilities()->SupportsBufferToTextureBlits()) {
391  impeller::TextureDescriptor texture_descriptor;
392  texture_descriptor.storage_mode = impeller::StorageMode::kDevicePrivate;
393  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
394  texture_descriptor.size = decompressed_image.GetSize();
395  texture_descriptor.mip_count =
396  enable_mipmapping ? decompressed_image.GetSize().MipCount() : 1u;
397 
398  auto dest_texture =
399  context->GetResourceAllocator()->CreateTexture(texture_descriptor);
400  if (!dest_texture) {
401  FML_DLOG(ERROR) << "Could not create Impeller texture.";
402  return nullptr;
403  }
404 
405  auto buffer = context->GetResourceAllocator()->CreateBufferWithCopy(
406  *decompressed_image.GetAllocation().get());
407 
408  dest_texture->SetLabel(
409  impeller::SPrintF("ui.Image(%p)", dest_texture.get()).c_str());
410 
411  auto command_buffer = context->CreateCommandBuffer();
412  if (!command_buffer) {
413  FML_DLOG(ERROR)
414  << "Could not create command buffer for mipmap generation.";
415  return nullptr;
416  }
417  command_buffer->SetLabel("Mipmap Command Buffer");
418 
419  auto blit_pass = command_buffer->CreateBlitPass();
420  if (!blit_pass) {
421  FML_DLOG(ERROR) << "Could not create blit pass for mipmap generation.";
422  return nullptr;
423  }
424  blit_pass->SetLabel("Mipmap Blit Pass");
425  blit_pass->AddCopy(buffer->AsBufferView(), dest_texture);
426  if (enable_mipmapping) {
427  blit_pass->GenerateMipmap(dest_texture);
428  }
429 
430  blit_pass->EncodeCommands(context->GetResourceAllocator());
431  if (!command_buffer->SubmitCommands()) {
432  FML_DLOG(ERROR) << "Failed to submit blit pass command buffer.";
433  return nullptr;
434  }
435  return dest_texture;
436  } else { // Doesn't support buffer-to-texture blits.
437  auto texture_descriptor = TextureDescriptor{};
438  texture_descriptor.storage_mode = StorageMode::kHostVisible;
439  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
440  texture_descriptor.size = decompressed_image.GetSize();
441  texture_descriptor.mip_count =
442  enable_mipmapping ? decompressed_image.GetSize().MipCount() : 1u;
443 
444  auto texture =
445  context->GetResourceAllocator()->CreateTexture(texture_descriptor);
446  if (!texture) {
447  VALIDATION_LOG << "Could not allocate texture for fixture.";
448  return nullptr;
449  }
450 
451  auto uploaded = texture->SetContents(decompressed_image.GetAllocation());
452  if (!uploaded) {
453  VALIDATION_LOG
454  << "Could not upload texture to device memory for fixture.";
455  return nullptr;
456  }
457  return texture;
458  }
459 }

References impeller::TextureDescriptor::format, impeller::DecompressedImage::GetAllocation(), impeller::DecompressedImage::GetSize(), kDevicePrivate, kHostVisible, kR8G8B8A8UNormInt, impeller::TextureDescriptor::mip_count, impeller::TSize< T >::MipCount(), impeller::TextureDescriptor::size, SPrintF(), impeller::TextureDescriptor::storage_mode, and VALIDATION_LOG.

Referenced by impeller::Playground::CreateTextureForMapping().

◆ CreateUniformMemberKey() [1/2]

static std::string impeller::CreateUniformMemberKey ( const std::string &  non_struct_member)
static

Definition at line 78 of file buffer_bindings_gles.cc.

79  {
80  return NormalizeUniformKey(non_struct_member);
81 }

References NormalizeUniformKey().

◆ CreateUniformMemberKey() [2/2]

static std::string impeller::CreateUniformMemberKey ( const std::string &  struct_name,
const std::string &  member,
bool  is_array 
)
static

Definition at line 64 of file buffer_bindings_gles.cc.

66  {
67  std::string result;
68  result.reserve(struct_name.length() + member.length() + (is_array ? 4 : 1));
69  result += struct_name;
70  result += '.';
71  result += member;
72  if (is_array) {
73  result += "[0]";
74  }
75  return NormalizeUniformKey(result);
76 }

References NormalizeUniformKey().

◆ CubicPathBoundingPopulateValues()

static void impeller::CubicPathBoundingPopulateValues ( std::vector< Scalar > &  values,
Scalar  p1,
Scalar  p2,
Scalar  p3,
Scalar  p4 
)
static

Definition at line 255 of file path_component.cc.

259  {
260  const Scalar a = 3.0 * (-p1 + 3.0 * p2 - 3.0 * p3 + p4);
261  const Scalar b = 6.0 * (p1 - 2.0 * p2 + p3);
262  const Scalar c = 3.0 * (p2 - p1);
263 
264  /*
265  * Boundary conditions.
266  */
267  if (NearZero(a)) {
268  if (NearZero(b)) {
269  return;
270  }
271 
272  Scalar t = -c / b;
273  if (t >= 0.0 && t <= 1.0) {
274  values.emplace_back(t);
275  }
276  return;
277  }
278 
279  Scalar b2Minus4AC = (b * b) - (4.0 * a * c);
280 
281  if (b2Minus4AC < 0.0) {
282  return;
283  }
284 
285  Scalar rootB2Minus4AC = ::sqrt(b2Minus4AC);
286 
287  /* From Numerical Recipes in C.
288  *
289  * q = -1/2 (b + sign(b) sqrt[b^2 - 4ac])
290  * x1 = q / a
291  * x2 = c / q
292  */
293  Scalar q = (b < 0) ? -(b - rootB2Minus4AC) / 2 : -(b + rootB2Minus4AC) / 2;
294 
295  {
296  Scalar t = q / a;
297  if (t >= 0.0 && t <= 1.0) {
298  values.emplace_back(t);
299  }
300  }
301 
302  {
303  Scalar t = c / q;
304  if (t >= 0.0 && t <= 1.0) {
305  values.emplace_back(t);
306  }
307  }
308 }

References NearZero().

Referenced by impeller::CubicPathComponent::Extrema().

◆ CubicSolve()

static Scalar impeller::CubicSolve ( Scalar  t,
Scalar  p0,
Scalar  p1,
Scalar  p2,
Scalar  p3 
)
inlinestatic

Definition at line 33 of file path_component.cc.

37  {
38  return (1 - t) * (1 - t) * (1 - t) * p0 + //
39  3 * (1 - t) * (1 - t) * t * p1 + //
40  3 * (1 - t) * t * t * p2 + //
41  t * t * t * p3;
42 }

Referenced by impeller::CubicPathComponent::Solve().

◆ CubicSolveDerivative()

static Scalar impeller::CubicSolveDerivative ( Scalar  t,
Scalar  p0,
Scalar  p1,
Scalar  p2,
Scalar  p3 
)
inlinestatic

Definition at line 44 of file path_component.cc.

48  {
49  return -3 * p0 * (1 - t) * (1 - t) + //
50  p1 * (3 * (1 - t) * (1 - t) - 6 * (1 - t) * t) +
51  p2 * (6 * (1 - t) * t - 3 * t * t) + //
52  3 * p3 * t * t;
53 }

Referenced by impeller::CubicPathComponent::SolveDerivative().

◆ CubicTo()

IMPELLER_API void impeller::CubicTo ( PathBuilder *  builder,
Scalar  x1,
Scalar  y1,
Scalar  x2,
Scalar  y2,
Scalar  x3,
Scalar  y3 
)

Definition at line 26 of file tessellator.cc.

32  {
33  builder->CubicCurveTo(Point(x1, y1), Point(x2, y2), Point(x3, y3));
34 }

References impeller::PathBuilder::CubicCurveTo().

◆ DecorateCacheWithMetadata()

static std::shared_ptr<fml::Mapping> impeller::DecorateCacheWithMetadata ( std::shared_ptr< fml::Mapping >  data)
static

Definition at line 24 of file pipeline_cache_vk.cc.

25  {
26  return data;
27 }

Referenced by impeller::PipelineCacheVK::PersistCacheToDisk().

◆ DeepCompareMap()

template<class Key , class ComparableType , class = std::enable_if_t<std::is_base_of_v<ComparableBase, ComparableType>>>
bool impeller::DeepCompareMap ( const std::map< Key, std::shared_ptr< ComparableType >> &  lhs,
const std::map< Key, std::shared_ptr< ComparableType >> &  rhs 
)

Definition at line 77 of file comparable.h.

78  {
79  if (lhs.size() != rhs.size()) {
80  return false;
81  }
82 
83  for (auto i = lhs.begin(), j = rhs.begin(); i != lhs.end(); i++, j++) {
84  if (i->first != j->first) {
85  return false;
86  }
87 
88  if (!DeepComparePointer(i->second, j->second)) {
89  return false;
90  }
91  }
92 
93  return true;
94 }

References DeepComparePointer().

Referenced by impeller::PipelineDescriptor::IsEqual().

◆ DeepComparePointer()

template<class ComparableType , class = std::enable_if_t<std::is_base_of_v<ComparableBase, ComparableType>>>
bool impeller::DeepComparePointer ( const std::shared_ptr< ComparableType > &  lhs,
const std::shared_ptr< ComparableType > &  rhs 
)

Definition at line 60 of file comparable.h.

61  {
62  if (lhs == rhs) {
63  return true;
64  }
65 
66  if (lhs && rhs) {
67  return lhs->IsEqual(*rhs);
68  }
69 
70  return false;
71 }

Referenced by DeepCompareMap(), impeller::ComputePipelineDescriptor::IsEqual(), impeller::Font::IsEqual(), and impeller::PipelineDescriptor::IsEqual().

◆ DefaultUniformAlignment()

constexpr size_t impeller::DefaultUniformAlignment ( )
constexpr

Definition at line 14 of file platform.h.

14  {
15 #if FML_OS_IOS && !TARGET_OS_SIMULATOR
16  return 16u;
17 #else
18  return 256u;
19 #endif
20 }

Referenced by impeller::HostBuffer::EmplaceStorageBuffer(), impeller::HostBuffer::EmplaceUniform(), and impeller::RuntimeEffectContents::Render().

◆ DeleteFBO()

static void impeller::DeleteFBO ( const ProcTableGLES &  gl,
GLuint  fbo,
GLenum  type 
)
static

Definition at line 16 of file blit_command_gles.cc.

16  {
17  if (fbo != GL_NONE) {
18  gl.BindFramebuffer(type, GL_NONE);
19  gl.DeleteFramebuffers(1u, &fbo);
20  }
21 };

Referenced by ConfigureFBO(), impeller::BlitCopyTextureToTextureCommandGLES::Encode(), and impeller::BlitCopyTextureToBufferCommandGLES::Encode().

◆ DepthAttachmentToString()

std::string impeller::DepthAttachmentToString ( const DepthAttachment &  depth)

Definition at line 130 of file formats.cc.

130  {
131  std::stringstream stream;
132  stream << AttachmentToString(depth) << ",";
133  stream << "ClearDepth=" << SPrintF("%.2f", depth.clear_depth);
134  return stream.str();
135 }

References AttachmentToString(), impeller::DepthAttachment::clear_depth, and SPrintF().

Referenced by impeller::RenderTarget::ToString().

◆ DescribeFramebufferAttachment()

static std::string impeller::DescribeFramebufferAttachment ( const ProcTableGLES &  gl,
GLenum  attachment 
)
static

Definition at line 175 of file proc_table_gles.cc.

176  {
177  GLint param = GL_NONE;
178  gl.GetFramebufferAttachmentParameteriv(
179  GL_FRAMEBUFFER, // target
180  attachment, // attachment
181  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, // parameter name
182  &param // parameter
183  );
184 
185  if (param != GL_NONE) {
186  param = GL_NONE;
187  gl.GetFramebufferAttachmentParameteriv(
188  GL_FRAMEBUFFER, // target
189  attachment, // attachment
190  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, // parameter name
191  &param // parameter
192  );
193  std::stringstream stream;
194  stream << AttachmentTypeString(param) << "(" << param << ")";
195  return stream.str();
196  }
197 
198  return "No Attachment";
199 }

References AttachmentTypeString().

Referenced by impeller::ProcTableGLES::DescribeCurrentFramebuffer().

◆ DestroyPathBuilder()

IMPELLER_API void impeller::DestroyPathBuilder ( PathBuilder *  builder)

Definition at line 14 of file tessellator.cc.

14  {
15  delete builder;
16 }

◆ DestroyTessellator()

void impeller::DestroyTessellator ( TESStesselator *  tessellator)

Definition at line 162 of file tessellator.cc.

162  {
163  if (tessellator != nullptr) {
164  ::tessDeleteTess(tessellator);
165  }
166 }

Referenced by impeller::Tessellator::Tessellator().

◆ DestroyVertices()

IMPELLER_API void impeller::DestroyVertices ( Vertices *  vertices)

Definition at line 75 of file tessellator.cc.

75  {
76  delete vertices->points;
77  delete vertices;
78 }

References impeller::Vertices::points.

◆ DetermineIfES()

static bool impeller::DetermineIfES ( const std::string &  version)
static

Definition at line 39 of file description_gles.cc.

39  {
40  return HasPrefix(version, "OpenGL ES");
41 }

References HasPrefix().

Referenced by impeller::DescriptionGLES::DescriptionGLES().

◆ DetermineVersion()

static std::optional<Version> impeller::DetermineVersion ( std::string  version)
static

Definition at line 43 of file description_gles.cc.

43  {
44  // Format for OpenGL "OpenGL<space>ES<space><version
45  // number><space><vendor-specific information>".
46  //
47  // Format for OpenGL SL "OpenGL<space>ES<space>GLSL<space>ES<space><version
48  // number><space><vendor-specific information>"
49  //
50  // The prefixes appear to be absent on Desktop GL.
51 
52  version = StripPrefix(version, "OpenGL ES ");
53  version = StripPrefix(version, "GLSL ES ");
54 
55  if (version.empty()) {
56  return std::nullopt;
57  }
58 
59  std::stringstream stream;
60  for (size_t i = 0; i < version.size(); i++) {
61  const auto character = version[i];
62  if (std::isdigit(character) || character == '.') {
63  stream << character;
64  } else {
65  break;
66  }
67  }
68  std::istringstream istream;
69  istream.str(stream.str());
70  std::vector<size_t> version_components;
71  for (std::string version_component;
72  std::getline(istream, version_component, '.');) {
73  version_components.push_back(std::stoul(version_component));
74  }
75  return Version::FromVector(version_components);
76 }

References impeller::Version::FromVector(), and StripPrefix().

Referenced by impeller::DescriptionGLES::DescriptionGLES().

◆ DeviceHasUnifiedMemoryArchitecture()

static bool impeller::DeviceHasUnifiedMemoryArchitecture ( id< MTLDevice >  device)
static

Definition at line 38 of file allocator_mtl.mm.

38  {
39  if (@available(ios 13.0, tvos 13.0, macOS 10.15, *)) {
40  return [device hasUnifiedMemory];
41  } else {
42 #if FML_OS_IOS
43  // iOS devices where the availability check can fail always have had UMA.
44  return true;
45 #else
46  // Mac devices where the availability check can fail have never had UMA.
47  return false;
48 #endif
49  }
50  FML_UNREACHABLE();
51 }

◆ DeviceMaxTextureSizeSupported()

static ISize impeller::DeviceMaxTextureSizeSupported ( id< MTLDevice >  device)
static

Definition at line 53 of file allocator_mtl.mm.

53  {
54  // Since Apple didn't expose API for us to get the max texture size, we have
55  // to use hardcoded data from
56  // https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
57  // According to the feature set table, there are two supported max sizes :
58  // 16384 and 8192 for devices flutter support. The former is used on macs and
59  // latest ios devices. The latter is used on old ios devices.
60  if (@available(macOS 10.15, iOS 13, tvOS 13, *)) {
61  if ([device supportsFamily:MTLGPUFamilyApple3] ||
62  [device supportsFamily:MTLGPUFamilyMacCatalyst1] ||
63  [device supportsFamily:MTLGPUFamilyMac1]) {
64  return {16384, 16384};
65  }
66  return {8192, 8192};
67  } else {
68 #if FML_OS_IOS
69  if ([device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily4_v1] ||
70  [device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily3_v1]) {
71  return {16384, 16384};
72  }
73 #endif
74 #if FML_OS_MACOSX
75  return {16384, 16384};
76 #endif
77  return {8192, 8192};
78  }
79 }

◆ DeviceSupportsComputeSubgroups()

static bool impeller::DeviceSupportsComputeSubgroups ( id< MTLDevice >  device)
static

Definition at line 40 of file context_mtl.mm.

40  {
41  bool supports_subgroups = false;
42  // Refer to the "SIMD-scoped reduction operations" feature in the table
43  // below: https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
44  if (@available(ios 13.0, tvos 13.0, macos 10.15, *)) {
45  supports_subgroups = [device supportsFamily:MTLGPUFamilyApple7] ||
46  [device supportsFamily:MTLGPUFamilyMac2];
47  }
48  return supports_subgroups;
49 }

Referenced by InferMetalCapabilities().

◆ DeviceSupportsDeviceTransientTargets()

static bool impeller::DeviceSupportsDeviceTransientTargets ( id< MTLDevice >  device)
static

Definition at line 17 of file allocator_mtl.mm.

17  {
18  // Refer to the "Memoryless render targets" feature in the table below:
19  // https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
20  if (@available(ios 13.0, tvos 13.0, macos 10.15, *)) {
21  return [device supportsFamily:MTLGPUFamilyApple2];
22  } else {
23 #if FML_OS_IOS
24  // This is perhaps redundant. But, just in case we somehow get into a case
25  // where Impeller runs on iOS versions less than 8.0 and/or without A8
26  // GPUs, we explicitly check feature set support.
27  return [device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily2_v1];
28 #else
29  // MacOS devices with Apple GPUs are only available with macos 10.15 and
30  // above. So, if we are here, it is safe to assume that memory-less targets
31  // are not supported.
32  return false;
33 #endif
34  }
35  FML_UNREACHABLE();
36 }

◆ DeviceSupportsFramebufferFetch()

static bool impeller::DeviceSupportsFramebufferFetch ( id< MTLDevice >  device)
static

Definition at line 20 of file context_mtl.mm.

20  {
21  // The iOS simulator lies about supporting framebuffer fetch.
22 #if FML_OS_IOS_SIMULATOR
23  return false;
24 #else // FML_OS_IOS_SIMULATOR
25 
26  if (@available(macOS 10.15, iOS 13, tvOS 13, *)) {
27  return [device supportsFamily:MTLGPUFamilyApple2];
28  }
29  // According to
30  // https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf , Apple2
31  // corresponds to iOS GPU family 2, which supports A8 devices.
32 #if FML_OS_IOS
33  return [device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily2_v1];
34 #else
35  return false;
36 #endif // FML_OS_IOS
37 #endif // FML_OS_IOS_SIMULATOR
38 }

Referenced by InferMetalCapabilities().

◆ DoColorBlend()

static constexpr Color impeller::DoColorBlend ( Color  d,
Color  s,
const std::function< Vector3(Vector3, Vector3)> &  blend_rgb_func 
)
inlinestaticconstexpr

Definition at line 196 of file color.cc.

199  {
200  d = d.Premultiply();
201  s = s.Premultiply();
202  const Vector3 rgb = blend_rgb_func(ToRGB(d), ToRGB(s));
203  const Color blended = Color::Lerp(s, FromRGB(rgb, d.alpha), d.alpha);
204  return Color::Lerp(d, blended, s.alpha).Unpremultiply();
205 }

References impeller::Color::alpha, FromRGB(), impeller::Color::Lerp(), impeller::Color::Premultiply(), ToRGB(), and impeller::Color::Unpremultiply().

Referenced by impeller::Color::Blend().

◆ DoColorBlendComponents()

static constexpr Color impeller::DoColorBlendComponents ( Color  d,
Color  s,
const std::function< Scalar(Scalar, Scalar)> &  blend_func 
)
inlinestaticconstexpr

Definition at line 207 of file color.cc.

210  {
211  d = d.Premultiply();
212  s = s.Premultiply();
213  const Color blended = Color::Lerp(s,
214  Color(blend_func(d.red, s.red), //
215  blend_func(d.green, s.green), //
216  blend_func(d.blue, s.blue), //
217  d.alpha),
218  d.alpha);
219  return Color::Lerp(d, blended, s.alpha).Unpremultiply();
220 }

References impeller::Color::alpha, impeller::Color::blue, impeller::Color::green, impeller::Color::Lerp(), impeller::Color::Premultiply(), impeller::Color::red, and impeller::Color::Unpremultiply().

Referenced by impeller::Color::Blend().

◆ DrawGlyph() [1/2]

static void impeller::DrawGlyph ( BitmapSTB *  bitmap,
const ScaledFont &  scaled_font,
const Glyph &  glyph,
const Rect &  location,
bool  has_color 
)
static

Definition at line 198 of file typographer_context_stb.cc.

202  {
203  const auto& metrics = scaled_font.font.GetMetrics();
204 
205  const impeller::Font& font = scaled_font.font;
206  auto typeface = font.GetTypeface();
207  // We downcast to the correct typeface type to access `stb` specific methods
208  std::shared_ptr<TypefaceSTB> typeface_stb =
209  std::reinterpret_pointer_cast<TypefaceSTB>(typeface);
210  // Conversion factor to scale font size in Points to pixels.
211  // Note this assumes typical DPI.
212  float text_size_pixels = metrics.point_size * TypefaceSTB::kPointsToPixels;
213  float scale_y =
214  stbtt_ScaleForPixelHeight(typeface_stb->GetFontInfo(), text_size_pixels);
215  float scale_x = scale_y;
216 
217  auto output =
218  bitmap->GetPixelAddress({static_cast<size_t>(location.origin.x),
219  static_cast<size_t>(location.origin.y)});
220  // For Alpha and Signed Distance field bitmaps we can use STB to draw the
221  // Glyph in place
222  if (!has_color || DISABLE_COLOR_FONT_SUPPORT) {
223  stbtt_MakeGlyphBitmap(typeface_stb->GetFontInfo(), output,
224  location.size.width - kPadding,
225  location.size.height - kPadding,
226  bitmap->GetRowBytes(), scale_x, scale_y, glyph.index);
227  } else {
228  // But for color bitmaps we need to get the glyph pixels and then carry all
229  // channels into the atlas bitmap. This may not be performant but I'm unsure
230  // of any other approach currently.
231  int glyph_bitmap_width = 0;
232  int glyph_bitmap_height = 0;
233  int glyph_bitmap_xoff = 0;
234  int glyph_bitmap_yoff = 0;
235  auto glyph_pixels = stbtt_GetGlyphBitmap(
236  typeface_stb->GetFontInfo(), scale_x, scale_y, glyph.index,
237  &glyph_bitmap_width, &glyph_bitmap_height, &glyph_bitmap_xoff,
238  &glyph_bitmap_yoff);
239 
240  uint8_t* write_pos = output;
241  for (auto y = 0; y < glyph_bitmap_height; ++y) {
242  for (auto x = 0; x < glyph_bitmap_width; ++x) {
243  // Color bitmaps write as White (i.e. what is 0 in an alpha bitmap is
244  // 255 in a color bitmap) But not alpha. Alpha still carries
245  // transparency info in the normal way.
246  // There's some issue with color fonts, in that if the pixel color is
247  // nonzero, the alpha is ignored during rendering. That is, partially
248  // (or fully) transparent pixels with nonzero color are rendered as
249  // fully opaque.
250  uint8_t a = glyph_pixels[x + y * glyph_bitmap_width];
251  uint8_t c = 255 - a;
252 
253  // Red channel
254  *write_pos = c;
255  write_pos++;
256  // Green channel
257  *write_pos = c;
258  write_pos++;
259  // Blue channel
260  *write_pos = c;
261  write_pos++;
262  // Alpha channel
263  *write_pos = a;
264  write_pos++;
265  }
266  // next row
267  write_pos = output + (y * bitmap->GetRowBytes());
268  }
269  stbtt_FreeBitmap(glyph_pixels, nullptr);
270  }
271 }

References DISABLE_COLOR_FONT_SUPPORT, impeller::ScaledFont::font, impeller::Font::GetMetrics(), impeller::BitmapSTB::GetPixelAddress(), impeller::BitmapSTB::GetRowBytes(), impeller::Font::GetTypeface(), impeller::TSize< T >::height, impeller::Glyph::index, kPadding, impeller::TypefaceSTB::kPointsToPixels, impeller::TRect< T >::origin, impeller::TRect< T >::size, impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ DrawGlyph() [2/2]

static void impeller::DrawGlyph ( SkCanvas *  canvas,
const ScaledFont &  scaled_font,
const Glyph &  glyph,
const Rect &  location,
bool  has_color 
)
static

Definition at line 155 of file typographer_context_skia.cc.

159  {
160  const auto& metrics = scaled_font.font.GetMetrics();
161  const auto position = SkPoint::Make(location.origin.x / scaled_font.scale,
162  location.origin.y / scaled_font.scale);
163  SkGlyphID glyph_id = glyph.index;
164 
165  SkFont sk_font(
166  TypefaceSkia::Cast(*scaled_font.font.GetTypeface()).GetSkiaTypeface(),
167  metrics.point_size, metrics.scaleX, metrics.skewX);
168  sk_font.setEdging(SkFont::Edging::kAntiAlias);
169  sk_font.setHinting(SkFontHinting::kSlight);
170  sk_font.setEmbolden(metrics.embolden);
171 
172  auto glyph_color = has_color ? SK_ColorWHITE : SK_ColorBLACK;
173 
174  SkPaint glyph_paint;
175  glyph_paint.setColor(glyph_color);
176  canvas->resetMatrix();
177  canvas->scale(scaled_font.scale, scaled_font.scale);
178  canvas->drawGlyphs(1u, // count
179  &glyph_id, // glyphs
180  &position, // positions
181  SkPoint::Make(-glyph.bounds.GetLeft(),
182  -glyph.bounds.GetTop()), // origin
183  sk_font, // font
184  glyph_paint // paint
185  );
186 }

References impeller::Glyph::bounds, impeller::BackendCast< TypefaceSkia, Typeface >::Cast(), impeller::ScaledFont::font, impeller::TRect< T >::GetLeft(), impeller::Font::GetMetrics(), impeller::TypefaceSkia::GetSkiaTypeface(), impeller::TRect< T >::GetTop(), impeller::Font::GetTypeface(), impeller::Glyph::index, impeller::TRect< T >::origin, impeller::ScaledFont::scale, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by CreateAtlasBitmap(), and UpdateAtlasBitmap().

◆ EmptyFeedback()

static vk::PipelineCreationFeedbackEXT impeller::EmptyFeedback ( )
static

Definition at line 152 of file pipeline_library_vk.cc.

152  {
153  vk::PipelineCreationFeedbackEXT feedback;
154  // If the VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT is not set in flags, an
155  // implementation must not set any other bits in flags, and the values of all
156  // other VkPipelineCreationFeedback data members are undefined.
157  feedback.flags = vk::PipelineCreationFeedbackFlagBits::eValid;
158  return feedback;
159 }

◆ EncodeCommand()

static bool impeller::EncodeCommand ( const Context &  context,
const Command &  command,
CommandEncoderVK &  encoder,
PassBindingsCache &  command_buffer_cache,
const ISize &  target_size,
size_t  command_count 
)
static

Definition at line 486 of file render_pass_vk.cc.

491  {
492  if (command.vertex_count == 0u || command.instance_count == 0u) {
493  return true;
494  }
495 
496 #ifdef IMPELLER_DEBUG
497  fml::ScopedCleanupClosure pop_marker(
498  [&encoder]() { encoder.PopDebugGroup(); });
499  if (!command.label.empty()) {
500  encoder.PushDebugGroup(command.label.c_str());
501  } else {
502  pop_marker.Release();
503  }
504 #endif // IMPELLER_DEBUG
505 
506  const auto& cmd_buffer = encoder.GetCommandBuffer();
507 
508  const auto& pipeline_vk = PipelineVK::Cast(*command.pipeline);
509 
510  if (!AllocateAndBindDescriptorSets(ContextVK::Cast(context), //
511  command, //
512  encoder, //
513  pipeline_vk, //
514  command_count //
515  )) {
516  return false;
517  }
518 
519  command_buffer_cache.BindPipeline(
520  cmd_buffer, vk::PipelineBindPoint::eGraphics, pipeline_vk.GetPipeline());
521 
522  // Set the viewport and scissors.
523  SetViewportAndScissor(command, cmd_buffer, command_buffer_cache, target_size);
524 
525  // Set the stencil reference.
526  command_buffer_cache.SetStencilReference(
527  cmd_buffer, vk::StencilFaceFlagBits::eVkStencilFrontAndBack,
528  command.stencil_reference);
529 
530  // Configure vertex and index and buffers for binding.
531  auto vertex_buffer_view = command.GetVertexBuffer();
532 
533  if (!vertex_buffer_view) {
534  return false;
535  }
536 
537  auto& allocator = *context.GetResourceAllocator();
538 
539  auto vertex_buffer = vertex_buffer_view.buffer->GetDeviceBuffer(allocator);
540 
541  if (!vertex_buffer) {
542  VALIDATION_LOG << "Failed to acquire device buffer"
543  << " for vertex buffer view";
544  return false;
545  }
546 
547  if (!encoder.Track(vertex_buffer)) {
548  return false;
549  }
550 
551  // Bind the vertex buffer.
552  auto vertex_buffer_handle = DeviceBufferVK::Cast(*vertex_buffer).GetBuffer();
553  vk::Buffer vertex_buffers[] = {vertex_buffer_handle};
554  vk::DeviceSize vertex_buffer_offsets[] = {vertex_buffer_view.range.offset};
555  cmd_buffer.bindVertexBuffers(0u, 1u, vertex_buffers, vertex_buffer_offsets);
556 
557  if (command.index_type != IndexType::kNone) {
558  // Bind the index buffer.
559  auto index_buffer_view = command.index_buffer;
560  if (!index_buffer_view) {
561  return false;
562  }
563 
564  auto index_buffer = index_buffer_view.buffer->GetDeviceBuffer(allocator);
565  if (!index_buffer) {
566  VALIDATION_LOG << "Failed to acquire device buffer"
567  << " for index buffer view";
568  return false;
569  }
570 
571  if (!encoder.Track(index_buffer)) {
572  return false;
573  }
574 
575  auto index_buffer_handle = DeviceBufferVK::Cast(*index_buffer).GetBuffer();
576  cmd_buffer.bindIndexBuffer(index_buffer_handle,
577  index_buffer_view.range.offset,
578  ToVKIndexType(command.index_type));
579 
580  // Engage!
581  cmd_buffer.drawIndexed(command.vertex_count, // index count
582  command.instance_count, // instance count
583  0u, // first index
584  command.base_vertex, // vertex offset
585  0u // first instance
586  );
587  } else {
588  cmd_buffer.draw(command.vertex_count, // vertex count
589  command.instance_count, // instance count
590  command.base_vertex, // vertex offset
591  0u // first instance
592  );
593  }
594  return true;
595 }

References AllocateAndBindDescriptorSets(), impeller::Command::base_vertex, impeller::PassBindingsCache::BindPipeline(), impeller::BufferView::buffer, impeller::CommandEncoderVK::GetCommandBuffer(), impeller::Context::GetResourceAllocator(), impeller::Command::GetVertexBuffer(), impeller::Command::index_buffer, impeller::Command::index_type, impeller::Command::instance_count, impeller::Command::pipeline, impeller::CommandEncoderVK::PopDebugGroup(), impeller::CommandEncoderVK::PushDebugGroup(), impeller::PassBindingsCache::SetStencilReference(), SetViewportAndScissor(), impeller::Command::stencil_reference, ToVKIndexType(), impeller::CommandEncoderVK::Track(), VALIDATION_LOG, and impeller::Command::vertex_count.

◆ EncodeCommandsInReactor() [1/2]

bool impeller::EncodeCommandsInReactor ( const RenderPassData &  pass_data,
const std::shared_ptr< Allocator > &  transients_allocator,
const ReactorGLES &  reactor,
const std::vector< Command > &  commands 
)

Configure blending.

Setup stencil.

Configure depth.

Setup the viewport.

Setup the scissor rect.

Setup culling.

Setup winding order.

Bind vertex and index buffers.

Bind the pipeline program.

Bind vertex attribs.

Bind uniform data.

Determine the primitive type.

Finally! Invoke the draw call.

Unbind vertex attribs.

Unbind the program pipeline.

Definition at line 139 of file render_pass_gles.cc.

143  {
144  TRACE_EVENT0("impeller", "RenderPassGLES::EncodeCommandsInReactor");
145 
146  if (commands.empty()) {
147  return true;
148  }
149 
150  const auto& gl = reactor.GetProcTable();
151 
152  fml::ScopedCleanupClosure pop_pass_debug_marker(
153  [&gl]() { gl.PopDebugGroup(); });
154  if (!pass_data.label.empty()) {
155  gl.PushDebugGroup(pass_data.label);
156  } else {
157  pop_pass_debug_marker.Release();
158  }
159 
160  GLuint fbo = GL_NONE;
161  fml::ScopedCleanupClosure delete_fbo([&gl, &fbo]() {
162  if (fbo != GL_NONE) {
163  gl.BindFramebuffer(GL_FRAMEBUFFER, GL_NONE);
164  gl.DeleteFramebuffers(1u, &fbo);
165  }
166  });
167 
168  const auto is_default_fbo =
169  TextureGLES::Cast(*pass_data.color_attachment).IsWrapped();
170 
171  if (!is_default_fbo) {
172  // Create and bind an offscreen FBO.
173  gl.GenFramebuffers(1u, &fbo);
174  gl.BindFramebuffer(GL_FRAMEBUFFER, fbo);
175 
176  if (auto color = TextureGLES::Cast(pass_data.color_attachment.get())) {
177  if (!color->SetAsFramebufferAttachment(
178  GL_FRAMEBUFFER, fbo, TextureGLES::AttachmentPoint::kColor0)) {
179  return false;
180  }
181  }
182  if (auto depth = TextureGLES::Cast(pass_data.depth_attachment.get())) {
183  if (!depth->SetAsFramebufferAttachment(
184  GL_FRAMEBUFFER, fbo, TextureGLES::AttachmentPoint::kDepth)) {
185  return false;
186  }
187  }
188  if (auto stencil = TextureGLES::Cast(pass_data.stencil_attachment.get())) {
189  if (!stencil->SetAsFramebufferAttachment(
190  GL_FRAMEBUFFER, fbo, TextureGLES::AttachmentPoint::kStencil)) {
191  return false;
192  }
193  }
194 
195  if (gl.CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
196  VALIDATION_LOG << "Could not create a complete frambuffer.";
197  return false;
198  }
199  }
200 
201  gl.ClearColor(pass_data.clear_color.red, // red
202  pass_data.clear_color.green, // green
203  pass_data.clear_color.blue, // blue
204  pass_data.clear_color.alpha // alpha
205  );
206  if (pass_data.depth_attachment) {
207  gl.ClearDepthf(pass_data.clear_depth);
208  }
209  if (pass_data.stencil_attachment) {
210  gl.ClearStencil(pass_data.clear_stencil);
211  }
212 
213  GLenum clear_bits = 0u;
214  if (pass_data.clear_color_attachment) {
215  clear_bits |= GL_COLOR_BUFFER_BIT;
216  }
217  if (pass_data.clear_depth_attachment) {
218  clear_bits |= GL_DEPTH_BUFFER_BIT;
219  }
220  if (pass_data.clear_stencil_attachment) {
221  clear_bits |= GL_STENCIL_BUFFER_BIT;
222  }
223 
224  gl.Disable(GL_SCISSOR_TEST);
225  gl.Disable(GL_DEPTH_TEST);
226  gl.Disable(GL_STENCIL_TEST);
227  gl.Disable(GL_CULL_FACE);
228  gl.Disable(GL_BLEND);
229  gl.ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
230 
231  gl.Clear(clear_bits);
232 
233  for (const auto& command : commands) {
234  if (command.instance_count != 1u) {
235  VALIDATION_LOG << "GLES backend does not support instanced rendering.";
236  return false;
237  }
238 
239  if (!command.pipeline) {
240  VALIDATION_LOG << "Command has no pipeline specified.";
241  return false;
242  }
243 
244 #ifdef IMPELLER_DEBUG
245  fml::ScopedCleanupClosure pop_cmd_debug_marker(
246  [&gl]() { gl.PopDebugGroup(); });
247  if (!command.label.empty()) {
248  gl.PushDebugGroup(command.label);
249  } else {
250  pop_cmd_debug_marker.Release();
251  }
252 #endif // IMPELLER_DEBUG
253 
254  const auto& pipeline = PipelineGLES::Cast(*command.pipeline);
255 
256  const auto* color_attachment =
257  pipeline.GetDescriptor().GetLegacyCompatibleColorAttachment();
258  if (!color_attachment) {
259  VALIDATION_LOG
260  << "Color attachment is too complicated for a legacy renderer.";
261  return false;
262  }
263 
264  //--------------------------------------------------------------------------
265  /// Configure blending.
266  ///
267  ConfigureBlending(gl, color_attachment);
268 
269  //--------------------------------------------------------------------------
270  /// Setup stencil.
271  ///
272  ConfigureStencil(gl, pipeline.GetDescriptor(), command.stencil_reference);
273 
274  //--------------------------------------------------------------------------
275  /// Configure depth.
276  ///
277  if (auto depth =
278  pipeline.GetDescriptor().GetDepthStencilAttachmentDescriptor();
279  depth.has_value()) {
280  gl.Enable(GL_DEPTH_TEST);
281  gl.DepthFunc(ToCompareFunction(depth->depth_compare));
282  gl.DepthMask(depth->depth_write_enabled ? GL_TRUE : GL_FALSE);
283  } else {
284  gl.Disable(GL_DEPTH_TEST);
285  }
286 
287  // Both the viewport and scissor are specified in framebuffer coordinates.
288  // Impeller's framebuffer coordinate system is top left origin, but OpenGL's
289  // is bottom left origin, so we convert the coordinates here.
290  auto target_size = pass_data.color_attachment->GetSize();
291 
292  //--------------------------------------------------------------------------
293  /// Setup the viewport.
294  ///
295  const auto& viewport = command.viewport.value_or(pass_data.viewport);
296  gl.Viewport(viewport.rect.origin.x, // x
297  target_size.height - viewport.rect.origin.y -
298  viewport.rect.size.height, // y
299  viewport.rect.size.width, // width
300  viewport.rect.size.height // height
301  );
302  if (pass_data.depth_attachment) {
303  gl.DepthRangef(viewport.depth_range.z_near, viewport.depth_range.z_far);
304  }
305 
306  //--------------------------------------------------------------------------
307  /// Setup the scissor rect.
308  ///
309  if (command.scissor.has_value()) {
310  const auto& scissor = command.scissor.value();
311  gl.Enable(GL_SCISSOR_TEST);
312  gl.Scissor(
313  scissor.origin.x, // x
314  target_size.height - scissor.origin.y - scissor.size.height, // y
315  scissor.size.width, // width
316  scissor.size.height // height
317  );
318  } else {
319  gl.Disable(GL_SCISSOR_TEST);
320  }
321 
322  //--------------------------------------------------------------------------
323  /// Setup culling.
324  ///
325  switch (pipeline.GetDescriptor().GetCullMode()) {
326  case CullMode::kNone:
327  gl.Disable(GL_CULL_FACE);
328  break;
329  case CullMode::kFrontFace:
330  gl.Enable(GL_CULL_FACE);
331  gl.CullFace(GL_FRONT);
332  break;
333  case CullMode::kBackFace:
334  gl.Enable(GL_CULL_FACE);
335  gl.CullFace(GL_BACK);
336  break;
337  }
338  //--------------------------------------------------------------------------
339  /// Setup winding order.
340  ///
341  switch (pipeline.GetDescriptor().GetWindingOrder()) {
342  case WindingOrder::kClockwise:
343  gl.FrontFace(GL_CW);
344  break;
345  case WindingOrder::kCounterClockwise:
346  gl.FrontFace(GL_CCW);
347  break;
348  }
349 
350  if (command.index_type == IndexType::kUnknown) {
351  return false;
352  }
353 
354  const auto& vertex_desc_gles = pipeline.GetBufferBindings();
355 
356  //--------------------------------------------------------------------------
357  /// Bind vertex and index buffers.
358  ///
359  auto vertex_buffer_view = command.GetVertexBuffer();
360 
361  if (!vertex_buffer_view) {
362  return false;
363  }
364 
365  auto vertex_buffer =
366  vertex_buffer_view.buffer->GetDeviceBuffer(*transients_allocator);
367 
368  if (!vertex_buffer) {
369  return false;
370  }
371 
372  const auto& vertex_buffer_gles = DeviceBufferGLES::Cast(*vertex_buffer);
373  if (!vertex_buffer_gles.BindAndUploadDataIfNecessary(
374  DeviceBufferGLES::BindingType::kArrayBuffer)) {
375  return false;
376  }
377 
378  //--------------------------------------------------------------------------
379  /// Bind the pipeline program.
380  ///
381  if (!pipeline.BindProgram()) {
382  return false;
383  }
384 
385  //--------------------------------------------------------------------------
386  /// Bind vertex attribs.
387  ///
388  if (!vertex_desc_gles->BindVertexAttributes(
389  gl, vertex_buffer_view.range.offset)) {
390  return false;
391  }
392 
393  //--------------------------------------------------------------------------
394  /// Bind uniform data.
395  ///
396  if (!vertex_desc_gles->BindUniformData(gl, //
397  *transients_allocator, //
398  command.vertex_bindings, //
399  command.fragment_bindings //
400  )) {
401  return false;
402  }
403 
404  //--------------------------------------------------------------------------
405  /// Determine the primitive type.
406  ///
407  // GLES doesn't support setting the fill mode, so override the primitive
408  // with GL_LINE_STRIP to somewhat emulate PolygonMode::kLine. This isn't
409  // correct; full triangle outlines won't be drawn and disconnected
410  // geometry may appear connected. However this can still be useful for
411  // wireframe debug views.
412  auto mode = pipeline.GetDescriptor().GetPolygonMode() == PolygonMode::kLine
413  ? GL_LINE_STRIP
414  : ToMode(pipeline.GetDescriptor().GetPrimitiveType());
415 
416  //--------------------------------------------------------------------------
417  /// Finally! Invoke the draw call.
418  ///
419  if (command.index_type == IndexType::kNone) {
420  gl.DrawArrays(mode, command.base_vertex, command.vertex_count);
421  } else {
422  // Bind the index buffer if necessary.
423  auto index_buffer_view = command.index_buffer;
424  auto index_buffer =
425  index_buffer_view.buffer->GetDeviceBuffer(*transients_allocator);
426  const auto& index_buffer_gles = DeviceBufferGLES::Cast(*index_buffer);
427  if (!index_buffer_gles.BindAndUploadDataIfNecessary(
428  DeviceBufferGLES::BindingType::kElementArrayBuffer)) {
429  return false;
430  }
431  gl.DrawElements(mode, // mode
432  command.vertex_count, // count
433  ToIndexType(command.index_type), // type
434  reinterpret_cast<const GLvoid*>(static_cast<GLsizei>(
435  index_buffer_view.range.offset)) // indices
436  );
437  }
438 
439  //--------------------------------------------------------------------------
440  /// Unbind vertex attribs.
441  ///
442  if (!vertex_desc_gles->UnbindVertexAttributes(gl)) {
443  return false;
444  }
445 
446  //--------------------------------------------------------------------------
447  /// Unbind the program pipeline.
448  ///
449  if (!pipeline.UnbindProgram()) {
450  return false;
451  }
452  }
453 
454  if (gl.DiscardFramebufferEXT.IsAvailable()) {
455  std::vector<GLenum> attachments;
456 
457  if (pass_data.discard_color_attachment) {
458  attachments.push_back(is_default_fbo ? GL_COLOR_EXT
459  : GL_COLOR_ATTACHMENT0);
460  }
461  if (pass_data.discard_depth_attachment) {
462  attachments.push_back(is_default_fbo ? GL_DEPTH_EXT
463  : GL_DEPTH_ATTACHMENT);
464  }
465 
466 // TODO(jonahwilliams): discarding the stencil on the default fbo when running
467 // on Windows causes Angle to discard the entire render target. Until we know
468 // the reason, default to storing.
469 #ifdef FML_OS_WIN
470  if (pass_data.discard_stencil_attachment && !is_default_fbo) {
471 #else
472  if (pass_data.discard_stencil_attachment) {
473 #endif
474  attachments.push_back(is_default_fbo ? GL_STENCIL_EXT
475  : GL_STENCIL_ATTACHMENT);
476  }
477  gl.DiscardFramebufferEXT(GL_FRAMEBUFFER, // target
478  attachments.size(), // attachments to discard
479  attachments.data() // size
480  );
481  }
482 
483  return true;
484 }

References impeller::Color::alpha, impeller::Color::blue, CanClearAttachment(), CanDiscardAttachmentWhenDone(), impeller::BackendCast< DeviceBufferGLES, DeviceBuffer >::Cast(), impeller::BackendCast< PipelineGLES, Pipeline< PipelineDescriptor > >::Cast(), impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::RenderPassData::clear_color, impeller::RenderPassData::clear_color_attachment, impeller::RenderPassData::clear_depth, impeller::RenderPassData::clear_depth_attachment, impeller::RenderPassData::clear_stencil, impeller::RenderPassData::clear_stencil_attachment, impeller::RenderPassData::color_attachment, impeller::RenderPass::commands_, ConfigureBlending(), ConfigureStencil(), impeller::RenderPassData::depth_attachment, impeller::RenderPassData::discard_color_attachment, impeller::RenderPassData::discard_depth_attachment, impeller::RenderPassData::discard_stencil_attachment, impeller::ReactorGLES::GetProcTable(), impeller::RenderPass::GetRenderTarget(), impeller::RenderPass::GetRenderTargetSize(), impeller::Context::GetResourceAllocator(), impeller::Color::green, impeller::DeviceBufferGLES::kArrayBuffer, kBackFace, kClockwise, impeller::TextureGLES::kColor0, kCounterClockwise, impeller::TextureGLES::kDepth, impeller::DeviceBufferGLES::kElementArrayBuffer, kFrontFace, kLine, kNone, impeller::TextureGLES::kStencil, kUnknown, impeller::RenderPassData::label, impeller::TRect< Scalar >::MakeSize(), impeller::ProcTableGLES::PushDebugGroup(), impeller::Viewport::rect, impeller::Color::red, impeller::RenderPassData::stencil_attachment, ToCompareFunction(), ToIndexType(), ToMode(), VALIDATION_LOG, and impeller::RenderPassData::viewport.

◆ EncodeCommandsInReactor() [2/2]

bool impeller::EncodeCommandsInReactor ( const std::shared_ptr< Allocator > &  transients_allocator,
const ReactorGLES &  reactor,
const std::vector< std::unique_ptr< BlitEncodeGLES >> &  commands,
const std::string &  label 
)

Definition at line 40 of file blit_pass_gles.cc.

44  {
45  TRACE_EVENT0("impeller", "BlitPassGLES::EncodeCommandsInReactor");
46 
47  if (commands.empty()) {
48  return true;
49  }
50 
51  const auto& gl = reactor.GetProcTable();
52 
53  fml::ScopedCleanupClosure pop_pass_debug_marker(
54  [&gl]() { gl.PopDebugGroup(); });
55  if (!label.empty()) {
56  gl.PushDebugGroup(label);
57  } else {
58  pop_pass_debug_marker.Release();
59  }
60 
61  for (const auto& command : commands) {
62  fml::ScopedCleanupClosure pop_cmd_debug_marker(
63  [&gl]() { gl.PopDebugGroup(); });
64  auto label = command->GetLabel();
65  if (!label.empty()) {
66  gl.PushDebugGroup(label);
67  } else {
68  pop_cmd_debug_marker.Release();
69  }
70 
71  if (!command->Encode(reactor)) {
72  return false;
73  }
74  }
75 
76  return true;
77 }

References impeller::ReactorGLES::GetProcTable(), and impeller::ProcTableGLES::PushDebugGroup().

◆ FormatWindowTitle() [1/2]

static std::string impeller::FormatWindowTitle ( const std::string &  test_name)
static

Definition at line 57 of file compute_playground_test.cc.

57  {
58  std::stringstream stream;
59  stream << "Impeller Playground for '" << test_name << "' (Press ESC to quit)";
60  return stream.str();
61 }

Referenced by impeller::ComputePlaygroundTest::GetWindowTitle(), and impeller::PlaygroundTest::GetWindowTitle().

◆ FormatWindowTitle() [2/2]

static std::string impeller::FormatWindowTitle ( const std::string &  test_name)
static

Definition at line 62 of file playground_test.cc.

62  {
63  std::stringstream stream;
64  stream << "Impeller Playground for '" << test_name << "' (Press ESC to quit)";
65  return stream.str();
66 }

◆ FramebufferStatusToString()

static const char* impeller::FramebufferStatusToString ( GLenum  status)
static

Definition at line 141 of file proc_table_gles.cc.

141  {
142  switch (status) {
143  case GL_FRAMEBUFFER_COMPLETE:
144  return "GL_FRAMEBUFFER_COMPLETE";
145  case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
146  return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
147 #if GL_ES_VERSION_2_0
148  case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
149  return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
150 #endif
151  case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
152  return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
153  case GL_FRAMEBUFFER_UNSUPPORTED:
154  return "GL_FRAMEBUFFER_UNSUPPORTED";
155  case GL_INVALID_ENUM:
156  return "GL_INVALID_ENUM";
157  }
158 
159  return "Unknown FBO Error Status";
160 }

Referenced by impeller::ProcTableGLES::DescribeCurrentFramebuffer().

◆ fromFanIndices()

static std::vector<uint16_t> impeller::fromFanIndices ( const std::vector< Point > &  vertices,
const std::vector< uint16_t > &  indices 
)
static

Definition at line 20 of file vertices_geometry.cc.

22  {
23  std::vector<uint16_t> unrolled_indices;
24 
25  // Un-fan index buffer if provided.
26  if (indices.size() > 0u) {
27  if (indices.size() < 3u) {
28  return {};
29  }
30 
31  auto center_point = indices[0];
32  for (auto i = 1u; i < indices.size() - 1; i++) {
33  unrolled_indices.push_back(center_point);
34  unrolled_indices.push_back(indices[i]);
35  unrolled_indices.push_back(indices[i + 1]);
36  }
37  } else {
38  if (vertices.size() < 3u) {
39  return {};
40  }
41 
42  // If indices were not provided, create an index buffer that unfans
43  // triangles instead of re-writing points, colors, et cetera.
44  for (auto i = 1u; i < vertices.size() - 1; i++) {
45  unrolled_indices.push_back(0);
46  unrolled_indices.push_back(i);
47  unrolled_indices.push_back(i + 1);
48  }
49  }
50  return unrolled_indices;
51 }

◆ FromMTLLoadAction()

constexpr LoadAction impeller::FromMTLLoadAction ( MTLLoadAction  action)
constexpr

Definition at line 290 of file formats_mtl.h.

290  {
291  switch (action) {
292  case MTLLoadActionDontCare:
293  return LoadAction::kDontCare;
294  case MTLLoadActionLoad:
295  return LoadAction::kLoad;
296  case MTLLoadActionClear:
297  return LoadAction::kClear;
298  default:
299  break;
300  }
301 
302  return LoadAction::kDontCare;
303 }

References kClear, kDontCare, and kLoad.

◆ FromMTLPixelFormat()

constexpr PixelFormat impeller::FromMTLPixelFormat ( MTLPixelFormat  format)
constexpr

Definition at line 21 of file formats_mtl.h.

21  {
22  switch (format) {
23  case MTLPixelFormatInvalid:
24  return PixelFormat::kUnknown;
25  case MTLPixelFormatBGRA8Unorm:
26  return PixelFormat::kB8G8R8A8UNormInt;
27  case MTLPixelFormatBGRA8Unorm_sRGB:
28  return PixelFormat::kB8G8R8A8UNormIntSRGB;
29  case MTLPixelFormatRGBA8Unorm:
30  return PixelFormat::kR8G8B8A8UNormInt;
31  case MTLPixelFormatRGBA8Unorm_sRGB:
32  return PixelFormat::kR8G8B8A8UNormIntSRGB;
33  case MTLPixelFormatRGBA32Float:
34  return PixelFormat::kR32G32B32A32Float;
35  case MTLPixelFormatRGBA16Float:
36  return PixelFormat::kR16G16B16A16Float;
37  case MTLPixelFormatStencil8:
38  return PixelFormat::kS8UInt;
39 #if !FML_OS_IOS
40  case MTLPixelFormatDepth24Unorm_Stencil8:
41  return PixelFormat::kD24UnormS8Uint;
42 #endif // FML_OS_IOS
43  case MTLPixelFormatDepth32Float_Stencil8:
44  return PixelFormat::kD32FloatS8UInt;
45  case MTLPixelFormatBGR10_XR_sRGB:
46  return PixelFormat::kB10G10R10XRSRGB;
47  case MTLPixelFormatBGR10_XR:
48  return PixelFormat::kB10G10R10XR;
49  case MTLPixelFormatBGRA10_XR:
50  return PixelFormat::kB10G10R10A10XR;
51  default:
52  return PixelFormat::kUnknown;
53  }
54  return PixelFormat::kUnknown;
55 }

References kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kS8UInt, and kUnknown.

Referenced by WrapTextureMTL(), and WrapTextureWithRenderTarget().

◆ FromMTLStoreAction()

constexpr StoreAction impeller::FromMTLStoreAction ( MTLStoreAction  action)
constexpr

Definition at line 319 of file formats_mtl.h.

319  {
320  switch (action) {
321  case MTLStoreActionDontCare:
322  return StoreAction::kDontCare;
323  case MTLStoreActionStore:
324  return StoreAction::kStore;
325  case MTLStoreActionMultisampleResolve:
326  return StoreAction::kMultisampleResolve;
327  case MTLStoreActionStoreAndMultisampleResolve:
328  return StoreAction::kStoreAndMultisampleResolve;
329  default:
330  break;
331  }
332  return StoreAction::kDontCare;
333 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

◆ FromRGB()

static constexpr Color impeller::FromRGB ( Vector3  color,
Scalar  alpha 
)
inlinestaticconstexpr

Definition at line 192 of file color.cc.

192  {
193  return {color.x, color.y, color.z, alpha};
194 }

References impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by DoColorBlend().

◆ GetBytesPerPixel()

static size_t impeller::GetBytesPerPixel ( DecompressedImage::Format  format)
static

Definition at line 46 of file decompressed_image.cc.

46  {
47  switch (format) {
48  case DecompressedImage::Format::kInvalid:
49  return 0u;
50  case DecompressedImage::Format::kGrey:
51  return 1u;
52  case DecompressedImage::Format::kGreyAlpha:
53  return 1u;
54  case DecompressedImage::Format::kRGB:
55  return 3u;
56  case DecompressedImage::Format::kRGBA:
57  return 4;
58  }
59  return 0u;
60 }

References impeller::DecompressedImage::kGrey, impeller::DecompressedImage::kGreyAlpha, impeller::DecompressedImage::kInvalid, impeller::DecompressedImage::kRGB, and impeller::DecompressedImage::kRGBA.

Referenced by impeller::DecompressedImage::ConvertToRGBA().

◆ GetDefaultStencilConfig()

static RenderTarget::AttachmentConfig impeller::GetDefaultStencilConfig ( bool  readable)
static

Definition at line 261 of file entity_pass.cc.

261  {
262  return RenderTarget::AttachmentConfig{
263  .storage_mode = readable ? StorageMode::kDevicePrivate
264  : StorageMode::kDeviceTransient,
265  .load_action = LoadAction::kDontCare,
266  .store_action = StoreAction::kDontCare,
267  };
268 }

References kDevicePrivate, kDeviceTransient, kDontCare, and impeller::RenderTarget::AttachmentConfig::storage_mode.

Referenced by CreateRenderTarget().

◆ GetDeviceExtensionName()

static const char* impeller::GetDeviceExtensionName ( OptionalDeviceExtensionVK  ext)
static

Definition at line 155 of file capabilities_vk.cc.

155  {
156  switch (ext) {
157  case OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback:
158  return VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME;
159  case OptionalDeviceExtensionVK::kLast:
160  return "Unknown";
161  }
162  return "Unknown";
163 }

References kEXTPipelineCreationFeedback, and kLast.

Referenced by impeller::CapabilitiesVK::GetEnabledDeviceExtensions(), and impeller::CapabilitiesVK::SetPhysicalDevice().

◆ GetFencesForWaitSet()

static std::vector<vk::Fence> impeller::GetFencesForWaitSet ( const WaitSet &  set)
static

Definition at line 77 of file fence_waiter_vk.cc.

77  {
78  std::vector<vk::Fence> fences;
79  for (const auto& entry : set) {
80  if (!entry->IsSignalled()) {
81  fences.emplace_back(entry->GetFence());
82  }
83  }
84  return fences;
85 }

◆ GetGLString()

static std::string impeller::GetGLString ( const ProcTableGLES &  gl,
GLenum  name 
)
static

Definition at line 21 of file description_gles.cc.

21  {
22  auto str = gl.GetString(name);
23  if (str == nullptr) {
24  return "";
25  }
26  return reinterpret_cast<const char*>(str);
27 }

Referenced by impeller::DescriptionGLES::DescriptionGLES().

◆ GetGLStringi()

static std::string impeller::GetGLStringi ( const ProcTableGLES &  gl,
GLenum  name,
int  index 
)
static

Definition at line 29 of file description_gles.cc.

31  {
32  auto str = gl.GetStringi(name, index);
33  if (str == nullptr) {
34  return "";
35  }
36  return reinterpret_cast<const char*>(str);
37 }

Referenced by impeller::DescriptionGLES::DescriptionGLES().

◆ GetMTLComputePipelineDescriptor()

static MTLComputePipelineDescriptor* impeller::GetMTLComputePipelineDescriptor ( const ComputePipelineDescriptor &  desc)
static

Definition at line 65 of file pipeline_library_mtl.mm.

66  {
67  auto descriptor = [[MTLComputePipelineDescriptor alloc] init];
68  descriptor.label = @(desc.GetLabel().c_str());
69  descriptor.computeFunction =
70  ShaderFunctionMTL::Cast(*desc.GetStageEntrypoint()).GetMTLFunction();
71  return descriptor;
72 }

References impeller::BackendCast< ShaderFunctionMTL, ShaderFunction >::Cast(), impeller::ComputePipelineDescriptor::GetLabel(), impeller::ShaderFunctionMTL::GetMTLFunction(), and impeller::ComputePipelineDescriptor::GetStageEntrypoint().

◆ GetMTLRenderPipelineDescriptor()

static MTLRenderPipelineDescriptor* impeller::GetMTLRenderPipelineDescriptor ( const PipelineDescriptor &  desc)
static

Definition at line 25 of file pipeline_library_mtl.mm.

26  {
27  auto descriptor = [[MTLRenderPipelineDescriptor alloc] init];
28  descriptor.label = @(desc.GetLabel().c_str());
29  descriptor.rasterSampleCount = static_cast<NSUInteger>(desc.GetSampleCount());
30 
31  for (const auto& entry : desc.GetStageEntrypoints()) {
32  if (entry.first == ShaderStage::kVertex) {
33  descriptor.vertexFunction =
34  ShaderFunctionMTL::Cast(*entry.second).GetMTLFunction();
35  }
36  if (entry.first == ShaderStage::kFragment) {
37  descriptor.fragmentFunction =
38  ShaderFunctionMTL::Cast(*entry.second).GetMTLFunction();
39  }
40  }
41 
42  if (const auto& vertex_descriptor = desc.GetVertexDescriptor()) {
43  VertexDescriptorMTL vertex_descriptor_mtl;
44  if (vertex_descriptor_mtl.SetStageInputsAndLayout(
45  vertex_descriptor->GetStageInputs(),
46  vertex_descriptor->GetStageLayouts())) {
47  descriptor.vertexDescriptor =
48  vertex_descriptor_mtl.GetMTLVertexDescriptor();
49  }
50  }
51 
52  for (const auto& item : desc.GetColorAttachmentDescriptors()) {
53  descriptor.colorAttachments[item.first] =
54  ToMTLRenderPipelineColorAttachmentDescriptor(item.second);
55  }
56 
57  descriptor.depthAttachmentPixelFormat =
58  ToMTLPixelFormat(desc.GetDepthPixelFormat());
59  descriptor.stencilAttachmentPixelFormat =
60  ToMTLPixelFormat(desc.GetStencilPixelFormat());
61 
62  return descriptor;
63 }

References impeller::BackendCast< ShaderFunctionMTL, ShaderFunction >::Cast(), impeller::PipelineDescriptor::GetColorAttachmentDescriptors(), impeller::PipelineDescriptor::GetDepthPixelFormat(), impeller::PipelineDescriptor::GetLabel(), impeller::ShaderFunctionMTL::GetMTLFunction(), impeller::VertexDescriptorMTL::GetMTLVertexDescriptor(), impeller::PipelineDescriptor::GetSampleCount(), impeller::PipelineDescriptor::GetStageEntrypoints(), impeller::PipelineDescriptor::GetStencilPixelFormat(), impeller::PipelineDescriptor::GetVertexDescriptor(), kFragment, kVertex, impeller::VertexDescriptorMTL::SetStageInputsAndLayout(), ToMTLPixelFormat(), and ToMTLRenderPipelineColorAttachmentDescriptor().

◆ GetQueueCreateInfos()

static std::vector<vk::DeviceQueueCreateInfo> impeller::GetQueueCreateInfos ( std::initializer_list< QueueIndexVK >  queues)
static

Definition at line 55 of file context_vk.cc.

56  {
57  std::map<size_t /* family */, size_t /* index */> family_index_map;
58  for (const auto& queue : queues) {
59  family_index_map[queue.family] = 0;
60  }
61  for (const auto& queue : queues) {
62  auto value = family_index_map[queue.family];
63  family_index_map[queue.family] = std::max(value, queue.index);
64  }
65 
66  static float kQueuePriority = 1.0f;
67  std::vector<vk::DeviceQueueCreateInfo> infos;
68  for (const auto& item : family_index_map) {
69  vk::DeviceQueueCreateInfo info;
70  info.setQueueFamilyIndex(item.first);
71  info.setQueueCount(item.second + 1);
72  info.setQueuePriorities(kQueuePriority);
73  infos.push_back(info);
74  }
75  return infos;
76 }

◆ GetShaderInfoLog()

static std::string impeller::GetShaderInfoLog ( const ProcTableGLES &  gl,
GLuint  shader 
)
static

Definition at line 21 of file pipeline_library_gles.cc.

21  {
22  GLint log_length = 0;
23  gl.GetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
24  if (log_length == 0) {
25  return "";
26  }
27  auto log_buffer =
28  reinterpret_cast<char*>(std::calloc(log_length, sizeof(char)));
29  gl.GetShaderInfoLog(shader, log_length, &log_length, log_buffer);
30  auto log_string = std::string(log_buffer, log_length);
31  std::free(log_buffer);
32  return log_string;
33 }

Referenced by LogShaderCompilationFailure().

◆ GetSupportedDeviceExtensions()

static std::optional<std::set<std::string> > impeller::GetSupportedDeviceExtensions ( const vk::PhysicalDevice &  physical_device)
static

Definition at line 176 of file capabilities_vk.cc.

177  {
178  auto device_extensions = physical_device.enumerateDeviceExtensionProperties();
179  if (device_extensions.result != vk::Result::eSuccess) {
180  return std::nullopt;
181  }
182 
183  std::set<std::string> exts;
184  for (const auto& device_extension : device_extensions.value) {
185  exts.insert(device_extension.extensionName);
186  };
187 
188  return exts;
189 }

Referenced by impeller::CapabilitiesVK::GetEnabledDeviceExtensions(), and impeller::CapabilitiesVK::SetPhysicalDevice().

◆ GetTextureTypeFromDescriptor()

static TextureGLES::Type impeller::GetTextureTypeFromDescriptor ( const TextureDescriptor &  desc)
static

Definition at line 19 of file texture_gles.cc.

20  {
21  const auto usage = static_cast<TextureUsageMask>(desc.usage);
22  const auto render_target =
23  static_cast<TextureUsageMask>(TextureUsage::kRenderTarget);
24  if (usage == render_target) {
25  return TextureGLES::Type::kRenderBuffer;
26  }
27  return TextureGLES::Type::kTexture;
28 }

References impeller::TextureGLES::kRenderBuffer, kRenderTarget, impeller::TextureGLES::kTexture, and impeller::TextureDescriptor::usage.

◆ GetVKClearValues()

static std::vector<vk::ClearValue> impeller::GetVKClearValues ( const RenderTarget &  target)
static

Definition at line 213 of file render_pass_vk.cc.

214  {
215  std::vector<vk::ClearValue> clears;
216 
217  for (const auto& [_, color] : target.GetColorAttachments()) {
218  clears.emplace_back(VKClearValueFromColor(color.clear_color));
219  if (color.resolve_texture) {
220  clears.emplace_back(VKClearValueFromColor(color.clear_color));
221  }
222  }
223 
224  const auto& depth = target.GetDepthAttachment();
225  const auto& stencil = target.GetStencilAttachment();
226 
227  if (depth.has_value()) {
228  clears.emplace_back(VKClearValueFromDepthStencil(
229  stencil ? stencil->clear_stencil : 0u, depth->clear_depth));
230  }
231 
232  if (stencil.has_value()) {
233  clears.emplace_back(VKClearValueFromDepthStencil(
234  stencil->clear_stencil, depth ? depth->clear_depth : 0.0f));
235  }
236 
237  return clears;
238 }

References impeller::RenderTarget::GetColorAttachments(), impeller::RenderTarget::GetDepthAttachment(), impeller::RenderTarget::GetStencilAttachment(), VKClearValueFromColor(), and VKClearValueFromDepthStencil().

◆ GLErrorToString()

const char * impeller::GLErrorToString ( GLenum  value)

Definition at line 15 of file proc_table_gles.cc.

15  {
16  switch (value) {
17  case GL_NO_ERROR:
18  return "GL_NO_ERROR";
19  case GL_INVALID_ENUM:
20  return "GL_INVALID_ENUM";
21  case GL_INVALID_VALUE:
22  return "GL_INVALID_VALUE";
23  case GL_INVALID_OPERATION:
24  return "GL_INVALID_OPERATION";
25  case GL_INVALID_FRAMEBUFFER_OPERATION:
26  return "GL_INVALID_FRAMEBUFFER_OPERATION";
27  case GL_FRAMEBUFFER_COMPLETE:
28  return "GL_FRAMEBUFFER_COMPLETE";
29  case GL_OUT_OF_MEMORY:
30  return "GL_OUT_OF_MEMORY";
31  }
32  return "Unknown.";
33 }

Referenced by impeller::AutoErrorCheck::~AutoErrorCheck().

◆ GLESShaderNameToShaderKeyName()

static std::string impeller::GLESShaderNameToShaderKeyName ( const std::string &  name,
ShaderStage  stage 
)
static

Definition at line 29 of file shader_library_gles.cc.

30  {
31  std::stringstream stream;
32  stream << name;
33  switch (stage) {
34  case ShaderStage::kUnknown:
35  stream << "_unknown_";
36  break;
37  case ShaderStage::kVertex:
38  stream << "_vertex_";
39  break;
40  case ShaderStage::kFragment:
41  stream << "_fragment_";
42  break;
43  case ShaderStage::kTessellationControl:
44  stream << "_tessellation_control_";
45  break;
46  case ShaderStage::kTessellationEvaluation:
47  stream << "_tessellation_evaluation_";
48  break;
49  case ShaderStage::kCompute:
50  stream << "_compute_";
51  break;
52  }
53  stream << "main";
54  return stream.str();
55 }

References kCompute, kFragment, kTessellationControl, kTessellationEvaluation, kUnknown, and kVertex.

◆ HandleTypeToString()

std::string impeller::HandleTypeToString ( HandleType  type)

Definition at line 11 of file handle_gles.cc.

11  {
12  switch (type) {
13  case HandleType::kUnknown:
14  return "Unknown";
15  case HandleType::kTexture:
16  return "Texture";
17  case HandleType::kBuffer:
18  return "Buffer";
19  case HandleType::kProgram:
20  return "Program";
21  case HandleType::kRenderBuffer:
22  return "RenderBuffer";
23  case HandleType::kFrameBuffer:
24  return "Framebuffer";
25  }
26  FML_UNREACHABLE();
27 }

References kBuffer, kFrameBuffer, kProgram, kRenderBuffer, kTexture, and kUnknown.

Referenced by std::operator<<().

◆ HasPrefix()

bool impeller::HasPrefix ( const std::string &  string,
const std::string &  prefix 
)

Definition at line 30 of file strings.cc.

30  {
31  return string.find(prefix) == 0u;
32 }

Referenced by DetermineIfES(), and StripPrefix().

◆ HasRequiredProperties()

static bool impeller::HasRequiredProperties ( const vk::PhysicalDevice &  physical_device)
static

Definition at line 262 of file capabilities_vk.cc.

262  {
263  auto properties = physical_device.getProperties();
264  if (!(properties.limits.framebufferColorSampleCounts &
265  (vk::SampleCountFlagBits::e1 | vk::SampleCountFlagBits::e4))) {
266  return false;
267  }
268  return true;
269 }

Referenced by impeller::CapabilitiesVK::GetEnabledDeviceFeatures().

◆ HasRequiredQueues()

static bool impeller::HasRequiredQueues ( const vk::PhysicalDevice &  physical_device)
static

Definition at line 271 of file capabilities_vk.cc.

271  {
272  auto queue_flags = vk::QueueFlags{};
273  for (const auto& queue : physical_device.getQueueFamilyProperties()) {
274  if (queue.queueCount == 0) {
275  continue;
276  }
277  queue_flags |= queue.queueFlags;
278  }
279  return static_cast<VkQueueFlags>(queue_flags &
280  (vk::QueueFlagBits::eGraphics |
281  vk::QueueFlagBits::eCompute |
282  vk::QueueFlagBits::eTransfer));
283 }

Referenced by impeller::CapabilitiesVK::GetEnabledDeviceFeatures().

◆ HasSuffix()

bool impeller::HasSuffix ( const std::string &  string,
const std::string &  suffix 
)

Definition at line 34 of file strings.cc.

34  {
35  auto position = string.rfind(suffix);
36  if (position == std::string::npos) {
37  return false;
38  }
39  return position == string.size() - suffix.size();
40 }

◆ HasSuitableColorFormat()

static bool impeller::HasSuitableColorFormat ( const vk::PhysicalDevice &  device,
vk::Format  format 
)
static

Definition at line 236 of file capabilities_vk.cc.

237  {
238  const auto props = device.getFormatProperties(format);
239  // This needs to be more comprehensive.
240  return !!(props.optimalTilingFeatures &
241  vk::FormatFeatureFlagBits::eColorAttachment);
242 }

Referenced by PhysicalDeviceSupportsRequiredFormats().

◆ HasSuitableDepthStencilFormat()

static bool impeller::HasSuitableDepthStencilFormat ( const vk::PhysicalDevice &  device,
vk::Format  format 
)
static

Definition at line 244 of file capabilities_vk.cc.

245  {
246  const auto props = device.getFormatProperties(format);
247  return !!(props.optimalTilingFeatures &
248  vk::FormatFeatureFlagBits::eDepthStencilAttachment);
249 }

Referenced by PhysicalDeviceSupportsRequiredFormats(), and impeller::CapabilitiesVK::SetPhysicalDevice().

◆ HasValidationLayers()

bool impeller::HasValidationLayers ( )

Definition at line 40 of file context_vk.cc.

40  {
41  return gHasValidationLayers;
42 }

References gHasValidationLayers.

Referenced by impeller::QueueVK::InsertDebugMarker(), impeller::CommandEncoderVK::InsertDebugMarker(), impeller::CommandEncoderVK::PopDebugGroup(), impeller::CommandEncoderVK::PushDebugGroup(), and impeller::ContextVK::SetDebugName().

◆ HeapAlloc()

static void* impeller::HeapAlloc ( void *  userData,
unsigned int  size 
)
static

Definition at line 11 of file tessellator.cc.

11  {
12  return malloc(size);
13 }

◆ HeapFree()

static void impeller::HeapFree ( void *  userData,
void *  ptr 
)
static

Definition at line 19 of file tessellator.cc.

19  {
20  free(ptr);
21 }

◆ HeapRealloc()

static void* impeller::HeapRealloc ( void *  userData,
void *  ptr,
unsigned int  size 
)
static

Definition at line 15 of file tessellator.cc.

15  {
16  return realloc(ptr, size);
17 }

◆ ImpellerUnimplemented()

void impeller::ImpellerUnimplemented ( const char *  method,
const char *  file,
int  line 
)
inline

Definition at line 29 of file config.h.

31  {
32  FML_CHECK(false) << "Unimplemented: " << method << " in " << file << ":"
33  << line;
34  std::abort();
35 }

◆ ImpellerValidationBreak()

void impeller::ImpellerValidationBreak ( const char *  message)

Definition at line 40 of file validation.cc.

40  {
41 // Nothing to do. Exists for the debugger.
42 #ifdef IMPELLER_ENABLE_VALIDATION
43  std::stringstream stream;
44  stream << "Break on '" << __FUNCTION__
45  << "' to inspect point of failure: " << message;
46  if (sValidationLogsAreFatal) {
47  FML_LOG(FATAL) << stream.str();
48  } else {
49  FML_LOG(ERROR) << stream.str();
50  }
51 #endif // IMPELLER_DEBUG
52 }

References sValidationLogsAreFatal.

Referenced by impeller::ValidationLog::~ValidationLog().

◆ ImpellerValidationErrorsSetFatal()

void impeller::ImpellerValidationErrorsSetFatal ( bool  fatal)

Definition at line 16 of file validation.cc.

16  {
17  sValidationLogsAreFatal = fatal;
18 }

References sValidationLogsAreFatal.

Referenced by impeller::PlaygroundTest::SetUp().

◆ InferMetalCapabilities()

static std::unique_ptr<Capabilities> impeller::InferMetalCapabilities ( id< MTLDevice >  device,
PixelFormat  color_format 
)
static

Definition at line 51 of file context_mtl.mm.

53  {
54  return CapabilitiesBuilder()
55  .SetSupportsOffscreenMSAA(true)
56  .SetSupportsSSBO(true)
57  .SetSupportsBufferToTextureBlits(true)
58  .SetSupportsTextureToTextureBlits(true)
59  .SetSupportsDecalSamplerAddressMode(true)
60  .SetSupportsFramebufferFetch(DeviceSupportsFramebufferFetch(device))
61  .SetDefaultColorFormat(color_format)
62  .SetDefaultStencilFormat(PixelFormat::kS8UInt)
63  .SetDefaultDepthStencilFormat(PixelFormat::kD32FloatS8UInt)
64  .SetSupportsCompute(true)
65  .SetSupportsComputeSubgroups(DeviceSupportsComputeSubgroups(device))
66  .SetSupportsReadFromResolve(true)
67  .SetSupportsReadFromOnscreenTexture(true)
68  .SetSupportsDeviceTransientTextures(true)
69  .Build();
70 }

References impeller::CapabilitiesBuilder::Build(), DeviceSupportsComputeSubgroups(), DeviceSupportsFramebufferFetch(), kD32FloatS8UInt, kS8UInt, impeller::CapabilitiesBuilder::SetDefaultColorFormat(), impeller::CapabilitiesBuilder::SetDefaultDepthStencilFormat(), impeller::CapabilitiesBuilder::SetDefaultStencilFormat(), impeller::CapabilitiesBuilder::SetSupportsBufferToTextureBlits(), impeller::CapabilitiesBuilder::SetSupportsCompute(), impeller::CapabilitiesBuilder::SetSupportsComputeSubgroups(), impeller::CapabilitiesBuilder::SetSupportsDecalSamplerAddressMode(), impeller::CapabilitiesBuilder::SetSupportsDeviceTransientTextures(), impeller::CapabilitiesBuilder::SetSupportsFramebufferFetch(), impeller::CapabilitiesBuilder::SetSupportsOffscreenMSAA(), impeller::CapabilitiesBuilder::SetSupportsReadFromOnscreenTexture(), impeller::CapabilitiesBuilder::SetSupportsReadFromResolve(), impeller::CapabilitiesBuilder::SetSupportsSSBO(), and impeller::CapabilitiesBuilder::SetSupportsTextureToTextureBlits().

Referenced by impeller::ContextMTL::UpdateOffscreenLayerPixelFormat().

◆ InferShaderTypefromFileExtension()

std::optional<BlobShaderType> impeller::InferShaderTypefromFileExtension ( const std::filesystem::path &  path)

Definition at line 19 of file blob_writer.cc.

20  {
21  if (path == ".vert") {
22  return BlobShaderType::kVertex;
23  } else if (path == ".frag") {
24  return BlobShaderType::kFragment;
25  } else if (path == ".comp") {
26  return BlobShaderType::kCompute;
27  }
28  return std::nullopt;
29 }

References kCompute, kFragment, and kVertex.

Referenced by impeller::BlobWriter::AddBlobAtPath().

◆ InsertImageMemoryBarrier()

static void impeller::InsertImageMemoryBarrier ( const vk::CommandBuffer &  cmd,
const vk::Image &  image,
vk::AccessFlags  src_access_mask,
vk::AccessFlags  dst_access_mask,
vk::ImageLayout  old_layout,
vk::ImageLayout  new_layout,
vk::PipelineStageFlags  src_stage,
vk::PipelineStageFlags  dst_stage,
uint32_t  base_mip_level,
uint32_t  mip_level_count = 1u 
)
static

Definition at line 215 of file blit_command_vk.cc.

224  {
225  if (old_layout == new_layout) {
226  return;
227  }
228 
229  vk::ImageMemoryBarrier barrier;
230  barrier.srcAccessMask = src_access_mask;
231  barrier.dstAccessMask = dst_access_mask;
232  barrier.oldLayout = old_layout;
233  barrier.newLayout = new_layout;
234  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
235  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
236  barrier.image = image;
237  barrier.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
238  barrier.subresourceRange.baseMipLevel = base_mip_level;
239  barrier.subresourceRange.levelCount = mip_level_count;
240  barrier.subresourceRange.baseArrayLayer = 0u;
241  barrier.subresourceRange.layerCount = 1u;
242 
243  cmd.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier);
244 }

Referenced by impeller::BlitGenerateMipmapCommandVK::Encode().

◆ InvertPorterDuffBlend()

std::optional< BlendMode > impeller::InvertPorterDuffBlend ( BlendMode  blend_mode)

Definition at line 28 of file blend_filter_contents.cc.

28  {
29  switch (blend_mode) {
30  case BlendMode::kClear:
31  return BlendMode::kClear;
32  case BlendMode::kSource:
33  return BlendMode::kDestination;
34  case BlendMode::kDestination:
35  return BlendMode::kSource;
36  case BlendMode::kSourceOver:
37  return BlendMode::kDestinationOver;
38  case BlendMode::kDestinationOver:
39  return BlendMode::kSourceOver;
40  case BlendMode::kSourceIn:
41  return BlendMode::kDestinationIn;
42  case BlendMode::kDestinationIn:
43  return BlendMode::kSourceIn;
44  case BlendMode::kSourceOut:
45  return BlendMode::kDestinationOut;
46  case BlendMode::kDestinationOut:
47  return BlendMode::kSourceOut;
48  case BlendMode::kSourceATop:
49  return BlendMode::kDestinationATop;
50  case BlendMode::kDestinationATop:
51  return BlendMode::kSourceATop;
52  case BlendMode::kXor:
53  return BlendMode::kXor;
54  case BlendMode::kPlus:
55  return BlendMode::kPlus;
56  case BlendMode::kModulate:
57  return BlendMode::kModulate;
58  default:
59  return std::nullopt;
60  }
61 }

References kClear, kDestination, kDestinationATop, kDestinationIn, kDestinationOut, kDestinationOver, kModulate, kPlus, kSource, kSourceATop, kSourceIn, kSourceOut, kSourceOver, and kXor.

Referenced by impeller::AtlasContents::Render().

◆ IPLR_CAPABILITY()

class impeller::IPLR_CAPABILITY ( "mutex"  )

Definition at line 17 of file thread.h.

17  {
18  public:
19  Mutex() = default;
20 
21  ~Mutex() = default;
22 
23  void Lock() IPLR_ACQUIRE() { mutex_.lock(); }
24 
25  void Unlock() IPLR_RELEASE() { mutex_.unlock(); }
26 
27  private:
28  std::mutex mutex_;
29 
30  FML_DISALLOW_COPY_ASSIGN_AND_MOVE(Mutex);
31 };

References IPLR_ACQUIRE, and IPLR_RELEASE.

◆ IPLR_GUARDED_BY()

static std::unordered_map<const ContextVK*, std::vector<std::weak_ptr<CommandPoolVK> > > g_all_pools_map impeller::IPLR_GUARDED_BY ( g_all_pools_map_mutex  )
static

◆ IsMappingSPIRV()

static bool impeller::IsMappingSPIRV ( const fml::Mapping &  mapping)
static

Definition at line 118 of file shader_library_vk.cc.

118  {
119  // https://registry.khronos.org/SPIR-V/specs/1.0/SPIRV.html#Magic
120  const uint32_t kSPIRVMagic = 0x07230203;
121  if (mapping.GetSize() < sizeof(kSPIRVMagic)) {
122  return false;
123  }
124  uint32_t magic = 0u;
125  ::memcpy(&magic, mapping.GetMapping(), sizeof(magic));
126  return magic == kSPIRVMagic;
127 }

◆ IsMultisampleCapable()

constexpr bool impeller::IsMultisampleCapable ( TextureType  type)
constexpr

Definition at line 257 of file formats.h.

257  {
258  switch (type) {
259  case TextureType::kTexture2D:
260  case TextureType::kTextureCube:
261  case TextureType::kTextureExternalOES:
262  return false;
263  case TextureType::kTexture2DMultisample:
264  return true;
265  }
266  return false;
267 }

References kTexture2D, kTexture2DMultisample, kTextureCube, and kTextureExternalOES.

Referenced by impeller::TextureDescriptor::SamplingOptionsAreValid().

◆ IterateOptionalDeviceExtensions()

static void impeller::IterateOptionalDeviceExtensions ( const std::function< void(OptionalDeviceExtensionVK)> &  it)
static

Definition at line 165 of file capabilities_vk.cc.

166  {
167  if (!it) {
168  return;
169  }
170  for (size_t i = 0;
171  i < static_cast<uint32_t>(OptionalDeviceExtensionVK::kLast); i++) {
172  it(static_cast<OptionalDeviceExtensionVK>(i));
173  }
174 }

References kLast.

Referenced by impeller::CapabilitiesVK::GetEnabledDeviceExtensions(), and impeller::CapabilitiesVK::SetPhysicalDevice().

◆ JoinLabels()

static std::string impeller::JoinLabels ( const VkDebugUtilsLabelEXT *  labels,
size_t  count 
)
static

Definition at line 48 of file debug_report_vk.cc.

49  {
50  std::stringstream stream;
51  for (size_t i = 0u; i < count; i++) {
52  stream << labels[i].pLabelName;
53  if (i != count - 1u) {
54  stream << ", ";
55  }
56  }
57  return stream.str();
58 }

◆ JoinVKDebugUtilsObjectNameInfoEXT()

static std::string impeller::JoinVKDebugUtilsObjectNameInfoEXT ( const VkDebugUtilsObjectNameInfoEXT *  names,
size_t  count 
)
static

Definition at line 60 of file debug_report_vk.cc.

62  {
63  std::stringstream stream;
64  for (size_t i = 0u; i < count; i++) {
65  stream << vk::to_string(vk::ObjectType(names[i].objectType)) << " ["
66  << names[i].objectHandle << "] [";
67  if (names[i].pObjectName != nullptr) {
68  stream << names[i].pObjectName;
69  } else {
70  stream << "UNNAMED";
71  }
72  stream << "]";
73  if (i != count - 1u) {
74  stream << ", ";
75  }
76  }
77  return stream.str();
78 }

◆ LinearSolve()

static Scalar impeller::LinearSolve ( Scalar  t,
Scalar  p0,
Scalar  p1 
)
inlinestatic

Definition at line 15 of file path_component.cc.

15  {
16  return p0 + t * (p1 - p0);
17 }

Referenced by impeller::LinearPathComponent::Solve().

◆ LineTo()

IMPELLER_API void impeller::LineTo ( PathBuilder *  builder,
Scalar  x,
Scalar  y 
)

Definition at line 22 of file tessellator.cc.

22  {
23  builder->LineTo(Point(x, y));
24 }

References impeller::PathBuilder::LineTo().

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

◆ LinkProgram()

static bool impeller::LinkProgram ( const ReactorGLES &  reactor,
const std::shared_ptr< PipelineGLES > &  pipeline,
const std::shared_ptr< const ShaderFunction > &  vert_function,
const std::shared_ptr< const ShaderFunction > &  frag_function 
)
static

Definition at line 72 of file pipeline_library_gles.cc.

76  {
77  TRACE_EVENT0("impeller", __FUNCTION__);
78 
79  const auto& descriptor = pipeline->GetDescriptor();
80 
81  auto vert_mapping =
82  ShaderFunctionGLES::Cast(*vert_function).GetSourceMapping();
83  auto frag_mapping =
84  ShaderFunctionGLES::Cast(*frag_function).GetSourceMapping();
85 
86  const auto& gl = reactor.GetProcTable();
87 
88  auto vert_shader = gl.CreateShader(GL_VERTEX_SHADER);
89  auto frag_shader = gl.CreateShader(GL_FRAGMENT_SHADER);
90 
91  if (vert_shader == 0 || frag_shader == 0) {
92  VALIDATION_LOG << "Could not create shader handles.";
93  return false;
94  }
95 
96  gl.SetDebugLabel(DebugResourceType::kShader, vert_shader,
97  SPrintF("%s Vertex Shader", descriptor.GetLabel().c_str()));
98  gl.SetDebugLabel(
99  DebugResourceType::kShader, frag_shader,
100  SPrintF("%s Fragment Shader", descriptor.GetLabel().c_str()));
101 
102  fml::ScopedCleanupClosure delete_vert_shader(
103  [&gl, vert_shader]() { gl.DeleteShader(vert_shader); });
104  fml::ScopedCleanupClosure delete_frag_shader(
105  [&gl, frag_shader]() { gl.DeleteShader(frag_shader); });
106 
107  gl.ShaderSourceMapping(vert_shader, *vert_mapping);
108  gl.ShaderSourceMapping(frag_shader, *frag_mapping);
109 
110  gl.CompileShader(vert_shader);
111  gl.CompileShader(frag_shader);
112 
113  GLint vert_status = GL_FALSE;
114  GLint frag_status = GL_FALSE;
115 
116  gl.GetShaderiv(vert_shader, GL_COMPILE_STATUS, &vert_status);
117  gl.GetShaderiv(frag_shader, GL_COMPILE_STATUS, &frag_status);
118 
119  if (vert_status != GL_TRUE) {
120  LogShaderCompilationFailure(gl, vert_shader, descriptor.GetLabel(),
121  *vert_mapping, ShaderStage::kVertex);
122  return false;
123  }
124 
125  if (frag_status != GL_TRUE) {
126  LogShaderCompilationFailure(gl, frag_shader, descriptor.GetLabel(),
127  *frag_mapping, ShaderStage::kFragment);
128  return false;
129  }
130 
131  auto program = reactor.GetGLHandle(pipeline->GetProgramHandle());
132  if (!program.has_value()) {
133  VALIDATION_LOG << "Could not get program handle from reactor.";
134  return false;
135  }
136 
137  gl.AttachShader(*program, vert_shader);
138  gl.AttachShader(*program, frag_shader);
139 
140  fml::ScopedCleanupClosure detach_vert_shader(
141  [&gl, program = *program, vert_shader]() {
142  gl.DetachShader(program, vert_shader);
143  });
144  fml::ScopedCleanupClosure detach_frag_shader(
145  [&gl, program = *program, frag_shader]() {
146  gl.DetachShader(program, frag_shader);
147  });
148 
149  for (const auto& stage_input :
150  descriptor.GetVertexDescriptor()->GetStageInputs()) {
151  gl.BindAttribLocation(*program, //
152  static_cast<GLuint>(stage_input.location), //
153  stage_input.name //
154  );
155  }
156 
157  gl.LinkProgram(*program);
158 
159  GLint link_status = GL_FALSE;
160  gl.GetProgramiv(*program, GL_LINK_STATUS, &link_status);
161 
162  if (link_status != GL_TRUE) {
163  VALIDATION_LOG << "Could not link shader program: "
164  << gl.GetProgramInfoLogString(*program);
165  return false;
166  }
167  return true;
168 }

References impeller::BackendCast< ShaderFunctionGLES, ShaderFunction >::Cast(), impeller::ReactorGLES::GetGLHandle(), impeller::ReactorGLES::GetProcTable(), impeller::ShaderFunctionGLES::GetSourceMapping(), kFragment, kShader, kVertex, LogShaderCompilationFailure(), SPrintF(), and VALIDATION_LOG.

◆ LoadActionToString()

constexpr const char* impeller::LoadActionToString ( LoadAction  action)
constexpr

Definition at line 189 of file formats.h.

189  {
190  switch (action) {
191  case LoadAction::kDontCare:
192  return "DontCare";
193  case LoadAction::kLoad:
194  return "Load";
195  case LoadAction::kClear:
196  return "Clear";
197  }
198 }

References kClear, kDontCare, and kLoad.

Referenced by AttachmentToString().

◆ LogMTLCommandBufferErrorIfPresent()

static bool impeller::LogMTLCommandBufferErrorIfPresent ( id< MTLCommandBuffer >  buffer)
static

Definition at line 61 of file command_buffer_mtl.mm.

61  {
62  if (!buffer) {
63  return true;
64  }
65 
66  if (buffer.status == MTLCommandBufferStatusCompleted) {
67  return true;
68  }
69 
70  std::stringstream stream;
71  stream << ">>>>>>>" << std::endl;
72  stream << "Impeller command buffer could not be committed!" << std::endl;
73 
74  if (auto desc = buffer.error.localizedDescription) {
75  stream << desc.UTF8String << std::endl;
76  }
77 
78  if (buffer.error) {
79  stream << "Domain: "
80  << (buffer.error.domain.length > 0u ? buffer.error.domain.UTF8String
81  : "<unknown>")
82  << " Code: "
83  << MTLCommandBufferErrorToString(
84  static_cast<MTLCommandBufferError>(buffer.error.code))
85  .UTF8String
86  << std::endl;
87  }
88 
89  if (@available(iOS 14.0, macOS 11.0, *)) {
90  NSArray<id<MTLCommandBufferEncoderInfo>>* infos =
91  buffer.error.userInfo[MTLCommandBufferEncoderInfoErrorKey];
92  for (id<MTLCommandBufferEncoderInfo> info in infos) {
93  stream << (info.label.length > 0u ? info.label.UTF8String
94  : "<Unlabelled Render Pass>")
95  << ": "
96  << MTLCommandEncoderErrorStateToString(info.errorState).UTF8String
97  << std::endl;
98 
99  auto signposts = [info.debugSignposts componentsJoinedByString:@", "];
100  if (signposts.length > 0u) {
101  stream << signposts.UTF8String << std::endl;
102  }
103  }
104 
105  for (id<MTLFunctionLog> log in buffer.logs) {
106  auto desc = log.description;
107  if (desc.length > 0u) {
108  stream << desc.UTF8String << std::endl;
109  }
110  }
111  }
112 
113  stream << "<<<<<<<";
114  VALIDATION_LOG << stream.str();
115  return false;
116 }

References MTLCommandBufferErrorToString(), and VALIDATION_LOG.

◆ LogShaderCompilationFailure()

static void impeller::LogShaderCompilationFailure ( const ProcTableGLES &  gl,
GLuint  shader,
const std::string &  name,
const fml::Mapping &  source_mapping,
ShaderStage  stage 
)
static

Definition at line 35 of file pipeline_library_gles.cc.

39  {
40  std::stringstream stream;
41  stream << "Failed to compile ";
42  switch (stage) {
43  case ShaderStage::kUnknown:
44  stream << "unknown";
45  break;
46  case ShaderStage::kVertex:
47  stream << "vertex";
48  break;
49  case ShaderStage::kFragment:
50  stream << "fragment";
51  break;
52  case ShaderStage::kTessellationControl:
53  stream << "tessellation control";
54  break;
55  case ShaderStage::kTessellationEvaluation:
56  stream << "tessellation evaluation";
57  break;
58  case ShaderStage::kCompute:
59  stream << "compute";
60  break;
61  }
62  stream << " shader for '" << name << "' with error:" << std::endl;
63  stream << GetShaderInfoLog(gl, shader) << std::endl;
64  stream << "Shader source was: " << std::endl;
65  stream << std::string{reinterpret_cast<const char*>(
66  source_mapping.GetMapping()),
67  source_mapping.GetSize()}
68  << std::endl;
69  VALIDATION_LOG << stream.str();
70 }

References GetShaderInfoLog(), kCompute, kFragment, kTessellationControl, kTessellationEvaluation, kUnknown, kVertex, and VALIDATION_LOG.

Referenced by LinkProgram().

◆ Luminosity()

static constexpr Scalar impeller::Luminosity ( Vector3  color)
inlinestaticconstexpr

Definition at line 140 of file color.cc.

140  {
141  return color.x * 0.3f + color.y * 0.59f + color.z * 0.11f;
142 }

References impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by impeller::Color::Blend(), ClipColor(), impeller::BlendFilterContents::SetBlendMode(), and SetLuminosity().

◆ Main()

bool impeller::Main ( const fml::CommandLine &  command_line)

Definition at line 13 of file blobcat_main.cc.

13  {
14  BlobWriter writer;
15 
16  std::string output;
17  if (!command_line.GetOptionValue("output", &output)) {
18  std::cerr << "Output path not specified." << std::endl;
19  return false;
20  }
21 
22  for (const auto& input : command_line.GetOptionValues("input")) {
23  if (!writer.AddBlobAtPath(std::string{input})) {
24  std::cerr << "Could not add blob at path: " << input << std::endl;
25  return false;
26  }
27  }
28 
29  auto blob = writer.CreateMapping();
30  if (!blob) {
31  std::cerr << "Could not create combined shader blob." << std::endl;
32  return false;
33  }
34 
35  auto current_directory =
36  fml::OpenDirectory(std::filesystem::current_path().string().c_str(),
37  false, fml::FilePermission::kReadWrite);
38  auto output_path =
39  std::filesystem::absolute(std::filesystem::current_path() / output);
40  if (!fml::WriteAtomically(current_directory, output_path.string().c_str(),
41  *blob)) {
42  std::cerr << "Could not write shader blob to path " << output << std::endl;
43  return false;
44  }
45 
46  return true;
47 }

References impeller::BlobWriter::AddBlobAtPath(), and impeller::BlobWriter::CreateMapping().

Referenced by main().

◆ MakeSharedVK()

template<class T >
auto impeller::MakeSharedVK ( vk::UniqueHandle< T, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE >  handle)

Definition at line 39 of file shared_object_vk.h.

40  {
41  if (!handle) {
42  return std::shared_ptr<SharedObjectVKT<T>>{nullptr};
43  }
44  return std::make_shared<SharedObjectVKT<T>>(std::move(handle));
45 }

◆ MakeTextFrameFromTextBlobSkia()

std::shared_ptr< impeller::TextFrame > impeller::MakeTextFrameFromTextBlobSkia ( const sk_sp< SkTextBlob > &  blob)

Definition at line 41 of file text_frame_skia.cc.

42  {
43  bool has_color = false;
44  std::vector<TextRun> runs;
45  for (SkTextBlobRunIterator run(blob.get()); !run.done(); run.next()) {
46  // TODO(jonahwilliams): ask Skia for a public API to look this up.
47  // https://github.com/flutter/flutter/issues/112005
48  SkStrikeSpec strikeSpec = SkStrikeSpec::MakeWithNoDevice(run.font());
49  SkBulkGlyphMetricsAndPaths paths{strikeSpec};
50 
51  const auto glyph_count = run.glyphCount();
52  const auto* glyphs = run.glyphs();
53  switch (run.positioning()) {
54  case SkTextBlobRunIterator::kFull_Positioning: {
55  std::vector<SkRect> glyph_bounds;
56  glyph_bounds.resize(glyph_count);
57  SkFont font = run.font();
58  auto font_size = font.getSize();
59  // For some platforms (including Android), `SkFont::getBounds()` snaps
60  // the computed bounds to integers. And so we scale up the font size
61  // prior to fetching the bounds to ensure that the returned bounds are
62  // always precise enough.
63  font.setSize(kScaleSize);
64  font.getBounds(glyphs, glyph_count, glyph_bounds.data(), nullptr);
65 
66  std::vector<TextRun::GlyphPosition> positions;
67  positions.reserve(glyph_count);
68  for (auto i = 0u; i < glyph_count; i++) {
69  // kFull_Positioning has two scalars per glyph.
70  const SkPoint* glyph_points = run.points();
71  const auto* point = glyph_points + i;
72  Glyph::Type type = paths.glyph(glyphs[i])->isColor()
73  ? Glyph::Type::kBitmap
74  : Glyph::Type::kPath;
75  has_color |= type == Glyph::Type::kBitmap;
76 
77  positions.emplace_back(TextRun::GlyphPosition{
78  Glyph{glyphs[i], type,
79  ToRect(glyph_bounds[i]).Scale(font_size / kScaleSize)},
80  Point{point->x(), point->y()}});
81  }
82  TextRun text_run(ToFont(run), positions);
83  runs.emplace_back(text_run);
84  break;
85  }
86  default:
87  FML_DLOG(ERROR) << "Unimplemented.";
88  continue;
89  }
90  }
91  return std::make_shared<TextFrame>(runs, ToRect(blob->bounds()), has_color);
92 }

References impeller::Glyph::kBitmap, impeller::Glyph::kPath, kScaleSize, impeller::TRect< T >::Scale(), ToFont(), ToRect(), and impeller::TPoint< T >::x.

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

◆ MakeTextFrameSTB()

std::shared_ptr< TextFrame > impeller::MakeTextFrameSTB ( const std::shared_ptr< TypefaceSTB > &  typeface_stb,
Font::Metrics  metrics,
const std::string &  text 
)

Definition at line 11 of file text_frame_stb.cc.

14  {
15  TextRun run(Font(typeface_stb, metrics));
16 
17  // Shape the text run using STB. The glyph positions could also be resolved
18  // using a more advanced text shaper such as harfbuzz.
19 
20  float scale = stbtt_ScaleForPixelHeight(
21  typeface_stb->GetFontInfo(),
22  metrics.point_size * TypefaceSTB::kPointsToPixels);
23 
24  int ascent, descent, line_gap;
25  stbtt_GetFontVMetrics(typeface_stb->GetFontInfo(), &ascent, &descent,
26  &line_gap);
27  ascent = std::round(ascent * scale);
28  descent = std::round(descent * scale);
29 
30  float x = 0;
31  for (size_t i = 0; i < text.size(); i++) {
32  int glyph_index =
33  stbtt_FindGlyphIndex(typeface_stb->GetFontInfo(), text[i]);
34 
35  int x0, y0, x1, y1;
36  stbtt_GetGlyphBitmapBox(typeface_stb->GetFontInfo(), glyph_index, scale,
37  scale, &x0, &y0, &x1, &y1);
38  float y = y0;
39 
40  int advance_width;
41  int left_side_bearing;
42  stbtt_GetGlyphHMetrics(typeface_stb->GetFontInfo(), glyph_index,
43  &advance_width, &left_side_bearing);
44 
45  Glyph glyph(glyph_index, Glyph::Type::kPath,
46  Rect::MakeXYWH(0, 0, x1 - x0, y1 - y0));
47  run.AddGlyph(glyph, {x + (left_side_bearing * scale), y});
48 
49  if (i + 1 < text.size()) {
50  int kerning = stbtt_GetCodepointKernAdvance(typeface_stb->GetFontInfo(),
51  text[i], text[i + 1]);
52  x += std::round((advance_width + kerning) * scale);
53  }
54  }
55 
56  std::optional<Rect> result;
57  for (const auto& glyph_position : run.GetGlyphPositions()) {
58  Rect glyph_rect =
59  Rect(glyph_position.position + glyph_position.glyph.bounds.origin,
60  glyph_position.glyph.bounds.size);
61  result = result.has_value() ? result->Union(glyph_rect) : glyph_rect;
62  }
63 
64  std::vector<TextRun> runs = {run};
65  return std::make_shared<TextFrame>(
66  runs, result.value_or(Rect::MakeLTRB(0, 0, 0, 0)), false);
67 }

References impeller::TextRun::AddGlyph(), impeller::TextRun::GetGlyphPositions(), impeller::Glyph::kPath, impeller::TypefaceSTB::kPointsToPixels, impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::Font::Metrics::point_size.

◆ MakeVertices()

std::shared_ptr< VerticesGeometry > impeller::MakeVertices ( const flutter::DlVertices *  vertices)

Definition at line 31 of file dl_vertices_geometry.cc.

32  {
33  auto bounds = ToRect(vertices->bounds());
34  auto mode = ToVertexMode(vertices->mode());
35  std::vector<Point> positions(vertices->vertex_count());
36  for (auto i = 0; i < vertices->vertex_count(); i++) {
37  positions[i] = skia_conversions::ToPoint(vertices->vertices()[i]);
38  }
39 
40  std::vector<uint16_t> indices(vertices->index_count());
41  for (auto i = 0; i < vertices->index_count(); i++) {
42  indices[i] = vertices->indices()[i];
43  }
44 
45  std::vector<Color> colors;
46  if (vertices->colors()) {
47  colors.reserve(vertices->vertex_count());
48  for (auto i = 0; i < vertices->vertex_count(); i++) {
49  colors.push_back(
50  skia_conversions::ToColor(vertices->colors()[i]).Premultiply());
51  }
52  }
53  std::vector<Point> texture_coordinates;
54  if (vertices->texture_coordinates()) {
55  texture_coordinates.reserve(vertices->vertex_count());
56  for (auto i = 0; i < vertices->vertex_count(); i++) {
57  texture_coordinates.push_back(
58  skia_conversions::ToPoint(vertices->texture_coordinates()[i]));
59  }
60  }
61  return std::make_shared<VerticesGeometry>(
62  positions, indices, texture_coordinates, colors, bounds, mode);
63 }

References impeller::Color::Premultiply(), impeller::skia_conversions::ToColor(), impeller::skia_conversions::ToPoint(), ToRect(), and ToVertexMode().

Referenced by impeller::DlDispatcher::drawVertices().

◆ Min()

static constexpr Color impeller::Min ( Color  c,
float  threshold 
)
inlinestaticconstexpr

Definition at line 132 of file color.cc.

132  {
133  return Color(std::min(c.red, threshold), std::min(c.green, threshold),
134  std::min(c.blue, threshold), std::min(c.alpha, threshold));
135 }

References impeller::Color::alpha, impeller::Color::blue, impeller::Color::green, and impeller::Color::red.

Referenced by impeller::Color::Blend().

◆ MoveTo()

IMPELLER_API void impeller::MoveTo ( PathBuilder *  builder,
Scalar  x,
Scalar  y 
)

Definition at line 18 of file tessellator.cc.

18  {
19  builder->MoveTo(Point(x, y));
20 }

References impeller::PathBuilder::MoveTo().

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

◆ MTLCommandBufferErrorToString()

static NSString* impeller::MTLCommandBufferErrorToString ( MTLCommandBufferError  code)
static

Definition at line 36 of file command_buffer_mtl.mm.

36  {
37  switch (code) {
38  case MTLCommandBufferErrorNone:
39  return @"none";
40  case MTLCommandBufferErrorInternal:
41  return @"internal";
42  case MTLCommandBufferErrorTimeout:
43  return @"timeout";
44  case MTLCommandBufferErrorPageFault:
45  return @"page fault";
46  case MTLCommandBufferErrorNotPermitted:
47  return @"not permitted";
48  case MTLCommandBufferErrorOutOfMemory:
49  return @"out of memory";
50  case MTLCommandBufferErrorInvalidResource:
51  return @"invalid resource";
52  case MTLCommandBufferErrorMemoryless:
53  return @"memory-less";
54  default:
55  break;
56  }
57 
58  return [NSString stringWithFormat:@"<unknown> %zu", code];
59 }

Referenced by LogMTLCommandBufferErrorIfPresent().

◆ MTLShaderLibraryFromFileData()

static NSArray<id<MTLLibrary> >* impeller::MTLShaderLibraryFromFileData ( id< MTLDevice >  device,
const std::vector< std::shared_ptr< fml::Mapping >> &  libraries_data,
const std::string &  label 
)
static

Definition at line 172 of file context_mtl.mm.

175  {
176  NSMutableArray<id<MTLLibrary>>* found_libraries = [NSMutableArray array];
177  for (const auto& library_data : libraries_data) {
178  if (library_data == nullptr) {
179  FML_LOG(ERROR) << "Shader library data was null.";
180  return nil;
181  }
182 
183  __block auto data = library_data;
184 
185  auto dispatch_data =
186  ::dispatch_data_create(library_data->GetMapping(), // buffer
187  library_data->GetSize(), // size
188  dispatch_get_main_queue(), // queue
189  ^() {
190  // We just need a reference.
191  data.reset();
192  } // destructor
193  );
194  if (!dispatch_data) {
195  FML_LOG(ERROR) << "Could not wrap shader data in dispatch data.";
196  return nil;
197  }
198 
199  NSError* shader_library_error = nil;
200  auto library = [device newLibraryWithData:dispatch_data
201  error:&shader_library_error];
202  if (!library) {
203  FML_LOG(ERROR) << "Could not create shader library: "
204  << shader_library_error.localizedDescription.UTF8String;
205  return nil;
206  }
207  if (!label.empty()) {
208  library.label = @(label.c_str());
209  }
210  [found_libraries addObject:library];
211  }
212  return found_libraries;
213 }

Referenced by impeller::ContextMTL::Create().

◆ MTLShaderLibraryFromFilePaths()

static NSArray<id<MTLLibrary> >* impeller::MTLShaderLibraryFromFilePaths ( id< MTLDevice >  device,
const std::vector< std::string > &  libraries_paths 
)
static

Definition at line 149 of file context_mtl.mm.

151  {
152  NSMutableArray<id<MTLLibrary>>* found_libraries = [NSMutableArray array];
153  for (const auto& library_path : libraries_paths) {
154  if (!fml::IsFile(library_path)) {
155  VALIDATION_LOG << "Shader library does not exist at path '"
156  << library_path << "'";
157  return nil;
158  }
159  NSError* shader_library_error = nil;
160  auto library = [device newLibraryWithFile:@(library_path.c_str())
161  error:&shader_library_error];
162  if (!library) {
163  FML_LOG(ERROR) << "Could not create shader library: "
164  << shader_library_error.localizedDescription.UTF8String;
165  return nil;
166  }
167  [found_libraries addObject:library];
168  }
169  return found_libraries;
170 }

References VALIDATION_LOG.

Referenced by impeller::ContextMTL::Create().

◆ NearEqual()

static bool impeller::NearEqual ( Scalar  a,
Scalar  b,
Scalar  epsilon 
)
inlinestatic

Definition at line 247 of file path_component.cc.

247  {
248  return (a > (b - epsilon)) && (a < (b + epsilon));
249 }

Referenced by NearZero().

◆ NearZero()

static bool impeller::NearZero ( Scalar  a)
inlinestatic

Definition at line 251 of file path_component.cc.

251  {
252  return NearEqual(a, 0.0, 1e-12);
253 }

References NearEqual().

Referenced by CubicPathBoundingPopulateValues().

◆ NormalizeUniformKey()

static std::string impeller::NormalizeUniformKey ( const std::string &  key)
static

Definition at line 53 of file buffer_bindings_gles.cc.

53  {
54  std::string result;
55  result.reserve(key.length());
56  for (char ch : key) {
57  if (ch != '_') {
58  result.push_back(toupper(ch));
59  }
60  }
61  return result;
62 }

Referenced by CreateUniformMemberKey(), and impeller::BufferBindingsGLES::ReadUniformsBindings().

◆ OpenCacheFile()

static std::unique_ptr<fml::Mapping> impeller::OpenCacheFile ( const fml::UniqueFD &  base_directory,
const std::string &  cache_file_name,
const CapabilitiesVK &  caps 
)
static

Definition at line 34 of file pipeline_cache_vk.cc.

37  {
38  if (!base_directory.is_valid()) {
39  return nullptr;
40  }
41  std::unique_ptr<fml::Mapping> mapping =
42  fml::FileMapping::CreateReadOnly(base_directory, cache_file_name);
43  if (!mapping) {
44  return nullptr;
45  }
46  if (!VerifyExistingCache(*mapping, caps)) {
47  return nullptr;
48  }
49  mapping = RemoveMetadataFromCache(std::move(mapping));
50  if (!mapping) {
51  return nullptr;
52  }
53  return mapping;
54 }

References RemoveMetadataFromCache(), and VerifyExistingCache().

Referenced by impeller::PipelineCacheVK::PipelineCacheVK().

◆ OpenFixtureAsSkData()

static sk_sp<SkData> impeller::OpenFixtureAsSkData ( const char *  fixture_name)
static

Definition at line 55 of file dl_playground.cc.

55  {
56  auto mapping = flutter::testing::OpenFixtureAsMapping(fixture_name);
57  if (!mapping) {
58  return nullptr;
59  }
60  auto data = SkData::MakeWithProc(
61  mapping->GetMapping(), mapping->GetSize(),
62  [](const void* ptr, void* context) {
63  delete reinterpret_cast<fml::Mapping*>(context);
64  },
65  mapping.get());
66  mapping.release();
67  return data;
68 }

Referenced by impeller::DlPlayground::CreateTestFontOfSize().

◆ operator*() [1/7]

template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint<F> impeller::operator* ( const TPoint< F > &  p1,
const TPoint< I > &  p2 
)
constexpr

Definition at line 253 of file point.h.

253  {
254  return {p1.x * static_cast<F>(p2.x), p1.y * static_cast<F>(p2.y)};
255 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator*() [2/7]

template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint<F> impeller::operator* ( const TPoint< I > &  p1,
const TPoint< F > &  p2 
)
constexpr

Definition at line 258 of file point.h.

258  {
259  return p2 * p1;
260 }

◆ operator*() [3/7]

template<class T , class U >
constexpr TPoint<T> impeller::operator* ( const TSize< U > &  s,
const TPoint< T > &  p 
)
constexpr

Definition at line 297 of file point.h.

297  {
298  return p * s;
299 }

◆ operator*() [4/7]

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color impeller::operator* ( T  value,
const Color &  c 
)
inlineconstexpr

Definition at line 895 of file color.h.

895  {
896  return c * static_cast<Scalar>(value);
897 }

◆ operator*() [5/7]

template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TPoint<T> impeller::operator* ( U  s,
const TPoint< T > &  p 
)
constexpr

Definition at line 275 of file point.h.

275  {
276  return p * s;
277 }

◆ operator*() [6/7]

template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TSize<T> impeller::operator* ( U  s,
const TSize< T > &  p 
)
constexpr

Definition at line 126 of file size.h.

126  {
127  return p * s;
128 }

◆ operator*() [7/7]

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 impeller::operator* ( U  s,
const Vector3 &  p 
)
constexpr

Definition at line 206 of file vector.h.

206  {
207  return p * s;
208 }

◆ operator+() [1/5]

template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint<F> impeller::operator+ ( const TPoint< F > &  p1,
const TPoint< I > &  p2 
)
constexpr

Definition at line 233 of file point.h.

233  {
234  return {p1.x + static_cast<F>(p2.x), p1.y + static_cast<F>(p2.y)};
235 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator+() [2/5]

template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint<F> impeller::operator+ ( const TPoint< I > &  p1,
const TPoint< F > &  p2 
)
constexpr

Definition at line 238 of file point.h.

238  {
239  return p2 + p1;
240 }

◆ operator+() [3/5]

template<class T , class U >
constexpr TPoint<T> impeller::operator+ ( const TSize< U > &  s,
const TPoint< T > &  p 
)
constexpr

Definition at line 287 of file point.h.

287  {
288  return p + s;
289 }

◆ operator+() [4/5]

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color impeller::operator+ ( T  value,
const Color &  c 
)
inlineconstexpr

Definition at line 884 of file color.h.

884  {
885  return c + static_cast<Scalar>(value);
886 }

◆ operator+() [5/5]

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 impeller::operator+ ( U  s,
const Vector3 &  p 
)
constexpr

Definition at line 211 of file vector.h.

211  {
212  return p + s;
213 }

◆ operator-() [1/5]

template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint<F> impeller::operator- ( const TPoint< F > &  p1,
const TPoint< I > &  p2 
)
constexpr

Definition at line 243 of file point.h.

243  {
244  return {p1.x - static_cast<F>(p2.x), p1.y - static_cast<F>(p2.y)};
245 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator-() [2/5]

template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint<F> impeller::operator- ( const TPoint< I > &  p1,
const TPoint< F > &  p2 
)
constexpr

Definition at line 248 of file point.h.

248  {
249  return {static_cast<F>(p1.x) - p2.x, static_cast<F>(p1.y) - p2.y};
250 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator-() [3/5]

template<class T , class U >
constexpr TPoint<T> impeller::operator- ( const TSize< U > &  s,
const TPoint< T > &  p 
)
constexpr

Definition at line 292 of file point.h.

292  {
293  return {static_cast<T>(s.width) - p.x, static_cast<T>(s.height) - p.y};
294 }

References impeller::TSize< T >::height, impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator-() [4/5]

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color impeller::operator- ( T  value,
const Color &  c 
)
inlineconstexpr

Definition at line 889 of file color.h.

889  {
890  auto v = static_cast<Scalar>(value);
891  return {v - c.red, v - c.green, v - c.blue, v - c.alpha};
892 }

References impeller::Color::alpha, impeller::Color::blue, impeller::Color::green, and impeller::Color::red.

◆ operator-() [5/5]

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 impeller::operator- ( U  s,
const Vector3 &  p 
)
constexpr

Definition at line 216 of file vector.h.

216  {
217  return -p + s;
218 }

◆ operator/() [1/7]

template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint<F> impeller::operator/ ( const TPoint< F > &  p1,
const TPoint< I > &  p2 
)
constexpr

Definition at line 263 of file point.h.

263  {
264  return {p1.x / static_cast<F>(p2.x), p1.y / static_cast<F>(p2.y)};
265 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator/() [2/7]

template<class F , class I , class = MixedOp<F, I>>
constexpr TPoint<F> impeller::operator/ ( const TPoint< I > &  p1,
const TPoint< F > &  p2 
)
constexpr

Definition at line 268 of file point.h.

268  {
269  return {static_cast<F>(p1.x) / p2.x, static_cast<F>(p1.y) / p2.y};
270 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator/() [3/7]

template<class T , class U >
constexpr TPoint<T> impeller::operator/ ( const TSize< U > &  s,
const TPoint< T > &  p 
)
constexpr

Definition at line 302 of file point.h.

302  {
303  return {static_cast<T>(s.width) / p.x, static_cast<T>(s.height) / p.y};
304 }

References impeller::TSize< T >::height, impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator/() [4/7]

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color impeller::operator/ ( T  value,
const Color &  c 
)
inlineconstexpr

Definition at line 900 of file color.h.

900  {
901  auto v = static_cast<Scalar>(value);
902  return {v / c.red, v / c.green, v / c.blue, v / c.alpha};
903 }

References impeller::Color::alpha, impeller::Color::blue, impeller::Color::green, and impeller::Color::red.

◆ operator/() [5/7]

template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TPoint<T> impeller::operator/ ( U  s,
const TPoint< T > &  p 
)
constexpr

Definition at line 280 of file point.h.

280  {
281  return {static_cast<T>(s) / p.x, static_cast<T>(s) / p.y};
282 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator/() [6/7]

template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TSize<T> impeller::operator/ ( U  s,
const TSize< T > &  p 
)
constexpr

Definition at line 131 of file size.h.

131  {
132  return {static_cast<T>(s) / p.x, static_cast<T>(s) / p.y};
133 }

◆ operator/() [7/7]

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 impeller::operator/ ( U  s,
const Vector3 &  p 
)
constexpr

Definition at line 221 of file vector.h.

221  {
222  return {
223  static_cast<Scalar>(s) / p.x,
224  static_cast<Scalar>(s) / p.y,
225  static_cast<Scalar>(s) / p.z,
226  };
227 }

References impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

◆ OptimumAtlasSizeForFontGlyphPairs() [1/2]

static ISize impeller::OptimumAtlasSizeForFontGlyphPairs ( const std::vector< FontGlyphPair > &  pairs,
std::vector< Rect > &  glyph_positions,
const std::shared_ptr< GlyphAtlasContext > &  atlas_context,
GlyphAtlas::Type  type,
const ISize &  max_texture_size 
)
static

Definition at line 116 of file typographer_context_skia.cc.

121  {
122  static constexpr auto kMinAtlasSize = 8u;
123  static constexpr auto kMinAlphaBitmapSize = 1024u;
124 
125  TRACE_EVENT0("impeller", __FUNCTION__);
126 
127  ISize current_size = type == GlyphAtlas::Type::kAlphaBitmap
128  ? ISize(kMinAlphaBitmapSize, kMinAlphaBitmapSize)
129  : ISize(kMinAtlasSize, kMinAtlasSize);
130  size_t total_pairs = pairs.size() + 1;
131  do {
132  auto rect_packer = std::shared_ptr<RectanglePacker>(
133  RectanglePacker::Factory(current_size.width, current_size.height));
134 
135  auto remaining_pairs = PairsFitInAtlasOfSize(pairs, current_size,
136  glyph_positions, rect_packer);
137  if (remaining_pairs == 0) {
138  atlas_context->UpdateRectPacker(rect_packer);
139  return current_size;
140  } else if (remaining_pairs < std::ceil(total_pairs / 2)) {
141  current_size = ISize::MakeWH(
142  std::max(current_size.width, current_size.height),
143  Allocation::NextPowerOfTwoSize(
144  std::min(current_size.width, current_size.height) + 1));
145  } else {
146  current_size = ISize::MakeWH(
147  Allocation::NextPowerOfTwoSize(current_size.width + 1),
148  Allocation::NextPowerOfTwoSize(current_size.height + 1));
149  }
150  } while (current_size.width <= max_texture_size.width &&
151  current_size.height <= max_texture_size.height);
152  return ISize{0, 0};
153 }

References impeller::RectanglePacker::Factory(), impeller::TSize< T >::height, impeller::GlyphAtlas::kAlphaBitmap, impeller::TSize< int64_t >::MakeWH(), impeller::Allocation::NextPowerOfTwoSize(), PairsFitInAtlasOfSize(), and impeller::TSize< T >::width.

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas(), and impeller::TypographerContextSTB::CreateGlyphAtlas().

◆ OptimumAtlasSizeForFontGlyphPairs() [2/2]

static ISize impeller::OptimumAtlasSizeForFontGlyphPairs ( const std::vector< FontGlyphPair > &  pairs,
std::vector< Rect > &  glyph_positions,
const std::shared_ptr< GlyphAtlasContext > &  atlas_context,
GlyphAtlas::Type  type,
const ISize &  max_texture_size 
)
static

Definition at line 159 of file typographer_context_stb.cc.

164  {
165  static constexpr auto kMinAtlasSize = 8u;
166  static constexpr auto kMinAlphaBitmapSize = 1024u;
167 
168  TRACE_EVENT0("impeller", __FUNCTION__);
169 
170  ISize current_size = type == GlyphAtlas::Type::kAlphaBitmap
171  ? ISize(kMinAlphaBitmapSize, kMinAlphaBitmapSize)
172  : ISize(kMinAtlasSize, kMinAtlasSize);
173  size_t total_pairs = pairs.size() + 1;
174  do {
175  auto rect_packer = std::shared_ptr<RectanglePacker>(
176  RectanglePacker::Factory(current_size.width, current_size.height));
177 
178  auto remaining_pairs = PairsFitInAtlasOfSize(pairs, current_size,
179  glyph_positions, rect_packer);
180  if (remaining_pairs == 0) {
181  atlas_context->UpdateRectPacker(rect_packer);
182  return current_size;
183  } else if (remaining_pairs < std::ceil(total_pairs / 2)) {
184  current_size = ISize::MakeWH(
185  std::max(current_size.width, current_size.height),
186  Allocation::NextPowerOfTwoSize(
187  std::min(current_size.width, current_size.height) + 1));
188  } else {
189  current_size = ISize::MakeWH(
190  Allocation::NextPowerOfTwoSize(current_size.width + 1),
191  Allocation::NextPowerOfTwoSize(current_size.height + 1));
192  }
193  } while (current_size.width <= max_texture_size.width &&
194  current_size.height <= max_texture_size.height);
195  return ISize{0, 0};
196 }

References impeller::RectanglePacker::Factory(), impeller::TSize< T >::height, impeller::GlyphAtlas::kAlphaBitmap, impeller::TSize< int64_t >::MakeWH(), impeller::Allocation::NextPowerOfTwoSize(), PairsFitInAtlasOfSize(), and impeller::TSize< T >::width.

◆ OptionsFromPass()

ContentContextOptions impeller::OptionsFromPass ( const RenderPass &  pass)

Definition at line 20 of file contents.cc.

20  {
21  ContentContextOptions opts;
22  opts.sample_count = pass.GetRenderTarget().GetSampleCount();
23  opts.color_attachment_pixel_format =
24  pass.GetRenderTarget().GetRenderTargetPixelFormat();
25  opts.has_stencil_attachment =
26  pass.GetRenderTarget().GetStencilAttachment().has_value();
27  return opts;
28 }

References impeller::ContentContextOptions::color_attachment_pixel_format, impeller::RenderPass::GetRenderTarget(), impeller::RenderTarget::GetRenderTargetPixelFormat(), impeller::RenderTarget::GetSampleCount(), impeller::RenderTarget::GetStencilAttachment(), impeller::ContentContextOptions::has_stencil_attachment, and impeller::ContentContextOptions::sample_count.

Referenced by AdvancedBlend(), OptionsFromPassAndEntity(), PipelineBlend(), impeller::CheckerboardContents::Render(), impeller::ClipContents::Render(), impeller::AtlasContents::Render(), impeller::ClipRestoreContents::Render(), and impeller::testing::TEST_P().

◆ OptionsFromPassAndEntity()

ContentContextOptions impeller::OptionsFromPassAndEntity ( const RenderPass &  pass,
const Entity &  entity 
)

Definition at line 30 of file contents.cc.

31  {
32  ContentContextOptions opts = OptionsFromPass(pass);
33  opts.blend_mode = entity.GetBlendMode();
34  return opts;
35 }

References impeller::ContentContextOptions::blend_mode, impeller::Entity::GetBlendMode(), and OptionsFromPass().

Referenced by impeller::RuntimeEffectContents::Render(), impeller::TiledTextureContents::Render(), impeller::SolidRRectBlurContents::Render(), impeller::SolidColorContents::Render(), impeller::TextContents::Render(), impeller::TextureContents::Render(), impeller::VerticesColorContents::Render(), impeller::VerticesUVContents::Render(), impeller::AtlasTextureContents::Render(), and impeller::AtlasColorContents::Render().

◆ PairsFitInAtlasOfSize() [1/2]

static size_t impeller::PairsFitInAtlasOfSize ( const std::vector< FontGlyphPair > &  pairs,
const ISize &  atlas_size,
std::vector< Rect > &  glyph_positions,
const std::shared_ptr< RectanglePacker > &  rect_packer 
)
static

Definition at line 43 of file typographer_context_skia.cc.

47  {
48  if (atlas_size.IsEmpty()) {
49  return false;
50  }
51 
52  glyph_positions.clear();
53  glyph_positions.reserve(pairs.size());
54 
55  size_t i = 0;
56  for (auto it = pairs.begin(); it != pairs.end(); ++i, ++it) {
57  const auto& pair = *it;
58 
59  const auto glyph_size =
60  ISize::Ceil(pair.glyph.bounds.size * pair.scaled_font.scale);
61  IPoint16 location_in_atlas;
62  if (!rect_packer->addRect(glyph_size.width + kPadding, //
63  glyph_size.height + kPadding, //
64  &location_in_atlas //
65  )) {
66  return pairs.size() - i;
67  }
68  glyph_positions.emplace_back(Rect::MakeXYWH(location_in_atlas.x(), //
69  location_in_atlas.y(), //
70  glyph_size.width, //
71  glyph_size.height //
72  ));
73  }
74 
75  return 0;
76 }

References impeller::TSize< int64_t >::Ceil(), impeller::TSize< T >::IsEmpty(), kPadding, impeller::TRect< Scalar >::MakeXYWH(), impeller::IPoint16::x(), and impeller::IPoint16::y().

Referenced by OptimumAtlasSizeForFontGlyphPairs().

◆ PairsFitInAtlasOfSize() [2/2]

static size_t impeller::PairsFitInAtlasOfSize ( const std::vector< FontGlyphPair > &  pairs,
const ISize &  atlas_size,
std::vector< Rect > &  glyph_positions,
const std::shared_ptr< RectanglePacker > &  rect_packer 
)
static

Definition at line 44 of file typographer_context_stb.cc.

48  {
49  if (atlas_size.IsEmpty()) {
50  return false;
51  }
52 
53  glyph_positions.clear();
54  glyph_positions.reserve(pairs.size());
55 
56  size_t i = 0;
57  for (auto it = pairs.begin(); it != pairs.end(); ++i, ++it) {
58  const auto& pair = *it;
59  const Font& font = pair.scaled_font.font;
60 
61  // We downcast to the correct typeface type to access `stb` specific
62  // methods.
63  std::shared_ptr<TypefaceSTB> typeface_stb =
64  std::reinterpret_pointer_cast<TypefaceSTB>(font.GetTypeface());
65  // Conversion factor to scale font size in Points to pixels.
66  // Note this assumes typical DPI.
67  float text_size_pixels =
68  font.GetMetrics().point_size * TypefaceSTB::kPointsToPixels;
69 
70  ISize glyph_size;
71  {
72  int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
73  // NOTE: We increase the size of the glyph by one pixel in all dimensions
74  // to allow us to cut out padding later.
75  float scale = stbtt_ScaleForPixelHeight(typeface_stb->GetFontInfo(),
76  text_size_pixels);
77  stbtt_GetGlyphBitmapBox(typeface_stb->GetFontInfo(), pair.glyph.index,
78  scale, scale, &x0, &y0, &x1, &y1);
79 
80  glyph_size = ISize(x1 - x0, y1 - y0);
81  }
82 
83  IPoint16 location_in_atlas;
84  if (!rect_packer->addRect(glyph_size.width + kPadding, //
85  glyph_size.height + kPadding, //
86  &location_in_atlas //
87  )) {
88  return pairs.size() - i;
89  }
90  glyph_positions.emplace_back(Rect::MakeXYWH(location_in_atlas.x(), //
91  location_in_atlas.y(), //
92  glyph_size.width, //
93  glyph_size.height //
94  ));
95  }
96 
97  return 0;
98 }

References impeller::Font::GetMetrics(), impeller::Font::GetTypeface(), impeller::TSize< T >::height, impeller::TSize< T >::IsEmpty(), kPadding, impeller::TypefaceSTB::kPointsToPixels, impeller::TRect< Scalar >::MakeXYWH(), impeller::Font::Metrics::point_size, impeller::TSize< T >::width, impeller::IPoint16::x(), and impeller::IPoint16::y().

◆ PhysicalDeviceSupportsRequiredFormats()

static bool impeller::PhysicalDeviceSupportsRequiredFormats ( const vk::PhysicalDevice &  device)
static

Definition at line 251 of file capabilities_vk.cc.

252  {
253  const auto has_color_format =
254  HasSuitableColorFormat(device, vk::Format::eB8G8R8A8Unorm);
255  const auto has_stencil_format =
256  HasSuitableDepthStencilFormat(device, vk::Format::eS8Uint) ||
257  HasSuitableDepthStencilFormat(device, vk::Format::eD32SfloatS8Uint) ||
258  HasSuitableDepthStencilFormat(device, vk::Format::eD24UnormS8Uint);
259  return has_color_format && has_stencil_format;
260 }

References HasSuitableColorFormat(), and HasSuitableDepthStencilFormat().

Referenced by impeller::CapabilitiesVK::GetEnabledDeviceFeatures().

◆ PickPhysicalDevice()

static std::optional<vk::PhysicalDevice> impeller::PickPhysicalDevice ( const CapabilitiesVK &  caps,
const vk::Instance &  instance 
)
static

Definition at line 44 of file context_vk.cc.

46  {
47  for (const auto& device : instance.enumeratePhysicalDevices().value) {
48  if (caps.GetEnabledDeviceFeatures(device).has_value()) {
49  return device;
50  }
51  }
52  return std::nullopt;
53 }

References impeller::CapabilitiesVK::GetEnabledDeviceFeatures().

◆ PickQueue()

static std::optional<QueueIndexVK> impeller::PickQueue ( const vk::PhysicalDevice &  device,
vk::QueueFlagBits  flags 
)
static

Definition at line 78 of file context_vk.cc.

79  {
80  // This can be modified to ensure that dedicated queues are returned for each
81  // queue type depending on support.
82  const auto families = device.getQueueFamilyProperties();
83  for (size_t i = 0u; i < families.size(); i++) {
84  if (!(families[i].queueFlags & flags)) {
85  continue;
86  }
87  return QueueIndexVK{.family = i, .index = 0};
88  }
89  return std::nullopt;
90 }

References impeller::QueueIndexVK::family.

◆ PipelineBlend()

static std::optional<Entity> impeller::PipelineBlend ( const FilterInput::Vector &  inputs,
const ContentContext &  renderer,
const Entity &  entity,
const Rect &  coverage,
BlendMode  blend_mode,
std::optional< Color >  foreground_color,
ColorFilterContents::AbsorbOpacity  absorb_opacity,
std::optional< Scalar >  alpha 
)
static

Definition at line 527 of file blend_filter_contents.cc.

535  {
536  using VS = BlendPipeline::VertexShader;
537  using FS = BlendPipeline::FragmentShader;
538 
539  auto dst_snapshot =
540  inputs[0]->GetSnapshot("PipelineBlend(Dst)", renderer, entity);
541  if (!dst_snapshot.has_value()) {
542  return std::nullopt; // Nothing to render.
543  }
544 
545  Rect subpass_coverage = coverage;
546  if (entity.GetContents()) {
547  auto coverage_hint = entity.GetContents()->GetCoverageHint();
548 
549  if (coverage_hint.has_value()) {
550  auto maybe_subpass_coverage =
551  subpass_coverage.Intersection(*coverage_hint);
552  if (!maybe_subpass_coverage.has_value()) {
553  return std::nullopt; // Nothing to render.
554  }
555 
556  subpass_coverage = *maybe_subpass_coverage;
557  }
558  }
559 
560  ContentContext::SubpassCallback callback = [&](const ContentContext& renderer,
561  RenderPass& pass) {
562  auto& host_buffer = pass.GetTransientsBuffer();
563 
564  Command cmd;
565  DEBUG_COMMAND_INFO(cmd, SPrintF("Pipeline Blend Filter (%s)",
566  BlendModeToString(blend_mode)));
567  auto options = OptionsFromPass(pass);
568 
569  auto add_blend_command = [&](std::optional<Snapshot> input) {
570  if (!input.has_value()) {
571  return false;
572  }
573  auto input_coverage = input->GetCoverage();
574  if (!input_coverage.has_value()) {
575  return false;
576  }
577 
578  auto sampler = renderer.GetContext()->GetSamplerLibrary()->GetSampler(
579  input->sampler_descriptor);
580  FS::BindTextureSamplerSrc(cmd, input->texture, sampler);
581 
582  auto size = input->texture->GetSize();
583  VertexBufferBuilder<VS::PerVertexData> vtx_builder;
584  vtx_builder.AddVertices({
585  {Point(0, 0), Point(0, 0)},
586  {Point(size.width, 0), Point(1, 0)},
587  {Point(size.width, size.height), Point(1, 1)},
588  {Point(0, 0), Point(0, 0)},
589  {Point(size.width, size.height), Point(1, 1)},
590  {Point(0, size.height), Point(0, 1)},
591  });
592  auto vtx_buffer = vtx_builder.CreateVertexBuffer(host_buffer);
593  cmd.BindVertices(vtx_buffer);
594 
595  VS::FrameInfo frame_info;
596  frame_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
597  Matrix::MakeTranslation(-subpass_coverage.origin) *
598  input->transform;
599  frame_info.texture_sampler_y_coord_scale =
600  input->texture->GetYCoordScale();
601 
602  FS::FragInfo frag_info;
603  frag_info.input_alpha =
604  absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
605  ? input->opacity
606  : 1.0;
607  FS::BindFragInfo(cmd, host_buffer.EmplaceUniform(frag_info));
608  VS::BindFrameInfo(cmd, host_buffer.EmplaceUniform(frame_info));
609 
610  pass.AddCommand(std::move(cmd));
611  return true;
612  };
613 
614  // Draw the first texture using kSource.
615  options.blend_mode = BlendMode::kSource;
616  cmd.pipeline = renderer.GetBlendPipeline(options);
617  if (!add_blend_command(dst_snapshot)) {
618  return true;
619  }
620 
621  // Write subsequent textures using the selected blend mode.
622 
623  if (inputs.size() >= 2) {
624  options.blend_mode = blend_mode;
625  cmd.pipeline = renderer.GetBlendPipeline(options);
626 
627  for (auto texture_i = inputs.begin() + 1; texture_i < inputs.end();
628  texture_i++) {
629  auto src_input = texture_i->get()->GetSnapshot("PipelineBlend(Src)",
630  renderer, entity);
631  if (!add_blend_command(src_input)) {
632  return true;
633  }
634  }
635  }
636 
637  // If a foreground color is set, blend it in.
638 
639  if (foreground_color.has_value()) {
640  auto contents = std::make_shared<SolidColorContents>();
641  contents->SetGeometry(
642  Geometry::MakeRect(Rect::MakeSize(pass.GetRenderTargetSize())));
643  contents->SetColor(foreground_color.value());
644 
645  Entity foreground_entity;
646  foreground_entity.SetBlendMode(blend_mode);
647  foreground_entity.SetContents(contents);
648  if (!foreground_entity.Render(renderer, pass)) {
649  return false;
650  }
651  }
652 
653  return true;
654  };
655 
656  auto out_texture = renderer.MakeSubpass(
657  "Pipeline Blend Filter", ISize(subpass_coverage.size), callback);
658 
659  if (!out_texture) {
660  return std::nullopt;
661  }
662 
663  return Entity::FromSnapshot(
664  Snapshot{
665  .texture = out_texture,
666  .transform = Matrix::MakeTranslation(subpass_coverage.origin),
667  // Since we absorbed the transform of the inputs and used the
668  // respective snapshot sampling modes when blending, pass on
669  // the default NN clamp sampler.
670  .sampler_descriptor = {},
671  .opacity = (absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
672  ? 1.0f
673  : dst_snapshot->opacity) *
674  alpha.value_or(1.0)},
675  entity.GetBlendMode(), entity.GetStencilDepth());
676 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::Command::BindVertices(), BlendModeToString(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), DEBUG_COMMAND_INFO, impeller::Entity::FromSnapshot(), impeller::Entity::GetBlendMode(), impeller::ContentContext::GetBlendPipeline(), impeller::Entity::GetContents(), impeller::ContentContext::GetContext(), impeller::Entity::GetStencilDepth(), impeller::TRect< T >::Intersection(), kSource, impeller::ColorFilterContents::kYes, impeller::Matrix::MakeOrthographic(), impeller::Geometry::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::ContentContext::MakeSubpass(), impeller::Matrix::MakeTranslation(), OptionsFromPass(), impeller::TRect< T >::origin, impeller::Command::pipeline, impeller::Entity::Render(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::TRect< T >::size, SPrintF(), and impeller::Snapshot::texture.

◆ PixelFormatIsDepthStencil()

constexpr bool impeller::PixelFormatIsDepthStencil ( PixelFormat  format)
constexpr

Definition at line 375 of file formats_vk.h.

375  {
376  switch (format) {
377  case PixelFormat::kUnknown:
378  case PixelFormat::kA8UNormInt:
379  case PixelFormat::kR8UNormInt:
380  case PixelFormat::kR8G8UNormInt:
381  case PixelFormat::kR8G8B8A8UNormInt:
382  case PixelFormat::kR8G8B8A8UNormIntSRGB:
383  case PixelFormat::kB8G8R8A8UNormInt:
384  case PixelFormat::kB8G8R8A8UNormIntSRGB:
385  case PixelFormat::kR32G32B32A32Float:
386  case PixelFormat::kR16G16B16A16Float:
387  case PixelFormat::kB10G10R10XR:
388  case PixelFormat::kB10G10R10XRSRGB:
389  case PixelFormat::kB10G10R10A10XR:
390  return false;
391  case PixelFormat::kS8UInt:
392  case PixelFormat::kD24UnormS8Uint:
393  case PixelFormat::kD32FloatS8UInt:
394  return true;
395  }
396  return false;
397 }

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, and kUnknown.

Referenced by ToVKImageUsageFlags().

◆ PixelFormatToString()

constexpr const char* impeller::PixelFormatToString ( PixelFormat  format)
constexpr

Definition at line 114 of file formats.h.

114  {
115  switch (format) {
116  case PixelFormat::kUnknown:
117  return "Unknown";
118  case PixelFormat::kA8UNormInt:
119  return "A8UNormInt";
120  case PixelFormat::kR8UNormInt:
121  return "R8UNormInt";
122  case PixelFormat::kR8G8UNormInt:
123  return "R8G8UNormInt";
124  case PixelFormat::kR8G8B8A8UNormInt:
125  return "R8G8B8A8UNormInt";
126  case PixelFormat::kR8G8B8A8UNormIntSRGB:
127  return "R8G8B8A8UNormIntSRGB";
128  case PixelFormat::kB8G8R8A8UNormInt:
129  return "B8G8R8A8UNormInt";
130  case PixelFormat::kB8G8R8A8UNormIntSRGB:
131  return "B8G8R8A8UNormIntSRGB";
132  case PixelFormat::kR32G32B32A32Float:
133  return "R32G32B32A32Float";
134  case PixelFormat::kR16G16B16A16Float:
135  return "R16G16B16A16Float";
136  case PixelFormat::kB10G10R10XR:
137  return "B10G10R10XR";
138  case PixelFormat::kB10G10R10XRSRGB:
139  return "B10G10R10XRSRGB";
140  case PixelFormat::kB10G10R10A10XR:
141  return "B10G10R10A10XR";
142  case PixelFormat::kS8UInt:
143  return "S8UInt";
144  case PixelFormat::kD24UnormS8Uint:
145  return "D24UnormS8Uint";
146  case PixelFormat::kD32FloatS8UInt:
147  return "D32FloatS8UInt";
148  }
149  FML_UNREACHABLE();
150 }

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, and kUnknown.

Referenced by TextureDescriptorToString().

◆ PlaygroundBackendToString()

std::string impeller::PlaygroundBackendToString ( PlaygroundBackend  backend)

Definition at line 39 of file playground.cc.

39  {
40  switch (backend) {
41  case PlaygroundBackend::kMetal:
42  return "Metal";
43  case PlaygroundBackend::kOpenGLES:
44  return "OpenGLES";
45  case PlaygroundBackend::kVulkan:
46  return "Vulkan";
47  }
48  FML_UNREACHABLE();
49 }

References kMetal, kOpenGLES, and kVulkan.

Referenced by impeller::PlaygroundImpl::Create().

◆ PlaygroundKeyCallback()

static void impeller::PlaygroundKeyCallback ( GLFWwindow *  window,
int  key,
int  scancode,
int  action,
int  mods 
)
static

Definition at line 156 of file playground.cc.

160  {
161  if ((key == GLFW_KEY_ESCAPE) && action == GLFW_RELEASE) {
162  if (mods & (GLFW_MOD_CONTROL | GLFW_MOD_SUPER | GLFW_MOD_SHIFT)) {
163  gShouldOpenNewPlaygrounds = false;
164  }
165  ::glfwSetWindowShouldClose(window, GLFW_TRUE);
166  }
167 }

References gShouldOpenNewPlaygrounds.

Referenced by impeller::Playground::OpenPlaygroundHere().

◆ QuadraticSolve()

static Scalar impeller::QuadraticSolve ( Scalar  t,
Scalar  p0,
Scalar  p1,
Scalar  p2 
)
inlinestatic

Definition at line 19 of file path_component.cc.

19  {
20  return (1 - t) * (1 - t) * p0 + //
21  2 * (1 - t) * t * p1 + //
22  t * t * p2;
23 }

Referenced by impeller::QuadraticPathComponent::Solve().

◆ QuadraticSolveDerivative()

static Scalar impeller::QuadraticSolveDerivative ( Scalar  t,
Scalar  p0,
Scalar  p1,
Scalar  p2 
)
inlinestatic

Definition at line 25 of file path_component.cc.

28  {
29  return 2 * (1 - t) * (p1 - p0) + //
30  2 * t * (p2 - p1);
31 }

Referenced by impeller::QuadraticPathComponent::SolveDerivative().

◆ ReadStageInputFormat()

static MTLVertexFormat impeller::ReadStageInputFormat ( const ShaderStageIOSlot &  input)
static

Definition at line 16 of file vertex_descriptor_mtl.mm.

16  {
17  if (input.columns != 1) {
18  // All matrix types are unsupported as vertex inputs.
19  return MTLVertexFormatInvalid;
20  }
21 
22  switch (input.type) {
23  case ShaderType::kFloat: {
24  if (input.bit_width == 8 * sizeof(float)) {
25  switch (input.vec_size) {
26  case 1:
27  return MTLVertexFormatFloat;
28  case 2:
29  return MTLVertexFormatFloat2;
30  case 3:
31  return MTLVertexFormatFloat3;
32  case 4:
33  return MTLVertexFormatFloat4;
34  }
35  }
36  return MTLVertexFormatInvalid;
37  }
38  case ShaderType::kHalfFloat: {
39  if (input.bit_width == 8 * sizeof(float) / 2) {
40  switch (input.vec_size) {
41  case 1:
42  return MTLVertexFormatHalf;
43  case 2:
44  return MTLVertexFormatHalf2;
45  case 3:
46  return MTLVertexFormatHalf3;
47  case 4:
48  return MTLVertexFormatHalf4;
49  }
50  }
51  return MTLVertexFormatInvalid;
52  }
53  case ShaderType::kDouble: {
54  // Unsupported.
55  return MTLVertexFormatInvalid;
56  }
57  case ShaderType::kBoolean: {
58  if (input.bit_width == 8 * sizeof(bool) && input.vec_size == 1) {
59  return MTLVertexFormatChar;
60  }
61  return MTLVertexFormatInvalid;
62  }
63  case ShaderType::kSignedByte: {
64  if (input.bit_width == 8 * sizeof(char)) {
65  switch (input.vec_size) {
66  case 1:
67  return MTLVertexFormatChar;
68  case 2:
69  return MTLVertexFormatChar2;
70  case 3:
71  return MTLVertexFormatChar3;
72  case 4:
73  return MTLVertexFormatChar4;
74  }
75  }
76  return MTLVertexFormatInvalid;
77  }
78  case ShaderType::kUnsignedByte: {
79  if (input.bit_width == 8 * sizeof(char)) {
80  switch (input.vec_size) {
81  case 1:
82  return MTLVertexFormatUChar;
83  case 2:
84  return MTLVertexFormatUChar2;
85  case 3:
86  return MTLVertexFormatUChar3;
87  case 4:
88  return MTLVertexFormatUChar4;
89  }
90  }
91  return MTLVertexFormatInvalid;
92  }
93  case ShaderType::kSignedShort: {
94  if (input.bit_width == 8 * sizeof(short)) {
95  switch (input.vec_size) {
96  case 1:
97  return MTLVertexFormatShort;
98  case 2:
99  return MTLVertexFormatShort2;
100  case 3:
101  return MTLVertexFormatShort3;
102  case 4:
103  return MTLVertexFormatShort4;
104  }
105  }
106  return MTLVertexFormatInvalid;
107  }
108  case ShaderType::kUnsignedShort: {
109  if (input.bit_width == 8 * sizeof(ushort)) {
110  switch (input.vec_size) {
111  case 1:
112  return MTLVertexFormatUShort;
113  case 2:
114  return MTLVertexFormatUShort2;
115  case 3:
116  return MTLVertexFormatUShort3;
117  case 4:
118  return MTLVertexFormatUShort4;
119  }
120  }
121  return MTLVertexFormatInvalid;
122  }
123  case ShaderType::kSignedInt: {
124  if (input.bit_width == 8 * sizeof(int32_t)) {
125  switch (input.vec_size) {
126  case 1:
127  return MTLVertexFormatInt;
128  case 2:
129  return MTLVertexFormatInt2;
130  case 3:
131  return MTLVertexFormatInt3;
132  case 4:
133  return MTLVertexFormatInt4;
134  }
135  }
136  return MTLVertexFormatInvalid;
137  }
138  case ShaderType::kUnsignedInt: {
139  if (input.bit_width == 8 * sizeof(uint32_t)) {
140  switch (input.vec_size) {
141  case 1:
142  return MTLVertexFormatUInt;
143  case 2:
144  return MTLVertexFormatUInt2;
145  case 3:
146  return MTLVertexFormatUInt3;
147  case 4:
148  return MTLVertexFormatUInt4;
149  }
150  }
151  return MTLVertexFormatInvalid;
152  }
153  case ShaderType::kSignedInt64: {
154  // Unsupported.
155  return MTLVertexFormatInvalid;
156  }
157  case ShaderType::kUnsignedInt64: {
158  // Unsupported.
159  return MTLVertexFormatInvalid;
160  }
161  case ShaderType::kAtomicCounter:
162  case ShaderType::kStruct:
163  case ShaderType::kImage:
164  case ShaderType::kSampledImage:
165  case ShaderType::kUnknown:
166  case ShaderType::kVoid:
167  case ShaderType::kSampler:
168  return MTLVertexFormatInvalid;
169  }
170 }

References impeller::ShaderStageIOSlot::bit_width, impeller::ShaderStageIOSlot::columns, kAtomicCounter, kBoolean, kDouble, kFloat, kHalfFloat, kImage, kSampledImage, kSampler, kSignedByte, kSignedInt, kSignedInt64, kSignedShort, kStruct, kUnknown, kUnsignedByte, kUnsignedInt, kUnsignedInt64, kUnsignedShort, kVoid, impeller::ShaderStageIOSlot::type, and impeller::ShaderStageIOSlot::vec_size.

Referenced by impeller::VertexDescriptorMTL::SetStageInputsAndLayout().

◆ RealizedFuture()

template<class T >
std::future<T> impeller::RealizedFuture ( T  t)

Definition at line 12 of file promise.h.

12  {
13  std::promise<T> promise;
14  auto future = promise.get_future();
15  promise.set_value(std::move(t));
16  return future;
17 }

◆ RegistrationIfReady()

static const ArchiveClassRegistration* impeller::RegistrationIfReady ( const ArchiveClassRegistration *  registration)
inlinestatic

Definition at line 95 of file archive_database.cc.

96  {
97  if (registration == nullptr) {
98  return nullptr;
99  }
100  return registration->IsValid() ? registration : nullptr;
101 }

References impeller::ArchiveClassRegistration::IsValid().

Referenced by impeller::ArchiveDatabase::GetRegistrationForDefinition().

◆ RemoveMetadataFromCache()

static std::unique_ptr<fml::Mapping> impeller::RemoveMetadataFromCache ( std::unique_ptr< fml::Mapping >  data)
static

Definition at line 29 of file pipeline_cache_vk.cc.

30  {
31  return data;
32 }

Referenced by OpenCacheFile().

◆ ReportPipelineCreationFeedback()

static void impeller::ReportPipelineCreationFeedback ( const PipelineDescriptor &  desc,
const vk::PipelineCreationFeedbackCreateInfoEXT &  feedback 
)
static

Definition at line 226 of file pipeline_library_vk.cc.

228  {
229  constexpr bool kReportPipelineCreationFeedbackToLogs = false;
230  constexpr bool kReportPipelineCreationFeedbackToTraces = true;
231  if (kReportPipelineCreationFeedbackToLogs) {
232  ReportPipelineCreationFeedbackToLog(desc, feedback);
233  }
234  if (kReportPipelineCreationFeedbackToTraces) {
235  ReportPipelineCreationFeedbackToTrace(desc, feedback);
236  }
237 }

References ReportPipelineCreationFeedbackToLog(), and ReportPipelineCreationFeedbackToTrace().

◆ ReportPipelineCreationFeedbackToLog() [1/2]

static void impeller::ReportPipelineCreationFeedbackToLog ( const PipelineDescriptor &  desc,
const vk::PipelineCreationFeedbackCreateInfoEXT &  feedback 
)
static

Definition at line 178 of file pipeline_library_vk.cc.

180  {
181  std::stringstream stream;
182  stream << std::fixed << std::showpoint << std::setprecision(2);
183  stream << std::endl << ">>>>>>" << std::endl;
184  stream << "Pipeline '" << desc.GetLabel() << "' ";
185  ReportPipelineCreationFeedbackToLog(stream,
186  *feedback.pPipelineCreationFeedback);
187  if (feedback.pipelineStageCreationFeedbackCount != 0) {
188  stream << std::endl;
189  }
190  for (size_t i = 0, count = feedback.pipelineStageCreationFeedbackCount;
191  i < count; i++) {
192  stream << "\tStage " << i + 1 << ": ";
193  ReportPipelineCreationFeedbackToLog(
194  stream, feedback.pPipelineStageCreationFeedbacks[i]);
195  if (i != count - 1) {
196  stream << std::endl;
197  }
198  }
199  stream << std::endl << "<<<<<<" << std::endl;
200  FML_LOG(ERROR) << stream.str();
201 }

References impeller::PipelineDescriptor::GetLabel(), and ReportPipelineCreationFeedbackToLog().

◆ ReportPipelineCreationFeedbackToLog() [2/2]

static void impeller::ReportPipelineCreationFeedbackToLog ( std::stringstream &  stream,
const vk::PipelineCreationFeedbackEXT &  feedback 
)
static

Definition at line 161 of file pipeline_library_vk.cc.

163  {
164  const auto pipeline_cache_hit =
165  feedback.flags &
166  vk::PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit;
167  const auto base_pipeline_accl =
168  feedback.flags &
169  vk::PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration;
170  auto duration = std::chrono::duration_cast<MillisecondsF>(
171  std::chrono::nanoseconds{feedback.duration});
172  stream << "Time: " << duration.count() << "ms"
173  << " Cache Hit: " << static_cast<bool>(pipeline_cache_hit)
174  << " Base Accel: " << static_cast<bool>(base_pipeline_accl)
175  << " Thread: " << std::this_thread::get_id();
176 }

Referenced by ReportPipelineCreationFeedback(), and ReportPipelineCreationFeedbackToLog().

◆ ReportPipelineCreationFeedbackToTrace()

static void impeller::ReportPipelineCreationFeedbackToTrace ( const PipelineDescriptor &  desc,
const vk::PipelineCreationFeedbackCreateInfoEXT &  feedback 
)
static

Definition at line 203 of file pipeline_library_vk.cc.

205  {
206  static int64_t gPipelineCacheHits = 0;
207  static int64_t gPipelineCacheMisses = 0;
208  static int64_t gPipelines = 0;
209  if (feedback.pPipelineCreationFeedback->flags &
210  vk::PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit) {
211  gPipelineCacheHits++;
212  } else {
213  gPipelineCacheMisses++;
214  }
215  gPipelines++;
216  static constexpr int64_t kImpellerPipelineTraceID = 1988;
217  FML_TRACE_COUNTER("impeller", //
218  "PipelineCache", // series name
219  kImpellerPipelineTraceID, // series ID
220  "PipelineCacheHits", gPipelineCacheHits, //
221  "PipelineCacheMisses", gPipelineCacheMisses, //
222  "TotalPipelines", gPipelines //
223  );
224 }

Referenced by ReportPipelineCreationFeedback().

◆ ResourceIsLive()

static bool impeller::ResourceIsLive ( const ProcTableGLES &  gl,
DebugResourceType  type,
GLint  name 
)
static

Definition at line 261 of file proc_table_gles.cc.

263  {
264  switch (type) {
265  case DebugResourceType::kTexture:
266  return gl.IsTexture(name);
267  case DebugResourceType::kBuffer:
268  return gl.IsBuffer(name);
269  case DebugResourceType::kProgram:
270  return gl.IsProgram(name);
271  case DebugResourceType::kShader:
272  return gl.IsShader(name);
273  case DebugResourceType::kRenderBuffer:
274  return gl.IsRenderbuffer(name);
275  case DebugResourceType::kFrameBuffer:
276  return gl.IsFramebuffer(name);
277  }
278  FML_UNREACHABLE();
279 }

References kBuffer, kFrameBuffer, kProgram, kRenderBuffer, kShader, and kTexture.

Referenced by impeller::ProcTableGLES::SetDebugLabel().

◆ SafeMTLPixelFormatBGR10_XR()

MTLPixelFormat impeller::SafeMTLPixelFormatBGR10_XR ( )

Safe accessor for MTLPixelFormatBGR10_XR. Returns PixelFormat::kUnknown if MTLPixelFormatBGR10_XR isn't supported.

Definition at line 130 of file formats_mtl.mm.

130  {
131  if (@available(iOS 10, macOS 11.0, *)) {
132  return MTLPixelFormatBGR10_XR;
133  } else {
134  return MTLPixelFormatInvalid;
135  }
136 }

Referenced by ToMTLPixelFormat().

◆ SafeMTLPixelFormatBGR10_XR_sRGB()

MTLPixelFormat impeller::SafeMTLPixelFormatBGR10_XR_sRGB ( )

Safe accessor for MTLPixelFormatBGR10_XR_sRGB. Returns PixelFormat::kUnknown if MTLPixelFormatBGR10_XR_sRGB isn't supported.

Definition at line 122 of file formats_mtl.mm.

122  {
123  if (@available(iOS 11, macOS 11.0, *)) {
124  return MTLPixelFormatBGR10_XR_sRGB;
125  } else {
126  return MTLPixelFormatInvalid;
127  }
128 }

Referenced by ToMTLPixelFormat().

◆ SafeMTLPixelFormatBGRA10_XR()

MTLPixelFormat impeller::SafeMTLPixelFormatBGRA10_XR ( )

Safe accessor for MTLPixelFormatBGRA10_XR. Returns PixelFormat::kUnknown if MTLPixelFormatBGR10_XR isn't supported.

Definition at line 138 of file formats_mtl.mm.

138  {
139  if (@available(iOS 10, macOS 11.0, *)) {
140  return MTLPixelFormatBGRA10_XR;
141  } else {
142  return MTLPixelFormatInvalid;
143  }
144 }

Referenced by ToMTLPixelFormat().

◆ SafeMTLPixelFormatDepth24Unorm_Stencil8()

MTLPixelFormat impeller::SafeMTLPixelFormatDepth24Unorm_Stencil8 ( )

Safe accessor for MTLPixelFormatDepth24Unorm_Stencil8. Returns PixelFormat::kUnknown if MTLPixelFormatDepth24Unorm_Stencil8 isn't supported.

Definition at line 113 of file formats_mtl.mm.

113  {
114 #if !FML_OS_IOS
115  if (@available(macOS 10.11, *)) {
116  return MTLPixelFormatDepth24Unorm_Stencil8;
117  }
118 #endif // FML_OS_IOS
119  return MTLPixelFormatInvalid;
120 }

Referenced by ToMTLPixelFormat().

◆ Saturation()

static constexpr Scalar impeller::Saturation ( Vector3  color)
inlinestaticconstexpr

Definition at line 166 of file color.cc.

166  {
167  return std::max(std::max(color.x, color.y), color.z) -
168  std::min(std::min(color.x, color.y), color.z);
169 }

References impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by impeller::Color::Blend(), and impeller::BlendFilterContents::SetBlendMode().

◆ ScalarNearlyEqual()

constexpr bool impeller::ScalarNearlyEqual ( Scalar  x,
Scalar  y,
Scalar  tolerance = kEhCloseEnough 
)
inlineconstexpr

Definition at line 27 of file scalar.h.

29  {
30  return ScalarNearlyZero(x - y, tolerance);
31 }

References ScalarNearlyZero().

Referenced by CreateGradientBuffer(), impeller::Color::operator==(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::Color::Unpremultiply().

◆ ScalarNearlyZero()

constexpr bool impeller::ScalarNearlyZero ( Scalar  x,
Scalar  tolerance = kEhCloseEnough 
)
inlineconstexpr

Definition at line 22 of file scalar.h.

23  {
24  return Absolute(x) <= tolerance;
25 }

References Absolute().

Referenced by impeller::Matrix::IsAligned(), and ScalarNearlyEqual().

◆ ScalarToHalf()

constexpr InternalHalf impeller::ScalarToHalf ( Scalar  f)
inlineconstexpr

Convert a scalar to a half precision float.

See also: https://clang.llvm.org/docs/LanguageExtensions.html This is not currently supported on Windows toolchains.

Definition at line 28 of file half.h.

28  {
29 #ifdef FML_OS_WIN
30  return static_cast<InternalHalf>(0);
31 #else
32  return static_cast<InternalHalf>(f);
33 #endif
34 }

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

◆ SetLuminosity()

static constexpr Vector3 impeller::SetLuminosity ( Vector3  color,
Scalar  luminosity 
)
inlinestaticconstexpr

Definition at line 160 of file color.cc.

161  {
162  Scalar relative_lum = luminosity - Luminosity(color);
163  return ClipColor(color + relative_lum);
164 }

References ClipColor(), and Luminosity().

Referenced by impeller::Color::Blend().

◆ SetSaturation()

static constexpr Vector3 impeller::SetSaturation ( Vector3  color,
Scalar  saturation 
)
inlinestaticconstexpr

Definition at line 171 of file color.cc.

172  {
173  Scalar mn = std::min(std::min(color.x, color.y), color.z);
174  Scalar mx = std::max(std::max(color.x, color.y), color.z);
175  return (mn < mx) ? ((color - mn) * saturation) / (mx - mn) : Vector3();
176 }

References impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by impeller::Color::Blend().

◆ SetTextureLayout()

static void impeller::SetTextureLayout ( const Attachment &  attachment,
const vk::AttachmentDescription &  attachment_desc,
const std::shared_ptr< CommandBufferVK > &  command_buffer,
const std::shared_ptr< Texture > Attachment::*  texture_ptr 
)
static

Definition at line 69 of file render_pass_vk.cc.

73  {
74  const auto& texture = attachment.*texture_ptr;
75  if (!texture) {
76  return;
77  }
78  const auto& texture_vk = TextureVK::Cast(*texture);
79 
80  if (attachment_desc.initialLayout == vk::ImageLayout::eGeneral) {
81  BarrierVK barrier;
82  barrier.new_layout = vk::ImageLayout::eGeneral;
83  barrier.cmd_buffer = command_buffer->GetEncoder()->GetCommandBuffer();
84  barrier.src_access = vk::AccessFlagBits::eShaderRead;
85  barrier.src_stage = vk::PipelineStageFlagBits::eFragmentShader;
86  barrier.dst_access = vk::AccessFlagBits::eColorAttachmentWrite |
87  vk::AccessFlagBits::eTransferWrite;
88  barrier.dst_stage = vk::PipelineStageFlagBits::eColorAttachmentOutput |
89  vk::PipelineStageFlagBits::eTransfer;
90 
91  texture_vk.SetLayout(barrier);
92  }
93 
94  // Instead of transitioning layouts manually using barriers, we are going to
95  // make the subpass perform our transitions.
96  texture_vk.SetLayoutWithoutEncoding(attachment_desc.finalLayout);
97 }

References impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::BarrierVK::cmd_buffer, impeller::BarrierVK::dst_access, impeller::BarrierVK::dst_stage, impeller::BarrierVK::new_layout, impeller::BarrierVK::src_access, and impeller::BarrierVK::src_stage.

◆ SetViewportAndScissor()

static void impeller::SetViewportAndScissor ( const Command &  command,
const vk::CommandBuffer &  cmd_buffer,
PassBindingsCache &  cmd_buffer_cache,
const ISize &  target_size 
)
static

Definition at line 462 of file render_pass_vk.cc.

465  {
466  // Set the viewport.
467  const auto& vp = command.viewport.value_or<Viewport>(
468  {.rect = Rect::MakeSize(target_size)});
469  vk::Viewport viewport = vk::Viewport()
470  .setWidth(vp.rect.size.width)
471  .setHeight(-vp.rect.size.height)
472  .setY(vp.rect.size.height)
473  .setMinDepth(0.0f)
474  .setMaxDepth(1.0f);
475  cmd_buffer_cache.SetViewport(cmd_buffer, 0, 1, &viewport);
476 
477  // Set the scissor rect.
478  const auto& sc = command.scissor.value_or(IRect::MakeSize(target_size));
479  vk::Rect2D scissor =
480  vk::Rect2D()
481  .setOffset(vk::Offset2D(sc.origin.x, sc.origin.y))
482  .setExtent(vk::Extent2D(sc.size.width, sc.size.height));
483  cmd_buffer_cache.SetScissor(cmd_buffer, 0, 1, &scissor);
484 }

References impeller::Command::scissor, impeller::PassBindingsCache::SetScissor(), impeller::PassBindingsCache::SetViewport(), and impeller::Command::viewport.

Referenced by EncodeCommand().

◆ ShaderLibraryMappingsForPlayground() [1/3]

static std::vector<std::shared_ptr<fml::Mapping> > impeller::ShaderLibraryMappingsForPlayground ( )
static

Definition at line 30 of file playground_impl_vk.cc.

30  {
31  return {
32  std::make_shared<fml::NonOwnedMapping>(impeller_entity_shaders_vk_data,
33  impeller_entity_shaders_vk_length),
34  std::make_shared<fml::NonOwnedMapping>(impeller_modern_shaders_vk_data,
35  impeller_modern_shaders_vk_length),
36  std::make_shared<fml::NonOwnedMapping>(
37  impeller_fixtures_shaders_vk_data,
38  impeller_fixtures_shaders_vk_length),
39  std::make_shared<fml::NonOwnedMapping>(impeller_imgui_shaders_vk_data,
40  impeller_imgui_shaders_vk_length),
41  std::make_shared<fml::NonOwnedMapping>(impeller_scene_shaders_vk_data,
42  impeller_scene_shaders_vk_length),
43  std::make_shared<fml::NonOwnedMapping>(
44  impeller_compute_shaders_vk_data, impeller_compute_shaders_vk_length),
45  };
46 }

◆ ShaderLibraryMappingsForPlayground() [2/3]

static std::vector<std::shared_ptr<fml::Mapping> > impeller::ShaderLibraryMappingsForPlayground ( )
static

Definition at line 36 of file playground_impl_mtl.mm.

36  {
37  return {std::make_shared<fml::NonOwnedMapping>(
38  impeller_entity_shaders_data, impeller_entity_shaders_length),
39  std::make_shared<fml::NonOwnedMapping>(
40  impeller_modern_shaders_data, impeller_modern_shaders_length),
41  std::make_shared<fml::NonOwnedMapping>(
42  impeller_framebuffer_blend_shaders_data,
43  impeller_framebuffer_blend_shaders_length),
44  std::make_shared<fml::NonOwnedMapping>(
45  impeller_fixtures_shaders_data, impeller_fixtures_shaders_length),
46  std::make_shared<fml::NonOwnedMapping>(impeller_imgui_shaders_data,
47  impeller_imgui_shaders_length),
48  std::make_shared<fml::NonOwnedMapping>(impeller_scene_shaders_data,
49  impeller_scene_shaders_length),
50  std::make_shared<fml::NonOwnedMapping>(
51  impeller_compute_shaders_data, impeller_compute_shaders_length)
52 
53  };
54 }

◆ ShaderLibraryMappingsForPlayground() [3/3]

static std::vector<std::shared_ptr<fml::Mapping> > impeller::ShaderLibraryMappingsForPlayground ( )
static

Definition at line 89 of file playground_impl_gles.cc.

89  {
90  return {
91  std::make_shared<fml::NonOwnedMapping>(
92  impeller_entity_shaders_gles_data,
93  impeller_entity_shaders_gles_length),
94  std::make_shared<fml::NonOwnedMapping>(
95  impeller_fixtures_shaders_gles_data,
96  impeller_fixtures_shaders_gles_length),
97  std::make_shared<fml::NonOwnedMapping>(
98  impeller_imgui_shaders_gles_data, impeller_imgui_shaders_gles_length),
99  std::make_shared<fml::NonOwnedMapping>(
100  impeller_scene_shaders_gles_data, impeller_scene_shaders_gles_length),
101  };
102 }

Referenced by impeller::PlaygroundImplMTL::PlaygroundImplMTL(), and impeller::PlaygroundImplVK::PlaygroundImplVK().

◆ SortUniforms()

std::vector< spirv_cross::ID > impeller::SortUniforms ( const spirv_cross::ParsedIR *  ir,
const spirv_cross::Compiler *  compiler,
std::optional< spirv_cross::SPIRType::BaseType >  type_filter = std::nullopt,
bool  include = true 
)

Sorts uniform declarations in an IR according to decoration order.

The [type_filter] may be optionally supplied to limit which types are returned The [include] value can be set to false change this filter to exclude instead of include.

Definition at line 9 of file uniform_sorter.cc.

13  {
14  // Sort the IR so that the uniforms are in declaration order.
15  std::vector<spirv_cross::ID> uniforms;
16  ir->for_each_typed_id<spirv_cross::SPIRVariable>(
17  [&](uint32_t, const spirv_cross::SPIRVariable& var) {
18  if (var.storage != spv::StorageClassUniformConstant) {
19  return;
20  }
21  const auto type = compiler->get_type(var.basetype);
22  if (!type_filter.has_value() ||
23  (include && type_filter.value() == type.basetype) ||
24  (!include && type_filter.value() != type.basetype)) {
25  uniforms.push_back(var.self);
26  }
27  });
28 
29  auto compare_locations = [&ir](spirv_cross::ID id1, spirv_cross::ID id2) {
30  auto& flags1 = ir->get_decoration_bitset(id1);
31  auto& flags2 = ir->get_decoration_bitset(id2);
32  // Put the uniforms with no location after the ones that have a location.
33  if (!flags1.get(spv::Decoration::DecorationLocation)) {
34  return false;
35  }
36  if (!flags2.get(spv::Decoration::DecorationLocation)) {
37  return true;
38  }
39  // Sort in increasing order of location.
40  return ir->get_decoration(id1, spv::Decoration::DecorationLocation) <
41  ir->get_decoration(id2, spv::Decoration::DecorationLocation);
42  };
43  std::sort(uniforms.begin(), uniforms.end(), compare_locations);
44 
45  return uniforms;
46 }

◆ SPrintF()

std::string impeller::SPrintF ( const char *  format,
  ... 
)

Definition at line 12 of file strings.cc.

12  {
13  std::string ret_val;
14  va_list list;
15  va_list list2;
16  va_start(list, format);
17  va_copy(list2, list);
18  if (auto string_length = ::vsnprintf(nullptr, 0, format, list);
19  string_length >= 0) {
20  auto buffer = reinterpret_cast<char*>(::malloc(string_length + 1));
21  ::vsnprintf(buffer, string_length + 1, format, list2);
22  ret_val = std::string{buffer, static_cast<size_t>(string_length)};
23  ::free(buffer);
24  }
25  va_end(list2);
26  va_end(list);
27  return ret_val;
28 }

Referenced by impeller::BlitPass::AddCopy(), AdvancedBlend(), ColorToString(), CreateGradientTexture(), impeller::RenderTarget::CreateOffscreen(), impeller::RenderTarget::CreateOffscreenMSAA(), CreateTextureForDecompressedImage(), DepthAttachmentToString(), impeller::FilterContentsFilterInput::GetSnapshot(), impeller::ContentsFilterInput::GetSnapshot(), ImGui_ImplImpeller_RenderDrawData(), impeller::ComputePipelineBuilder< ComputeShader_ >::InitializePipelineDescriptorDefaults(), impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::InitializePipelineDescriptorDefaults(), LinkProgram(), impeller::ContentContext::MakeSubpass(), PipelineBlend(), impeller::AtlasContents::Render(), impeller::ComputePass::SetLabel(), impeller::BlitPass::SetLabel(), impeller::RenderPass::SetLabel(), impeller::RenderTarget::SetupStencilAttachment(), impeller::testing::TEST(), and impeller::RenderTarget::ToString().

◆ StencilAttachmentToString()

std::string impeller::StencilAttachmentToString ( const StencilAttachment &  stencil)

Definition at line 137 of file formats.cc.

137  {
138  std::stringstream stream;
139  stream << AttachmentToString(stencil) << ",";
140  stream << "ClearStencil=" << stencil.clear_stencil;
141  return stream.str();
142 }

References AttachmentToString(), and impeller::StencilAttachment::clear_stencil.

Referenced by impeller::RenderTarget::ToString().

◆ StorageModeToString()

constexpr const char* impeller::StorageModeToString ( StorageMode  mode)
constexpr

Definition at line 55 of file formats.h.

55  {
56  switch (mode) {
57  case StorageMode::kHostVisible:
58  return "HostVisible";
59  case StorageMode::kDevicePrivate:
60  return "DevicePrivate";
61  case StorageMode::kDeviceTransient:
62  return "DeviceTransient";
63  }
64  FML_UNREACHABLE();
65 }

References kDevicePrivate, kDeviceTransient, and kHostVisible.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK(), and TextureDescriptorToString().

◆ StoreActionNeedsResolveTexture()

constexpr bool impeller::StoreActionNeedsResolveTexture ( StoreAction  action)
constexpr

Definition at line 15 of file formats.cc.

15  {
16  switch (action) {
17  case StoreAction::kDontCare:
18  case StoreAction::kStore:
19  return false;
20  case StoreAction::kMultisampleResolve:
21  case StoreAction::kStoreAndMultisampleResolve:
22  return true;
23  }
24 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by impeller::Attachment::IsValid().

◆ StoreActionToString()

constexpr const char* impeller::StoreActionToString ( StoreAction  action)
constexpr

Definition at line 200 of file formats.h.

200  {
201  switch (action) {
202  case StoreAction::kDontCare:
203  return "DontCare";
204  case StoreAction::kStore:
205  return "Store";
206  case StoreAction::kMultisampleResolve:
207  return "MultisampleResolve";
208  case StoreAction::kStoreAndMultisampleResolve:
209  return "StoreAndMultisampleResolve";
210  }
211 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by AttachmentToString().

◆ StripPrefix()

std::string impeller::StripPrefix ( const std::string &  string,
const std::string &  to_strip 
)

Definition at line 42 of file strings.cc.

43  {
44  if (!HasPrefix(string, to_strip)) {
45  return string;
46  }
47  return string.substr(to_strip.length());
48 }

References HasPrefix().

Referenced by DetermineVersion().

◆ SupportsLossyTextureCompression()

static bool impeller::SupportsLossyTextureCompression ( id< MTLDevice >  device)
static

Definition at line 81 of file allocator_mtl.mm.

81  {
82 #ifdef FML_OS_IOS_SIMULATOR
83  return false;
84 #else
85  if (@available(macOS 10.15, iOS 13, tvOS 13, *)) {
86  return [device supportsFamily:MTLGPUFamilyApple8];
87  }
88  return false;
89 #endif
90 }

◆ Tessellate()

IMPELLER_API struct Vertices * impeller::Tessellate ( PathBuilder *  builder,
int  fill_type,
Scalar  tolerance 
)

Definition at line 40 of file tessellator.cc.

42  {
43  auto path = builder->CopyPath(static_cast<FillType>(fill_type));
44  auto polyline = path.CreatePolyline(tolerance);
45  std::vector<float> points;
46  if (Tessellator{}.Tessellate(
47  path.GetFillType(), polyline,
48  [&points](const float* vertices, size_t vertices_count,
49  const uint16_t* indices, size_t indices_count) {
50  // Results are expected to be re-duplicated.
51  std::vector<Point> raw_points;
52  for (auto i = 0u; i < vertices_count * 2; i += 2) {
53  raw_points.emplace_back(Point{vertices[i], vertices[i + 1]});
54  }
55  for (auto i = 0u; i < indices_count; i++) {
56  auto point = raw_points[indices[i]];
57  points.push_back(point.x);
58  points.push_back(point.y);
59  }
60  return true;
61  }) != Tessellator::Result::kSuccess) {
62  return nullptr;
63  }
64 
65  Vertices* vertices = new Vertices();
66  vertices->points = new float[points.size()];
67  if (!vertices->points) {
68  return nullptr;
69  }
70  vertices->length = points.size();
71  std::copy(points.begin(), points.end(), vertices->points);
72  return vertices;
73 }

References impeller::PathBuilder::CopyPath(), impeller::Path::CreatePolyline(), and impeller::Tessellator::Tessellate().

◆ TessellateConvex()

std::pair< std::vector< Point >, std::vector< uint16_t > > impeller::TessellateConvex ( Path::Polyline  polyline)

Given a convex polyline, create a triangle fan structure.

Given a polyline created from a convex filled path, perform a tessellation.

Definition at line 19 of file geometry.cc.

20  {
21  std::vector<Point> output;
22  std::vector<uint16_t> indices;
23 
24  for (auto j = 0u; j < polyline.contours.size(); j++) {
25  auto [start, end] = polyline.GetContourPointBounds(j);
26  auto center = polyline.points[start];
27 
28  // Some polygons will not self close and an additional triangle
29  // must be inserted, others will self close and we need to avoid
30  // inserting an extra triangle.
31  if (polyline.points[end - 1] == polyline.points[start]) {
32  end--;
33  }
34  output.emplace_back(center);
35  output.emplace_back(polyline.points[start + 1]);
36 
37  for (auto i = start + 2; i < end; i++) {
38  const auto& point_b = polyline.points[i];
39  output.emplace_back(point_b);
40 
41  indices.emplace_back(0);
42  indices.emplace_back(i - 1);
43  indices.emplace_back(i);
44  }
45  }
46  return std::make_pair(output, indices);
47 }

References impeller::Path::Polyline::contours, impeller::Path::Polyline::GetContourPointBounds(), and impeller::Path::Polyline::points.

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

◆ TextureDescriptorToString()

std::string impeller::TextureDescriptorToString ( const TextureDescriptor &  desc)

Definition at line 11 of file texture_descriptor.cc.

11  {
12  std::stringstream stream;
13  stream << "StorageMode=" << StorageModeToString(desc.storage_mode) << ",";
14  stream << "Type=" << TextureTypeToString(desc.type) << ",";
15  stream << "Format=" << PixelFormatToString(desc.format) << ",";
16  stream << "Size=" << desc.size << ",";
17  stream << "MipCount=" << desc.mip_count << ",";
18  stream << "SampleCount=" << static_cast<size_t>(desc.sample_count) << ",";
19  stream << "Compression=" << CompressionTypeToString(desc.compression_type);
20  return stream.str();
21 }

References impeller::TextureDescriptor::compression_type, CompressionTypeToString(), impeller::TextureDescriptor::format, impeller::TextureDescriptor::mip_count, PixelFormatToString(), impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, StorageModeToString(), TextureTypeToString(), and impeller::TextureDescriptor::type.

Referenced by AttachmentToString().

◆ TextureTypeToString()

constexpr const char* impeller::TextureTypeToString ( TextureType  type)
constexpr

Definition at line 243 of file formats.h.

243  {
244  switch (type) {
245  case TextureType::kTexture2D:
246  return "Texture2D";
247  case TextureType::kTexture2DMultisample:
248  return "Texture2DMultisample";
249  case TextureType::kTextureCube:
250  return "TextureCube";
251  case TextureType::kTextureExternalOES:
252  return "TextureExternalOES";
253  }
254  FML_UNREACHABLE();
255 }

References kTexture2D, kTexture2DMultisample, kTextureCube, and kTextureExternalOES.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK(), impeller::RenderTarget::IsValid(), and TextureDescriptorToString().

◆ TextureUsageIsRenderTarget()

constexpr bool impeller::TextureUsageIsRenderTarget ( TextureUsageMask  mask)
constexpr

Definition at line 283 of file formats.h.

283  {
284  return static_cast<TextureUsageMask>(TextureUsage::kRenderTarget) & mask;
285 }

References kRenderTarget.

◆ TextureUsageMaskToString()

std::string impeller::TextureUsageMaskToString ( TextureUsageMask  mask)

Definition at line 81 of file formats.cc.

81  {
82  std::vector<TextureUsage> usages;
83  if (mask & static_cast<TextureUsageMask>(TextureUsage::kShaderRead)) {
84  usages.push_back(TextureUsage::kShaderRead);
85  }
86  if (mask & static_cast<TextureUsageMask>(TextureUsage::kShaderWrite)) {
87  usages.push_back(TextureUsage::kShaderWrite);
88  }
89  if (mask & static_cast<TextureUsageMask>(TextureUsage::kRenderTarget)) {
90  usages.push_back(TextureUsage::kRenderTarget);
91  }
92  std::stringstream stream;
93  stream << "{ ";
94  for (size_t i = 0; i < usages.size(); i++) {
95  stream << TextureUsageToString(usages[i]);
96  if (i != usages.size() - 1u) {
97  stream << ", ";
98  }
99  }
100  stream << " }";
101  return stream.str();
102 }

References kRenderTarget, kShaderRead, kShaderWrite, and TextureUsageToString().

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ TextureUsageToString()

constexpr const char* impeller::TextureUsageToString ( TextureUsage  usage)
constexpr

Definition at line 287 of file formats.h.

287  {
288  switch (usage) {
289  case TextureUsage::kUnknown:
290  return "Unknown";
291  case TextureUsage::kShaderRead:
292  return "ShaderRead";
293  case TextureUsage::kShaderWrite:
294  return "ShaderWrite";
295  case TextureUsage::kRenderTarget:
296  return "RenderTarget";
297  }
298  FML_UNREACHABLE();
299 }

References kRenderTarget, kShaderRead, kShaderWrite, and kUnknown.

Referenced by TextureUsageMaskToString().

◆ TileModeToAddressMode()

static std::optional<SamplerAddressMode> impeller::TileModeToAddressMode ( Entity::TileMode  tile_mode,
const Capabilities &  capabilities 
)
static

Definition at line 19 of file tiled_texture_contents.cc.

21  {
22  switch (tile_mode) {
23  case Entity::TileMode::kClamp:
24  return SamplerAddressMode::kClampToEdge;
25  break;
26  case Entity::TileMode::kMirror:
27  return SamplerAddressMode::kMirror;
28  break;
29  case Entity::TileMode::kRepeat:
30  return SamplerAddressMode::kRepeat;
31  break;
32  case Entity::TileMode::kDecal:
33  if (capabilities.SupportsDecalSamplerAddressMode()) {
34  return SamplerAddressMode::kDecal;
35  }
36  return std::nullopt;
37  }
38 }

References impeller::Entity::kClamp, kClampToEdge, impeller::Entity::kDecal, kDecal, impeller::Entity::kMirror, kMirror, impeller::Entity::kRepeat, kRepeat, and impeller::Capabilities::SupportsDecalSamplerAddressMode().

◆ ToAddressMode()

static GLint impeller::ToAddressMode ( SamplerAddressMode  mode)
static

Definition at line 56 of file sampler_gles.cc.

56  {
57  switch (mode) {
58  case SamplerAddressMode::kClampToEdge:
59  return GL_CLAMP_TO_EDGE;
60  case SamplerAddressMode::kRepeat:
61  return GL_REPEAT;
62  case SamplerAddressMode::kMirror:
63  return GL_MIRRORED_REPEAT;
64  case SamplerAddressMode::kDecal:
65  break; // Unsupported.
66  }
67  FML_UNREACHABLE();
68 }

References kClampToEdge, kDecal, kMirror, and kRepeat.

Referenced by impeller::SamplerGLES::ConfigureBoundTexture().

◆ ToArrayLayerCount()

constexpr uint32_t impeller::ToArrayLayerCount ( TextureType  type)
constexpr

Definition at line 591 of file formats_vk.h.

591  {
592  switch (type) {
593  case TextureType::kTexture2D:
594  case TextureType::kTexture2DMultisample:
595  return 1u;
596  case TextureType::kTextureCube:
597  return 6u;
598  case TextureType::kTextureExternalOES:
599  VALIDATION_LOG
600  << "kTextureExternalOES can not be used with the Vulkan backend.";
601  }
602  FML_UNREACHABLE();
603 }

References kTexture2D, kTexture2DMultisample, kTextureCube, kTextureExternalOES, and VALIDATION_LOG.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK(), impeller::TextureSourceVK::SetLayout(), and impeller::SwapchainImageVK::SwapchainImageVK().

◆ ToAttachmentPoint()

static GLenum impeller::ToAttachmentPoint ( TextureGLES::AttachmentPoint  point)
static

Definition at line 497 of file texture_gles.cc.

497  {
498  switch (point) {
499  case TextureGLES::AttachmentPoint::kColor0:
500  return GL_COLOR_ATTACHMENT0;
501  case TextureGLES::AttachmentPoint::kDepth:
502  return GL_DEPTH_ATTACHMENT;
503  case TextureGLES::AttachmentPoint::kStencil:
504  return GL_STENCIL_ATTACHMENT;
505  }
506 }

References impeller::TextureGLES::kColor0, impeller::TextureGLES::kDepth, and impeller::TextureGLES::kStencil.

Referenced by impeller::TextureGLES::SetAsFramebufferAttachment().

◆ ToBlendFactor()

constexpr GLenum impeller::ToBlendFactor ( BlendFactor  factor)
constexpr

Definition at line 90 of file formats_gles.h.

90  {
91  switch (factor) {
92  case BlendFactor::kZero:
93  return GL_ZERO;
94  case BlendFactor::kOne:
95  return GL_ONE;
96  case BlendFactor::kSourceColor:
97  return GL_SRC_COLOR;
98  case BlendFactor::kOneMinusSourceColor:
99  return GL_ONE_MINUS_SRC_COLOR;
100  case BlendFactor::kSourceAlpha:
101  return GL_SRC_ALPHA;
102  case BlendFactor::kOneMinusSourceAlpha:
103  return GL_ONE_MINUS_SRC_ALPHA;
104  case BlendFactor::kDestinationColor:
105  return GL_DST_COLOR;
106  case BlendFactor::kOneMinusDestinationColor:
107  return GL_ONE_MINUS_DST_COLOR;
108  case BlendFactor::kDestinationAlpha:
109  return GL_DST_ALPHA;
110  case BlendFactor::kOneMinusDestinationAlpha:
111  return GL_ONE_MINUS_DST_ALPHA;
112  case BlendFactor::kSourceAlphaSaturated:
113  return GL_SRC_ALPHA_SATURATE;
114  case BlendFactor::kBlendColor:
115  return GL_CONSTANT_COLOR;
116  case BlendFactor::kOneMinusBlendColor:
117  return GL_ONE_MINUS_CONSTANT_COLOR;
118  case BlendFactor::kBlendAlpha:
119  return GL_CONSTANT_ALPHA;
120  case BlendFactor::kOneMinusBlendAlpha:
121  return GL_ONE_MINUS_CONSTANT_ALPHA;
122  }
123  FML_UNREACHABLE();
124 }

References kBlendAlpha, kBlendColor, kDestinationAlpha, kDestinationColor, kOne, kOneMinusBlendAlpha, kOneMinusBlendColor, kOneMinusDestinationAlpha, kOneMinusDestinationColor, kOneMinusSourceAlpha, kOneMinusSourceColor, kSourceAlpha, kSourceAlphaSaturated, kSourceColor, and kZero.

Referenced by ConfigureBlending().

◆ ToBlendMode()

static BlendMode impeller::ToBlendMode ( flutter::DlBlendMode  mode)
static

Definition at line 55 of file dl_dispatcher.cc.

55  {
56  switch (mode) {
57  case flutter::DlBlendMode::kClear:
58  return BlendMode::kClear;
59  case flutter::DlBlendMode::kSrc:
60  return BlendMode::kSource;
61  case flutter::DlBlendMode::kDst:
62  return BlendMode::kDestination;
63  case flutter::DlBlendMode::kSrcOver:
64  return BlendMode::kSourceOver;
65  case flutter::DlBlendMode::kDstOver:
66  return BlendMode::kDestinationOver;
67  case flutter::DlBlendMode::kSrcIn:
68  return BlendMode::kSourceIn;
69  case flutter::DlBlendMode::kDstIn:
70  return BlendMode::kDestinationIn;
71  case flutter::DlBlendMode::kSrcOut:
72  return BlendMode::kSourceOut;
73  case flutter::DlBlendMode::kDstOut:
74  return BlendMode::kDestinationOut;
75  case flutter::DlBlendMode::kSrcATop:
76  return BlendMode::kSourceATop;
77  case flutter::DlBlendMode::kDstATop:
78  return BlendMode::kDestinationATop;
79  case flutter::DlBlendMode::kXor:
80  return BlendMode::kXor;
81  case flutter::DlBlendMode::kPlus:
82  return BlendMode::kPlus;
83  case flutter::DlBlendMode::kModulate:
84  return BlendMode::kModulate;
85  case flutter::DlBlendMode::kScreen:
86  return BlendMode::kScreen;
87  case flutter::DlBlendMode::kOverlay:
88  return BlendMode::kOverlay;
89  case flutter::DlBlendMode::kDarken:
90  return BlendMode::kDarken;
91  case flutter::DlBlendMode::kLighten:
92  return BlendMode::kLighten;
93  case flutter::DlBlendMode::kColorDodge:
94  return BlendMode::kColorDodge;
95  case flutter::DlBlendMode::kColorBurn:
96  return BlendMode::kColorBurn;
97  case flutter::DlBlendMode::kHardLight:
98  return BlendMode::kHardLight;
99  case flutter::DlBlendMode::kSoftLight:
100  return BlendMode::kSoftLight;
101  case flutter::DlBlendMode::kDifference:
102  return BlendMode::kDifference;
103  case flutter::DlBlendMode::kExclusion:
104  return BlendMode::kExclusion;
105  case flutter::DlBlendMode::kMultiply:
106  return BlendMode::kMultiply;
107  case flutter::DlBlendMode::kHue:
108  return BlendMode::kHue;
109  case flutter::DlBlendMode::kSaturation:
110  return BlendMode::kSaturation;
111  case flutter::DlBlendMode::kColor:
112  return BlendMode::kColor;
113  case flutter::DlBlendMode::kLuminosity:
114  return BlendMode::kLuminosity;
115  }
116  FML_UNREACHABLE();
117 }

References kClear, kColor, kColorBurn, kColorDodge, kDarken, kDestination, kDestinationATop, kDestinationIn, kDestinationOut, kDestinationOver, kDifference, kExclusion, kHardLight, kHue, kLighten, kLuminosity, kModulate, kMultiply, kOverlay, kPlus, kSaturation, kScreen, kSoftLight, kSource, kSourceATop, kSourceIn, kSourceOut, kSourceOver, and kXor.

Referenced by impeller::DlDispatcher::drawAtlas(), impeller::DlDispatcher::drawColor(), impeller::DlDispatcher::drawVertices(), impeller::DlDispatcher::setBlendMode(), and ToColorFilter().

◆ ToBlendOperation()

constexpr GLenum impeller::ToBlendOperation ( BlendOperation  op)
constexpr

Definition at line 126 of file formats_gles.h.

126  {
127  switch (op) {
128  case BlendOperation::kAdd:
129  return GL_FUNC_ADD;
130  case BlendOperation::kSubtract:
131  return GL_FUNC_SUBTRACT;
132  case BlendOperation::kReverseSubtract:
133  return GL_FUNC_REVERSE_SUBTRACT;
134  }
135  FML_UNREACHABLE();
136 }

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ConfigureBlending().

◆ ToBlurStyle()

static FilterContents::BlurStyle impeller::ToBlurStyle ( flutter::DlBlurStyle  blur_style)
static

Definition at line 506 of file dl_dispatcher.cc.

506  {
507  switch (blur_style) {
508  case flutter::DlBlurStyle::kNormal:
509  return FilterContents::BlurStyle::kNormal;
510  case flutter::DlBlurStyle::kSolid:
511  return FilterContents::BlurStyle::kSolid;
512  case flutter::DlBlurStyle::kOuter:
513  return FilterContents::BlurStyle::kOuter;
514  case flutter::DlBlurStyle::kInner:
515  return FilterContents::BlurStyle::kInner;
516  }
517 }

References impeller::FilterContents::kInner, impeller::FilterContents::kNormal, impeller::FilterContents::kOuter, and impeller::FilterContents::kSolid.

Referenced by impeller::DlDispatcher::setMaskFilter().

◆ ToClipOperation()

static Entity::ClipOperation impeller::ToClipOperation ( flutter::DlCanvas::ClipOp  clip_op)
static

Definition at line 726 of file dl_dispatcher.cc.

727  {
728  switch (clip_op) {
729  case flutter::DlCanvas::ClipOp::kDifference:
730  return Entity::ClipOperation::kDifference;
731  case flutter::DlCanvas::ClipOp::kIntersect:
732  return Entity::ClipOperation::kIntersect;
733  }
734 }

References impeller::Entity::kDifference, and impeller::Entity::kIntersect.

Referenced by impeller::DlDispatcher::clipPath(), impeller::DlDispatcher::clipRect(), and impeller::DlDispatcher::clipRRect().

◆ ToColorFilter()

static std::shared_ptr<ColorFilter> impeller::ToColorFilter ( const flutter::DlColorFilter *  filter)
static

Definition at line 458 of file dl_dispatcher.cc.

459  {
460  if (filter == nullptr) {
461  return nullptr;
462  }
463  switch (filter->type()) {
464  case flutter::DlColorFilterType::kBlend: {
465  auto dl_blend = filter->asBlend();
466  auto blend_mode = ToBlendMode(dl_blend->mode());
467  auto color = skia_conversions::ToColor(dl_blend->color());
468  return ColorFilter::MakeBlend(blend_mode, color);
469  }
470  case flutter::DlColorFilterType::kMatrix: {
471  const flutter::DlMatrixColorFilter* dl_matrix = filter->asMatrix();
472  impeller::ColorMatrix color_matrix;
473  dl_matrix->get_matrix(color_matrix.array);
474  return ColorFilter::MakeMatrix(color_matrix);
475  }
476  case flutter::DlColorFilterType::kSrgbToLinearGamma:
477  return ColorFilter::MakeSrgbToLinear();
478  case flutter::DlColorFilterType::kLinearToSrgbGamma:
479  return ColorFilter::MakeLinearToSrgb();
480  }
481  return nullptr;
482 }

References impeller::ColorMatrix::array, impeller::ColorFilter::MakeBlend(), impeller::ColorFilter::MakeLinearToSrgb(), impeller::ColorFilter::MakeMatrix(), impeller::ColorFilter::MakeSrgbToLinear(), ToBlendMode(), and impeller::skia_conversions::ToColor().

Referenced by impeller::DlDispatcher::setColorFilter(), and ToImageFilter().

◆ ToColors()

static std::vector<Color> impeller::ToColors ( const flutter::DlColor  colors[],
int  count 
)
static

Definition at line 263 of file dl_dispatcher.cc.

263  {
264  auto result = std::vector<Color>();
265  if (colors == nullptr) {
266  return result;
267  }
268  for (int i = 0; i < count; i++) {
269  result.push_back(skia_conversions::ToColor(colors[i]));
270  }
271  return result;
272 }

References impeller::skia_conversions::ToColor().

Referenced by impeller::DlDispatcher::drawAtlas().

◆ ToColorSourceType()

static std::optional<ColorSource::Type> impeller::ToColorSourceType ( flutter::DlColorSourceType  type)
static

Definition at line 274 of file dl_dispatcher.cc.

275  {
276  switch (type) {
277  case flutter::DlColorSourceType::kColor:
278  return ColorSource::Type::kColor;
279  case flutter::DlColorSourceType::kImage:
280  return ColorSource::Type::kImage;
281  case flutter::DlColorSourceType::kLinearGradient:
282  return ColorSource::Type::kLinearGradient;
283  case flutter::DlColorSourceType::kRadialGradient:
284  return ColorSource::Type::kRadialGradient;
285  case flutter::DlColorSourceType::kConicalGradient:
286  return ColorSource::Type::kConicalGradient;
287  case flutter::DlColorSourceType::kSweepGradient:
288  return ColorSource::Type::kSweepGradient;
289  case flutter::DlColorSourceType::kRuntimeEffect:
290  return ColorSource::Type::kRuntimeEffect;
291 #ifdef IMPELLER_ENABLE_3D
292  case flutter::DlColorSourceType::kScene:
293  return ColorSource::Type::kScene;
294 #endif // IMPELLER_ENABLE_3D
295  }
296 }

References kColor, impeller::ColorSource::kColor, impeller::ColorSource::kConicalGradient, impeller::ColorSource::kImage, impeller::ColorSource::kLinearGradient, impeller::ColorSource::kRadialGradient, impeller::ColorSource::kRuntimeEffect, impeller::ColorSource::kScene, and impeller::ColorSource::kSweepGradient.

Referenced by impeller::DlDispatcher::setColorSource().

◆ ToColumn()

static constexpr int impeller::ToColumn ( size_t  index)
staticconstexpr

Definition at line 82 of file archive_statement.cc.

82  {
83  /*
84  * sqlite columns begin from 0
85  */
86  return static_cast<int>(index);
87 }

Referenced by impeller::ArchiveStatement::ReadValue().

◆ ToCommitResult()

static CommandBuffer::Status impeller::ToCommitResult ( MTLCommandBufferStatus  status)
static

Definition at line 149 of file command_buffer_mtl.mm.

149  {
150  switch (status) {
151  case MTLCommandBufferStatusCompleted:
152  return CommandBufferMTL::Status::kCompleted;
153  case MTLCommandBufferStatusEnqueued:
154  return CommandBufferMTL::Status::kPending;
155  default:
156  break;
157  }
158  return CommandBufferMTL::Status::kError;
159 }

◆ ToCompareFunction()

constexpr GLenum impeller::ToCompareFunction ( CompareFunction  func)
constexpr

Definition at line 68 of file formats_gles.h.

68  {
69  switch (func) {
70  case CompareFunction::kNever:
71  return GL_NEVER;
72  case CompareFunction::kAlways:
73  return GL_ALWAYS;
74  case CompareFunction::kLess:
75  return GL_LESS;
76  case CompareFunction::kEqual:
77  return GL_EQUAL;
78  case CompareFunction::kLessEqual:
79  return GL_LEQUAL;
80  case CompareFunction::kGreater:
81  return GL_GREATER;
82  case CompareFunction::kNotEqual:
83  return GL_NOTEQUAL;
84  case CompareFunction::kGreaterEqual:
85  return GL_GEQUAL;
86  }
87  FML_UNREACHABLE();
88 }

References kAlways, kEqual, kGreater, kGreaterEqual, kLess, kLessEqual, kNever, and kNotEqual.

Referenced by ConfigureStencil(), and EncodeCommandsInReactor().

◆ ToDebugIdentifier()

static std::optional<GLenum> impeller::ToDebugIdentifier ( DebugResourceType  type)
static

Definition at line 243 of file proc_table_gles.cc.

243  {
244  switch (type) {
245  case DebugResourceType::kTexture:
246  return GL_TEXTURE;
247  case DebugResourceType::kBuffer:
248  return GL_BUFFER_KHR;
249  case DebugResourceType::kProgram:
250  return GL_PROGRAM_KHR;
251  case DebugResourceType::kShader:
252  return GL_SHADER_KHR;
253  case DebugResourceType::kRenderBuffer:
254  return GL_RENDERBUFFER;
255  case DebugResourceType::kFrameBuffer:
256  return GL_FRAMEBUFFER;
257  }
258  FML_UNREACHABLE();
259 }

References kBuffer, kFrameBuffer, kProgram, kRenderBuffer, kShader, and kTexture.

Referenced by impeller::ProcTableGLES::SetDebugLabel().

◆ ToDebugResourceType()

static DebugResourceType impeller::ToDebugResourceType ( HandleType  type)
static

Definition at line 168 of file reactor_gles.cc.

168  {
169  switch (type) {
170  case HandleType::kUnknown:
171  FML_UNREACHABLE();
172  case HandleType::kTexture:
173  return DebugResourceType::kTexture;
174  case HandleType::kBuffer:
175  return DebugResourceType::kBuffer;
176  case HandleType::kProgram:
177  return DebugResourceType::kProgram;
178  case HandleType::kRenderBuffer:
179  return DebugResourceType::kRenderBuffer;
180  case HandleType::kFrameBuffer:
181  return DebugResourceType::kFrameBuffer;
182  }
183  FML_UNREACHABLE();
184 }

References kBuffer, kFrameBuffer, kProgram, kRenderBuffer, kTexture, and kUnknown.

◆ ToFont()

static Font impeller::ToFont ( const SkTextBlobRunIterator &  run)
static

Definition at line 19 of file text_frame_skia.cc.

19  {
20  auto& font = run.font();
21  auto typeface = std::make_shared<TypefaceSkia>(font.refTypefaceOrDefault());
22 
23  SkFontMetrics sk_metrics;
24  font.getMetrics(&sk_metrics);
25 
26  Font::Metrics metrics;
27  metrics.point_size = font.getSize();
28  metrics.embolden = font.isEmbolden();
29  metrics.skewX = font.getSkewX();
30  metrics.scaleX = font.getScaleX();
31 
32  return Font{std::move(typeface), metrics};
33 }

References impeller::Font::Metrics::embolden, impeller::Font::Metrics::point_size, impeller::Font::Metrics::scaleX, and impeller::Font::Metrics::skewX.

Referenced by MakeTextFrameFromTextBlobSkia().

◆ ToHandleType()

HandleType impeller::ToHandleType ( TextureGLES::Type  type)

Definition at line 30 of file texture_gles.cc.

30  {
31  switch (type) {
32  case TextureGLES::Type::kTexture:
33  return HandleType::kTexture;
34  case TextureGLES::Type::kRenderBuffer:
35  // MSAA textures are treated as render buffers.
36  case TextureGLES::Type::kRenderBufferMultisampled:
37  return HandleType::kRenderBuffer;
38  }
39  FML_UNREACHABLE();
40 }

References impeller::TextureGLES::kRenderBuffer, kRenderBuffer, impeller::TextureGLES::kRenderBufferMultisampled, impeller::TextureGLES::kTexture, and kTexture.

◆ ToImageAspectFlags()

constexpr vk::ImageAspectFlags impeller::ToImageAspectFlags ( PixelFormat  format)
constexpr

Definition at line 638 of file formats_vk.h.

638  {
639  switch (format) {
640  case PixelFormat::kUnknown:
641  return {};
642  case PixelFormat::kA8UNormInt:
643  case PixelFormat::kR8UNormInt:
644  case PixelFormat::kR8G8UNormInt:
645  case PixelFormat::kR8G8B8A8UNormInt:
646  case PixelFormat::kR8G8B8A8UNormIntSRGB:
647  case PixelFormat::kB8G8R8A8UNormInt:
648  case PixelFormat::kB8G8R8A8UNormIntSRGB:
649  case PixelFormat::kR32G32B32A32Float:
650  case PixelFormat::kR16G16B16A16Float:
651  case PixelFormat::kB10G10R10XR:
652  case PixelFormat::kB10G10R10XRSRGB:
653  case PixelFormat::kB10G10R10A10XR:
654  return vk::ImageAspectFlagBits::eColor;
655  case PixelFormat::kS8UInt:
656  return vk::ImageAspectFlagBits::eStencil;
657  case PixelFormat::kD24UnormS8Uint:
658  case PixelFormat::kD32FloatS8UInt:
659  return vk::ImageAspectFlagBits::eDepth |
660  vk::ImageAspectFlagBits::eStencil;
661  }
662  FML_UNREACHABLE();
663 }

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, and kUnknown.

Referenced by impeller::TextureSourceVK::SetLayout().

◆ ToImageFilter()

static std::shared_ptr<ImageFilter> impeller::ToImageFilter ( const flutter::DlImageFilter *  filter)
static

Definition at line 539 of file dl_dispatcher.cc.

540  {
541  if (filter == nullptr) {
542  return nullptr;
543  }
544 
545  switch (filter->type()) {
546  case flutter::DlImageFilterType::kBlur: {
547  auto blur = filter->asBlur();
548  auto sigma_x = Sigma(blur->sigma_x());
549  auto sigma_y = Sigma(blur->sigma_y());
550  auto tile_mode = ToTileMode(blur->tile_mode());
551  return ImageFilter::MakeBlur(
552  sigma_x, sigma_y, FilterContents::BlurStyle::kNormal, tile_mode);
553  }
554  case flutter::DlImageFilterType::kDilate: {
555  auto dilate = filter->asDilate();
556  FML_DCHECK(dilate);
557  if (dilate->radius_x() < 0 || dilate->radius_y() < 0) {
558  return nullptr;
559  }
560  auto radius_x = Radius(dilate->radius_x());
561  auto radius_y = Radius(dilate->radius_y());
562  return ImageFilter::MakeDilate(radius_x, radius_y);
563  }
564  case flutter::DlImageFilterType::kErode: {
565  auto erode = filter->asErode();
566  FML_DCHECK(erode);
567  if (erode->radius_x() < 0 || erode->radius_y() < 0) {
568  return nullptr;
569  }
570  auto radius_x = Radius(erode->radius_x());
571  auto radius_y = Radius(erode->radius_y());
572  return ImageFilter::MakeErode(radius_x, radius_y);
573  }
574  case flutter::DlImageFilterType::kMatrix: {
575  auto matrix_filter = filter->asMatrix();
576  FML_DCHECK(matrix_filter);
577  auto matrix = ToMatrix(matrix_filter->matrix());
578  auto desc = ToSamplerDescriptor(matrix_filter->sampling());
579  return ImageFilter::MakeMatrix(matrix, desc);
580  }
581  case flutter::DlImageFilterType::kCompose: {
582  auto compose = filter->asCompose();
583  FML_DCHECK(compose);
584  auto outer_dl_filter = compose->outer();
585  auto inner_dl_filter = compose->inner();
586  auto outer_filter = ToImageFilter(outer_dl_filter.get());
587  auto inner_filter = ToImageFilter(inner_dl_filter.get());
588  if (!outer_filter) {
589  return inner_filter;
590  }
591  if (!inner_filter) {
592  return outer_filter;
593  }
594  FML_DCHECK(outer_filter && inner_filter);
595 
596  return ImageFilter::MakeCompose(*inner_filter, *outer_filter);
597  }
598  case flutter::DlImageFilterType::kColorFilter: {
599  auto color_filter_image_filter = filter->asColorFilter();
600  FML_DCHECK(color_filter_image_filter);
601  auto color_filter =
602  ToColorFilter(color_filter_image_filter->color_filter().get());
603  if (!color_filter) {
604  return nullptr;
605  }
606  // When color filters are used as image filters, set the color filter's
607  // "absorb opacity" flag to false. For image filters, the snapshot
608  // opacity needs to be deferred until the result of the filter chain is
609  // being blended with the layer.
610  return ImageFilter::MakeFromColorFilter(*color_filter);
611  }
612  case flutter::DlImageFilterType::kLocalMatrix: {
613  auto local_matrix_filter = filter->asLocalMatrix();
614  FML_DCHECK(local_matrix_filter);
615  auto internal_filter = local_matrix_filter->image_filter();
616  FML_DCHECK(internal_filter);
617 
618  auto image_filter = ToImageFilter(internal_filter.get());
619  if (!image_filter) {
620  return nullptr;
621  }
622 
623  auto matrix = ToMatrix(local_matrix_filter->matrix());
624  return ImageFilter::MakeLocalMatrix(matrix, *image_filter);
625  }
626  }
627 }

References impeller::FilterContents::kNormal, impeller::ImageFilter::MakeBlur(), impeller::ImageFilter::MakeCompose(), impeller::ImageFilter::MakeDilate(), impeller::ImageFilter::MakeErode(), impeller::ImageFilter::MakeFromColorFilter(), impeller::ImageFilter::MakeLocalMatrix(), impeller::ImageFilter::MakeMatrix(), ToColorFilter(), ToMatrix(), ToSamplerDescriptor(), and ToTileMode().

Referenced by impeller::DlDispatcher::saveLayer(), and impeller::DlDispatcher::setImageFilter().

◆ ToIndexType()

constexpr GLenum impeller::ToIndexType ( IndexType  type)
constexpr

Definition at line 33 of file formats_gles.h.

33  {
34  switch (type) {
35  case IndexType::kUnknown:
36  case IndexType::kNone:
37  FML_UNREACHABLE();
38  case IndexType::k16bit:
39  return GL_UNSIGNED_SHORT;
40  case IndexType::k32bit:
41  return GL_UNSIGNED_INT;
42  }
43  FML_UNREACHABLE();
44 }

References k16bit, k32bit, kNone, and kUnknown.

Referenced by EncodeCommandsInReactor().

◆ ToMatrix()

static Matrix impeller::ToMatrix ( const SkMatrix &  m)
static

Definition at line 174 of file dl_dispatcher.cc.

174  {
175  return Matrix{
176  // clang-format off
177  m[0], m[3], 0, m[6],
178  m[1], m[4], 0, m[7],
179  0, 0, 1, 0,
180  m[2], m[5], 0, m[8],
181  // clang-format on
182  };
183 }

Referenced by impeller::DlDispatcher::setColorSource(), and ToImageFilter().

◆ ToMode()

constexpr GLenum impeller::ToMode ( PrimitiveType  primitive_type)
constexpr

Definition at line 17 of file formats_gles.h.

17  {
18  switch (primitive_type) {
19  case PrimitiveType::kTriangle:
20  return GL_TRIANGLES;
21  case PrimitiveType::kTriangleStrip:
22  return GL_TRIANGLE_STRIP;
23  case PrimitiveType::kLine:
24  return GL_LINES;
25  case PrimitiveType::kLineStrip:
26  return GL_LINE_STRIP;
27  case PrimitiveType::kPoint:
28  return GL_POINTS;
29  }
30  FML_UNREACHABLE();
31 }

References kLine, kLineStrip, kPoint, kTriangle, and kTriangleStrip.

Referenced by EncodeCommandsInReactor().

◆ ToMTLBlendFactor()

constexpr MTLBlendFactor impeller::ToMTLBlendFactor ( BlendFactor  type)
constexpr

Definition at line 113 of file formats_mtl.h.

113  {
114  switch (type) {
115  case BlendFactor::kZero:
116  return MTLBlendFactorZero;
117  case BlendFactor::kOne:
118  return MTLBlendFactorOne;
119  case BlendFactor::kSourceColor:
120  return MTLBlendFactorSourceColor;
121  case BlendFactor::kOneMinusSourceColor:
122  return MTLBlendFactorOneMinusSourceColor;
123  case BlendFactor::kSourceAlpha:
124  return MTLBlendFactorSourceAlpha;
125  case BlendFactor::kOneMinusSourceAlpha:
126  return MTLBlendFactorOneMinusSourceAlpha;
127  case BlendFactor::kDestinationColor:
128  return MTLBlendFactorDestinationColor;
129  case BlendFactor::kOneMinusDestinationColor:
130  return MTLBlendFactorOneMinusDestinationColor;
131  case BlendFactor::kDestinationAlpha:
132  return MTLBlendFactorDestinationAlpha;
133  case BlendFactor::kOneMinusDestinationAlpha:
134  return MTLBlendFactorOneMinusDestinationAlpha;
135  case BlendFactor::kSourceAlphaSaturated:
136  return MTLBlendFactorSourceAlphaSaturated;
137  case BlendFactor::kBlendColor:
138  return MTLBlendFactorBlendColor;
139  case BlendFactor::kOneMinusBlendColor:
140  return MTLBlendFactorOneMinusBlendColor;
141  case BlendFactor::kBlendAlpha:
142  return MTLBlendFactorBlendAlpha;
143  case BlendFactor::kOneMinusBlendAlpha:
144  return MTLBlendFactorOneMinusBlendAlpha;
145  }
146  return MTLBlendFactorZero;
147 };

References kBlendAlpha, kBlendColor, kDestinationAlpha, kDestinationColor, kOne, kOneMinusBlendAlpha, kOneMinusBlendColor, kOneMinusDestinationAlpha, kOneMinusDestinationColor, kOneMinusSourceAlpha, kOneMinusSourceColor, kSourceAlpha, kSourceAlphaSaturated, kSourceColor, and kZero.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

◆ ToMTLBlendOperation()

constexpr MTLBlendOperation impeller::ToMTLBlendOperation ( BlendOperation  type)
constexpr

Definition at line 196 of file formats_mtl.h.

196  {
197  switch (type) {
198  case BlendOperation::kAdd:
199  return MTLBlendOperationAdd;
200  case BlendOperation::kSubtract:
201  return MTLBlendOperationSubtract;
202  case BlendOperation::kReverseSubtract:
203  return MTLBlendOperationReverseSubtract;
204  }
205  return MTLBlendOperationAdd;
206 };

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

◆ ToMTLClearColor()

MTLClearColor impeller::ToMTLClearColor ( const Color &  color)
inline

Definition at line 370 of file formats_mtl.h.

370  {
371  return MTLClearColorMake(color.red, color.green, color.blue, color.alpha);
372 }

References impeller::Color::alpha, impeller::Color::blue, impeller::Color::green, and impeller::Color::red.

Referenced by ConfigureColorAttachment().

◆ ToMTLColorWriteMask()

constexpr MTLColorWriteMask impeller::ToMTLColorWriteMask ( std::underlying_type_t< ColorWriteMask >  type)
constexpr

Definition at line 208 of file formats_mtl.h.

209  {
210  using UnderlyingType = decltype(type);
211 
212  MTLColorWriteMask mask = MTLColorWriteMaskNone;
213 
214  if (type & static_cast<UnderlyingType>(ColorWriteMask::kRed)) {
215  mask |= MTLColorWriteMaskRed;
216  }
217 
218  if (type & static_cast<UnderlyingType>(ColorWriteMask::kGreen)) {
219  mask |= MTLColorWriteMaskGreen;
220  }
221 
222  if (type & static_cast<UnderlyingType>(ColorWriteMask::kBlue)) {
223  mask |= MTLColorWriteMaskBlue;
224  }
225 
226  if (type & static_cast<UnderlyingType>(ColorWriteMask::kAlpha)) {
227  mask |= MTLColorWriteMaskAlpha;
228  }
229 
230  return mask;
231 };

References kAlpha, kBlue, kGreen, and kRed.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

◆ ToMTLCompareFunction()

constexpr MTLCompareFunction impeller::ToMTLCompareFunction ( CompareFunction  func)
constexpr

Definition at line 233 of file formats_mtl.h.

233  {
234  switch (func) {
235  case CompareFunction::kNever:
236  return MTLCompareFunctionNever;
237  case CompareFunction::kLess:
238  return MTLCompareFunctionLess;
239  case CompareFunction::kEqual:
240  return MTLCompareFunctionEqual;
241  case CompareFunction::kLessEqual:
242  return MTLCompareFunctionLessEqual;
243  case CompareFunction::kGreater:
244  return MTLCompareFunctionGreater;
245  case CompareFunction::kNotEqual:
246  return MTLCompareFunctionNotEqual;
247  case CompareFunction::kGreaterEqual:
248  return MTLCompareFunctionGreaterEqual;
249  case CompareFunction::kAlways:
250  return MTLCompareFunctionAlways;
251  }
252  return MTLCompareFunctionAlways;
253 };

References kAlways, kEqual, kGreater, kGreaterEqual, kLess, kLessEqual, kNever, and kNotEqual.

Referenced by ToMTLDepthStencilDescriptor(), and ToMTLStencilDescriptor().

◆ ToMTLCullMode()

constexpr MTLCullMode impeller::ToMTLCullMode ( CullMode  mode)
constexpr

Definition at line 184 of file formats_mtl.h.

184  {
185  switch (mode) {
186  case CullMode::kNone:
187  return MTLCullModeNone;
188  case CullMode::kBackFace:
189  return MTLCullModeBack;
190  case CullMode::kFrontFace:
191  return MTLCullModeFront;
192  }
193  return MTLCullModeNone;
194 }

References kBackFace, kFrontFace, and kNone.

◆ ToMTLDepthStencilDescriptor()

MTLDepthStencilDescriptor * impeller::ToMTLDepthStencilDescriptor ( std::optional< DepthAttachmentDescriptor >  depth,
std::optional< StencilAttachmentDescriptor >  front,
std::optional< StencilAttachmentDescriptor >  back 
)

Definition at line 54 of file formats_mtl.mm.

57  {
58  if (!depth) {
59  depth = DepthAttachmentDescriptor{
60  // Always pass the depth test.
61  .depth_compare = CompareFunction::kAlways,
62  .depth_write_enabled = false,
63  };
64  }
65 
66  auto des = [[MTLDepthStencilDescriptor alloc] init];
67 
68  // These temporary variables are necessary for clang-tidy (Fuchsia LLVM
69  // version 17.0.0git) to not crash.
70  auto compare_function = ToMTLCompareFunction(depth->depth_compare);
71  auto depth_write_enabled = depth->depth_write_enabled;
72 
73  des.depthCompareFunction = compare_function;
74  des.depthWriteEnabled = depth_write_enabled;
75 
76  if (front.has_value()) {
77  des.frontFaceStencil = ToMTLStencilDescriptor(front.value());
78  }
79  if (back.has_value()) {
80  des.backFaceStencil = ToMTLStencilDescriptor(back.value());
81  }
82 
83  return des;
84 }

References impeller::DepthAttachmentDescriptor::depth_compare, kAlways, ToMTLCompareFunction(), and ToMTLStencilDescriptor().

Referenced by CreateDepthStencilDescriptor().

◆ ToMTLFunctionType()

static MTLFunctionType impeller::ToMTLFunctionType ( ShaderStage  stage)
static

Definition at line 28 of file shader_library_mtl.mm.

28  {
29  switch (stage) {
30  case ShaderStage::kVertex:
31  return MTLFunctionTypeVertex;
32  case ShaderStage::kFragment:
33  return MTLFunctionTypeFragment;
34  case ShaderStage::kUnknown:
35  case ShaderStage::kTessellationControl:
36  case ShaderStage::kTessellationEvaluation:
37  case ShaderStage::kCompute:
38  return MTLFunctionTypeKernel;
39  }
40  FML_UNREACHABLE();
41 }

References kCompute, kFragment, kTessellationControl, kTessellationEvaluation, kUnknown, and kVertex.

◆ ToMTLIndexType()

constexpr MTLIndexType impeller::ToMTLIndexType ( IndexType  type)
constexpr

Definition at line 175 of file formats_mtl.h.

175  {
176  switch (type) {
177  case IndexType::k16bit:
178  return MTLIndexTypeUInt16;
179  default:
180  return MTLIndexTypeUInt32;
181  }
182 }

References k16bit.

◆ ToMTLLoadAction()

constexpr MTLLoadAction impeller::ToMTLLoadAction ( LoadAction  action)
constexpr

Definition at line 277 of file formats_mtl.h.

277  {
278  switch (action) {
279  case LoadAction::kDontCare:
280  return MTLLoadActionDontCare;
281  case LoadAction::kLoad:
282  return MTLLoadActionLoad;
283  case LoadAction::kClear:
284  return MTLLoadActionClear;
285  }
286 
287  return MTLLoadActionDontCare;
288 }

References kClear, kDontCare, and kLoad.

Referenced by ConfigureAttachment().

◆ ToMTLPixelFormat()

constexpr MTLPixelFormat impeller::ToMTLPixelFormat ( PixelFormat  format)
constexpr

Definition at line 75 of file formats_mtl.h.

75  {
76  switch (format) {
77  case PixelFormat::kUnknown:
78  return MTLPixelFormatInvalid;
79  case PixelFormat::kA8UNormInt:
80  return MTLPixelFormatA8Unorm;
81  case PixelFormat::kR8UNormInt:
82  return MTLPixelFormatR8Unorm;
83  case PixelFormat::kR8G8UNormInt:
84  return MTLPixelFormatRG8Unorm;
85  case PixelFormat::kB8G8R8A8UNormInt:
86  return MTLPixelFormatBGRA8Unorm;
87  case PixelFormat::kB8G8R8A8UNormIntSRGB:
88  return MTLPixelFormatBGRA8Unorm_sRGB;
89  case PixelFormat::kR8G8B8A8UNormInt:
90  return MTLPixelFormatRGBA8Unorm;
91  case PixelFormat::kR8G8B8A8UNormIntSRGB:
92  return MTLPixelFormatRGBA8Unorm_sRGB;
93  case PixelFormat::kR32G32B32A32Float:
94  return MTLPixelFormatRGBA32Float;
95  case PixelFormat::kR16G16B16A16Float:
96  return MTLPixelFormatRGBA16Float;
97  case PixelFormat::kS8UInt:
98  return MTLPixelFormatStencil8;
99  case PixelFormat::kD24UnormS8Uint:
100  return SafeMTLPixelFormatDepth24Unorm_Stencil8();
101  case PixelFormat::kD32FloatS8UInt:
102  return MTLPixelFormatDepth32Float_Stencil8;
103  case PixelFormat::kB10G10R10XRSRGB:
104  return SafeMTLPixelFormatBGR10_XR_sRGB();
105  case PixelFormat::kB10G10R10XR:
106  return SafeMTLPixelFormatBGR10_XR();
107  case PixelFormat::kB10G10R10A10XR:
108  return SafeMTLPixelFormatBGRA10_XR();
109  }
110  return MTLPixelFormatInvalid;
111 };

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, kUnknown, SafeMTLPixelFormatBGR10_XR(), SafeMTLPixelFormatBGR10_XR_sRGB(), SafeMTLPixelFormatBGRA10_XR(), and SafeMTLPixelFormatDepth24Unorm_Stencil8().

Referenced by GetMTLRenderPipelineDescriptor(), impeller::PlaygroundImplMTL::PlaygroundImplMTL(), ToMTLRenderPipelineColorAttachmentDescriptor(), and ToMTLTextureDescriptor().

◆ ToMTLPrimitiveType()

constexpr MTLPrimitiveType impeller::ToMTLPrimitiveType ( PrimitiveType  type)
constexpr

Definition at line 149 of file formats_mtl.h.

149  {
150  switch (type) {
151  case PrimitiveType::kTriangle:
152  return MTLPrimitiveTypeTriangle;
153  case PrimitiveType::kTriangleStrip:
154  return MTLPrimitiveTypeTriangleStrip;
155  case PrimitiveType::kLine:
156  return MTLPrimitiveTypeLine;
157  case PrimitiveType::kLineStrip:
158  return MTLPrimitiveTypeLineStrip;
159  case PrimitiveType::kPoint:
160  return MTLPrimitiveTypePoint;
161  }
162  return MTLPrimitiveTypePoint;
163 }

References kLine, kLineStrip, kPoint, kTriangle, and kTriangleStrip.

◆ ToMTLRenderPassDescriptor()

static MTLRenderPassDescriptor* impeller::ToMTLRenderPassDescriptor ( const RenderTarget &  desc)
static

Definition at line 102 of file render_pass_mtl.mm.

103  {
104  auto result = [MTLRenderPassDescriptor renderPassDescriptor];
105 
106  const auto& colors = desc.GetColorAttachments();
107 
108  for (const auto& color : colors) {
109  if (!ConfigureColorAttachment(color.second,
110  result.colorAttachments[color.first])) {
111  VALIDATION_LOG << "Could not configure color attachment at index "
112  << color.first;
113  return nil;
114  }
115  }
116 
117  const auto& depth = desc.GetDepthAttachment();
118 
119  if (depth.has_value() &&
120  !ConfigureDepthAttachment(depth.value(), result.depthAttachment)) {
121  VALIDATION_LOG << "Could not configure depth attachment.";
122  return nil;
123  }
124 
125  const auto& stencil = desc.GetStencilAttachment();
126 
127  if (stencil.has_value() &&
128  !ConfigureStencilAttachment(stencil.value(), result.stencilAttachment)) {
129  VALIDATION_LOG << "Could not configure stencil attachment.";
130  return nil;
131  }
132 
133  return result;
134 }

References ConfigureColorAttachment(), ConfigureDepthAttachment(), ConfigureStencilAttachment(), impeller::RenderTarget::GetColorAttachments(), impeller::RenderTarget::GetDepthAttachment(), impeller::RenderTarget::GetStencilAttachment(), and VALIDATION_LOG.

◆ ToMTLRenderPipelineColorAttachmentDescriptor()

MTLRenderPipelineColorAttachmentDescriptor * impeller::ToMTLRenderPipelineColorAttachmentDescriptor ( ColorAttachmentDescriptor  descriptor)

Definition at line 15 of file formats_mtl.mm.

16  {
17  auto des = [[MTLRenderPipelineColorAttachmentDescriptor alloc] init];
18  des.pixelFormat = ToMTLPixelFormat(descriptor.format);
19 
20  des.blendingEnabled = descriptor.blending_enabled;
21 
22  des.sourceRGBBlendFactor =
23  ToMTLBlendFactor(descriptor.src_color_blend_factor);
24  des.rgbBlendOperation = ToMTLBlendOperation(descriptor.color_blend_op);
25  des.destinationRGBBlendFactor =
26  ToMTLBlendFactor(descriptor.dst_color_blend_factor);
27 
28  des.sourceAlphaBlendFactor =
29  ToMTLBlendFactor(descriptor.src_alpha_blend_factor);
30  des.alphaBlendOperation = ToMTLBlendOperation(descriptor.alpha_blend_op);
31  des.destinationAlphaBlendFactor =
32  ToMTLBlendFactor(descriptor.dst_alpha_blend_factor);
33 
34  des.writeMask = ToMTLColorWriteMask(descriptor.write_mask);
35  return des;
36 }

References impeller::ColorAttachmentDescriptor::alpha_blend_op, impeller::ColorAttachmentDescriptor::blending_enabled, impeller::ColorAttachmentDescriptor::color_blend_op, impeller::ColorAttachmentDescriptor::dst_alpha_blend_factor, impeller::ColorAttachmentDescriptor::dst_color_blend_factor, impeller::ColorAttachmentDescriptor::format, impeller::ColorAttachmentDescriptor::src_alpha_blend_factor, impeller::ColorAttachmentDescriptor::src_color_blend_factor, ToMTLBlendFactor(), ToMTLBlendOperation(), ToMTLColorWriteMask(), ToMTLPixelFormat(), and impeller::ColorAttachmentDescriptor::write_mask.

Referenced by GetMTLRenderPipelineDescriptor().

◆ ToMTLResourceOptions()

static MTLResourceOptions impeller::ToMTLResourceOptions ( StorageMode  type,
bool  supports_memoryless_targets,
bool  supports_uma 
)
static

Definition at line 111 of file allocator_mtl.mm.

113  {
114  switch (type) {
115  case StorageMode::kHostVisible:
116 #if FML_OS_IOS
117  return MTLResourceStorageModeShared;
118 #else
119  if (supports_uma) {
120  return MTLResourceStorageModeShared;
121  } else {
122  return MTLResourceStorageModeManaged;
123  }
124 #endif
125  case StorageMode::kDevicePrivate:
126  return MTLResourceStorageModePrivate;
127  case StorageMode::kDeviceTransient:
128  if (supports_memoryless_targets) {
129  // Device may support but the OS has not been updated.
130  if (@available(macOS 11.0, *)) {
131  return MTLResourceStorageModeMemoryless;
132  } else {
133  return MTLResourceStorageModePrivate;
134  }
135  } else {
136  return MTLResourceStorageModePrivate;
137  }
138  FML_UNREACHABLE();
139  }
140  FML_UNREACHABLE();
141 }

◆ ToMTLSamplerAddressMode()

constexpr MTLSamplerAddressMode impeller::ToMTLSamplerAddressMode ( SamplerAddressMode  mode)
constexpr

Definition at line 355 of file formats_mtl.h.

356  {
357  switch (mode) {
358  case SamplerAddressMode::kClampToEdge:
359  return MTLSamplerAddressModeClampToEdge;
360  case SamplerAddressMode::kRepeat:
361  return MTLSamplerAddressModeRepeat;
362  case SamplerAddressMode::kMirror:
363  return MTLSamplerAddressModeMirrorRepeat;
364  case SamplerAddressMode::kDecal:
365  return MTLSamplerAddressModeClampToZero;
366  }
367  return MTLSamplerAddressModeClampToEdge;
368 }

References kClampToEdge, kDecal, kMirror, and kRepeat.

◆ ToMTLSamplerMinMagFilter()

constexpr MTLSamplerMinMagFilter impeller::ToMTLSamplerMinMagFilter ( MinMagFilter  filter)
constexpr

Definition at line 335 of file formats_mtl.h.

335  {
336  switch (filter) {
337  case MinMagFilter::kNearest:
338  return MTLSamplerMinMagFilterNearest;
339  case MinMagFilter::kLinear:
340  return MTLSamplerMinMagFilterLinear;
341  }
342  return MTLSamplerMinMagFilterNearest;
343 }

References kLinear, and kNearest.

◆ ToMTLSamplerMipFilter()

constexpr MTLSamplerMipFilter impeller::ToMTLSamplerMipFilter ( MipFilter  filter)
constexpr

Definition at line 345 of file formats_mtl.h.

345  {
346  switch (filter) {
347  case MipFilter::kNearest:
348  return MTLSamplerMipFilterNearest;
349  case MipFilter::kLinear:
350  return MTLSamplerMipFilterLinear;
351  }
352  return MTLSamplerMipFilterNotMipmapped;
353 }

References kLinear, and kNearest.

◆ ToMTLStencilDescriptor()

MTLStencilDescriptor* impeller::ToMTLStencilDescriptor ( const StencilAttachmentDescriptor &  descriptor)

Definition at line 38 of file formats_mtl.mm.

39  {
40  auto des = [[MTLStencilDescriptor alloc] init];
41  des.stencilCompareFunction = ToMTLCompareFunction(descriptor.stencil_compare);
42  des.stencilFailureOperation =
43  ToMTLStencilOperation(descriptor.stencil_failure);
44  des.depthFailureOperation = ToMTLStencilOperation(descriptor.depth_failure);
45  des.depthStencilPassOperation =
46  ToMTLStencilOperation(descriptor.depth_stencil_pass);
47 
48  des.readMask = descriptor.read_mask;
49  des.writeMask = descriptor.write_mask;
50 
51  return des;
52 }

References impeller::StencilAttachmentDescriptor::depth_failure, impeller::StencilAttachmentDescriptor::depth_stencil_pass, impeller::StencilAttachmentDescriptor::read_mask, impeller::StencilAttachmentDescriptor::stencil_compare, impeller::StencilAttachmentDescriptor::stencil_failure, ToMTLCompareFunction(), ToMTLStencilOperation(), and impeller::StencilAttachmentDescriptor::write_mask.

Referenced by ToMTLDepthStencilDescriptor().

◆ ToMTLStencilOperation()

constexpr MTLStencilOperation impeller::ToMTLStencilOperation ( StencilOperation  op)
constexpr

Definition at line 255 of file formats_mtl.h.

255  {
256  switch (op) {
257  case StencilOperation::kKeep:
258  return MTLStencilOperationKeep;
259  case StencilOperation::kZero:
260  return MTLStencilOperationZero;
261  case StencilOperation::kSetToReferenceValue:
262  return MTLStencilOperationReplace;
263  case StencilOperation::kIncrementClamp:
264  return MTLStencilOperationIncrementClamp;
265  case StencilOperation::kDecrementClamp:
266  return MTLStencilOperationDecrementClamp;
267  case StencilOperation::kInvert:
268  return MTLStencilOperationInvert;
269  case StencilOperation::kIncrementWrap:
270  return MTLStencilOperationIncrementWrap;
271  case StencilOperation::kDecrementWrap:
272  return MTLStencilOperationDecrementWrap;
273  }
274  return MTLStencilOperationKeep;
275 };

References kDecrementClamp, kDecrementWrap, kIncrementClamp, kIncrementWrap, kInvert, kKeep, kSetToReferenceValue, and kZero.

Referenced by ToMTLStencilDescriptor().

◆ ToMTLStorageMode()

static MTLStorageMode impeller::ToMTLStorageMode ( StorageMode  mode,
bool  supports_memoryless_targets,
bool  supports_uma 
)
static

Definition at line 143 of file allocator_mtl.mm.

145  {
146  switch (mode) {
147  case StorageMode::kHostVisible:
148 #if FML_OS_IOS
149  return MTLStorageModeShared;
150 #else
151  if (supports_uma) {
152  return MTLStorageModeShared;
153  } else {
154  return MTLStorageModeManaged;
155  }
156 #endif
157  case StorageMode::kDevicePrivate:
158  return MTLStorageModePrivate;
159  case StorageMode::kDeviceTransient:
160  if (supports_memoryless_targets) {
161  // Device may support but the OS has not been updated.
162  if (@available(macOS 11.0, *)) {
163  return MTLStorageModeMemoryless;
164  } else {
165  return MTLStorageModePrivate;
166  }
167  } else {
168  return MTLStorageModePrivate;
169  }
170  FML_UNREACHABLE();
171  }
172  FML_UNREACHABLE();
173 }

◆ ToMTLStoreAction()

constexpr MTLStoreAction impeller::ToMTLStoreAction ( StoreAction  action)
constexpr

Definition at line 305 of file formats_mtl.h.

305  {
306  switch (action) {
307  case StoreAction::kDontCare:
308  return MTLStoreActionDontCare;
309  case StoreAction::kStore:
310  return MTLStoreActionStore;
311  case StoreAction::kMultisampleResolve:
312  return MTLStoreActionMultisampleResolve;
313  case StoreAction::kStoreAndMultisampleResolve:
314  return MTLStoreActionStoreAndMultisampleResolve;
315  }
316  return MTLStoreActionDontCare;
317 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by ConfigureAttachment().

◆ ToMTLTextureDescriptor()

MTLTextureDescriptor * impeller::ToMTLTextureDescriptor ( const TextureDescriptor &  desc)

Definition at line 86 of file formats_mtl.mm.

86  {
87  if (!desc.IsValid()) {
88  return nil;
89  }
90  auto mtl_desc = [[MTLTextureDescriptor alloc] init];
91  mtl_desc.textureType = ToMTLTextureType(desc.type);
92  mtl_desc.pixelFormat = ToMTLPixelFormat(desc.format);
93  mtl_desc.sampleCount = static_cast<NSUInteger>(desc.sample_count);
94  mtl_desc.width = desc.size.width;
95  mtl_desc.height = desc.size.height;
96  mtl_desc.mipmapLevelCount = desc.mip_count;
97  mtl_desc.usage = MTLTextureUsageUnknown;
98  if (desc.usage & static_cast<TextureUsageMask>(TextureUsage::kUnknown)) {
99  mtl_desc.usage |= MTLTextureUsageUnknown;
100  }
101  if (desc.usage & static_cast<TextureUsageMask>(TextureUsage::kShaderRead)) {
102  mtl_desc.usage |= MTLTextureUsageShaderRead;
103  }
104  if (desc.usage & static_cast<TextureUsageMask>(TextureUsage::kShaderWrite)) {
105  mtl_desc.usage |= MTLTextureUsageShaderWrite;
106  }
107  if (desc.usage & static_cast<TextureUsageMask>(TextureUsage::kRenderTarget)) {
108  mtl_desc.usage |= MTLTextureUsageRenderTarget;
109  }
110  return mtl_desc;
111 }

References impeller::TextureDescriptor::format, impeller::TSize< T >::height, impeller::TextureDescriptor::IsValid(), kRenderTarget, kShaderRead, kShaderWrite, kUnknown, impeller::TextureDescriptor::mip_count, impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, ToMTLPixelFormat(), ToMTLTextureType(), impeller::TextureDescriptor::type, impeller::TextureDescriptor::usage, and impeller::TSize< T >::width.

◆ ToMTLTextureType()

constexpr MTLTextureType impeller::ToMTLTextureType ( TextureType  type)
constexpr

Definition at line 374 of file formats_mtl.h.

374  {
375  switch (type) {
376  case TextureType::kTexture2D:
377  return MTLTextureType2D;
378  case TextureType::kTexture2DMultisample:
379  return MTLTextureType2DMultisample;
380  case TextureType::kTextureCube:
381  return MTLTextureTypeCube;
382  case TextureType::kTextureExternalOES:
383  VALIDATION_LOG
384  << "kTextureExternalOES can not be used with the Metal backend.";
385  }
386  return MTLTextureType2D;
387 }

References kTexture2D, kTexture2DMultisample, kTextureCube, kTextureExternalOES, and VALIDATION_LOG.

Referenced by ToMTLTextureDescriptor().

◆ ToMTLTriangleFillMode()

constexpr MTLTriangleFillMode impeller::ToMTLTriangleFillMode ( PolygonMode  mode)
constexpr

Definition at line 165 of file formats_mtl.h.

165  {
166  switch (mode) {
167  case PolygonMode::kFill:
168  return MTLTriangleFillModeFill;
169  case PolygonMode::kLine:
170  return MTLTriangleFillModeLines;
171  }
172  return MTLTriangleFillModeFill;
173 }

References kFill, and kLine.

◆ ToParam() [1/2]

static GLint impeller::ToParam ( MinMagFilter  minmag_filter,
std::optional< MipFilter >  mip_filter = std::nullopt 
)
static

Definition at line 25 of file sampler_gles.cc.

26  {
27  if (!mip_filter.has_value()) {
28  switch (minmag_filter) {
29  case MinMagFilter::kNearest:
30  return GL_NEAREST;
31  case MinMagFilter::kLinear:
32  return GL_LINEAR;
33  }
34  FML_UNREACHABLE();
35  }
36 
37  switch (mip_filter.value()) {
38  case MipFilter::kNearest:
39  switch (minmag_filter) {
40  case MinMagFilter::kNearest:
41  return GL_NEAREST_MIPMAP_NEAREST;
42  case MinMagFilter::kLinear:
43  return GL_LINEAR_MIPMAP_NEAREST;
44  }
45  case MipFilter::kLinear:
46  switch (minmag_filter) {
47  case MinMagFilter::kNearest:
48  return GL_NEAREST_MIPMAP_LINEAR;
49  case MinMagFilter::kLinear:
50  return GL_LINEAR_MIPMAP_LINEAR;
51  }
52  }
53  FML_UNREACHABLE();
54 }

References kLinear, and kNearest.

◆ ToParam() [2/2]

static constexpr int impeller::ToParam ( size_t  index)
staticconstexpr

Definition at line 75 of file archive_statement.cc.

75  {
76  /*
77  * sqlite parameters begin from 1
78  */
79  return static_cast<int>(index + 1);
80 }

Referenced by impeller::SamplerGLES::ConfigureBoundTexture(), and impeller::ArchiveStatement::WriteValue().

◆ ToPixelFormat()

constexpr PixelFormat impeller::ToPixelFormat ( vk::Format  format)
constexpr

Definition at line 173 of file formats_vk.h.

173  {
174  switch (format) {
175  case vk::Format::eUndefined:
176  return PixelFormat::kUnknown;
177  case vk::Format::eR8G8B8A8Unorm:
178  return PixelFormat::kR8G8B8A8UNormInt;
179  case vk::Format::eR8G8B8A8Srgb:
180  return PixelFormat::kR8G8B8A8UNormIntSRGB;
181  case vk::Format::eB8G8R8A8Unorm:
182  return PixelFormat::kB8G8R8A8UNormInt;
183  case vk::Format::eB8G8R8A8Srgb:
184  return PixelFormat::kB8G8R8A8UNormIntSRGB;
185  case vk::Format::eR32G32B32A32Sfloat:
186  return PixelFormat::kR32G32B32A32Float;
187  case vk::Format::eR16G16B16A16Sfloat:
188  return PixelFormat::kR16G16B16A16Float;
189  case vk::Format::eS8Uint:
190  return PixelFormat::kS8UInt;
191  case vk::Format::eD24UnormS8Uint:
192  return PixelFormat::kD24UnormS8Uint;
193  case vk::Format::eD32SfloatS8Uint:
194  return PixelFormat::kD32FloatS8UInt;
195  case vk::Format::eR8Unorm:
196  return PixelFormat::kR8UNormInt;
197  case vk::Format::eR8G8Unorm:
198  return PixelFormat::kR8G8UNormInt;
199  default:
200  return PixelFormat::kUnknown;
201  }
202 }

References kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, and kUnknown.

◆ ToRect() [1/2]

static Rect impeller::ToRect ( const SkRect &  rect)
static

Definition at line 16 of file dl_vertices_geometry.cc.

16  {
17  return Rect::MakeLTRB(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
18 }

References impeller::TRect< Scalar >::MakeLTRB().

Referenced by MakeTextFrameFromTextBlobSkia(), and MakeVertices().

◆ ToRect() [2/2]

static Rect impeller::ToRect ( const SkRect &  rect)
static

Definition at line 35 of file text_frame_skia.cc.

35  {
36  return Rect::MakeLTRB(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
37 }

References impeller::TRect< Scalar >::MakeLTRB().

◆ ToRenderBufferFormat()

static std::optional<GLenum> impeller::ToRenderBufferFormat ( PixelFormat  format)
static

Definition at line 309 of file texture_gles.cc.

309  {
310  switch (format) {
311  case PixelFormat::kB8G8R8A8UNormInt:
312  case PixelFormat::kR8G8B8A8UNormInt:
313  return GL_RGBA4;
314  case PixelFormat::kR32G32B32A32Float:
315  return GL_RGBA32F;
316  case PixelFormat::kR16G16B16A16Float:
317  return GL_RGBA16F;
318  case PixelFormat::kS8UInt:
319  return GL_STENCIL_INDEX8;
320  case PixelFormat::kD24UnormS8Uint:
321  return GL_DEPTH24_STENCIL8;
322  case PixelFormat::kD32FloatS8UInt:
323  return GL_DEPTH32F_STENCIL8;
324  case PixelFormat::kUnknown:
325  case PixelFormat::kA8UNormInt:
326  case PixelFormat::kR8UNormInt:
327  case PixelFormat::kR8G8UNormInt:
328  case PixelFormat::kR8G8B8A8UNormIntSRGB:
329  case PixelFormat::kB8G8R8A8UNormIntSRGB:
330  case PixelFormat::kB10G10R10XRSRGB:
331  case PixelFormat::kB10G10R10XR:
332  case PixelFormat::kB10G10R10A10XR:
333  return std::nullopt;
334  }
335  FML_UNREACHABLE();
336 }

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, and kUnknown.

◆ ToRGB()

static constexpr Vector3 impeller::ToRGB ( Color  color)
inlinestaticconstexpr

Definition at line 188 of file color.cc.

188  {
189  return {color.red, color.green, color.blue};
190 }

References impeller::Color::blue, impeller::Color::green, and impeller::Color::red.

Referenced by DoColorBlend().

◆ ToSamplerDescriptor() [1/2]

static impeller::SamplerDescriptor impeller::ToSamplerDescriptor ( const flutter::DlFilterMode  options)
static

Definition at line 156 of file dl_dispatcher.cc.

157  {
158  impeller::SamplerDescriptor desc;
159  switch (options) {
160  case flutter::DlFilterMode::kNearest:
161  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kNearest;
162  desc.label = "Nearest Sampler";
163  break;
164  case flutter::DlFilterMode::kLinear:
165  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
166  desc.label = "Linear Sampler";
167  break;
168  default:
169  break;
170  }
171  return desc;
172 }

References kLinear, kNearest, impeller::SamplerDescriptor::label, impeller::SamplerDescriptor::mag_filter, and impeller::SamplerDescriptor::min_filter.

◆ ToSamplerDescriptor() [2/2]

static impeller::SamplerDescriptor impeller::ToSamplerDescriptor ( const flutter::DlImageSampling  options)
static

Definition at line 132 of file dl_dispatcher.cc.

133  {
134  impeller::SamplerDescriptor desc;
135  switch (options) {
136  case flutter::DlImageSampling::kNearestNeighbor:
137  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kNearest;
138  desc.label = "Nearest Sampler";
139  break;
140  case flutter::DlImageSampling::kLinear:
141  // Impeller doesn't support cubic sampling, but linear is closer to correct
142  // than nearest for this case.
143  case flutter::DlImageSampling::kCubic:
144  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
145  desc.label = "Linear Sampler";
146  break;
147  case flutter::DlImageSampling::kMipmapLinear:
148  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
149  desc.mip_filter = impeller::MipFilter::kLinear;
150  desc.label = "Mipmap Linear Sampler";
151  break;
152  }
153  return desc;
154 }

References kLinear, kNearest, impeller::SamplerDescriptor::label, impeller::SamplerDescriptor::mag_filter, impeller::SamplerDescriptor::min_filter, and impeller::SamplerDescriptor::mip_filter.

Referenced by impeller::DlDispatcher::drawAtlas(), impeller::DlDispatcher::drawImageNine(), impeller::DlDispatcher::drawImageRect(), impeller::DlDispatcher::setColorSource(), and ToImageFilter().

◆ ToShaderStage() [1/4]

static ShaderStage impeller::ToShaderStage ( BlobShaderType  type)
static

Definition at line 15 of file shader_library_vk.cc.

15  {
16  switch (type) {
17  case BlobShaderType::kVertex:
18  return ShaderStage::kVertex;
19  case BlobShaderType::kFragment:
20  return ShaderStage::kFragment;
21  case BlobShaderType::kCompute:
22  return ShaderStage::kCompute;
23  }
24  FML_UNREACHABLE();
25 }

References kCompute, kFragment, and kVertex.

◆ ToShaderStage() [2/4]

static ShaderStage impeller::ToShaderStage ( BlobShaderType  type)
static

Definition at line 17 of file shader_library_gles.cc.

17  {
18  switch (type) {
19  case BlobShaderType::kVertex:
20  return ShaderStage::kVertex;
21  case BlobShaderType::kFragment:
22  return ShaderStage::kFragment;
23  case BlobShaderType::kCompute:
24  return ShaderStage::kCompute;
25  }
26  FML_UNREACHABLE();
27 }

References kCompute, kFragment, and kVertex.

◆ ToShaderStage() [3/4]

static RuntimeShaderStage impeller::ToShaderStage ( fb::Stage  stage)
static

Definition at line 46 of file runtime_stage.cc.

46  {
47  switch (stage) {
48  case fb::Stage::kVertex:
49  return RuntimeShaderStage::kVertex;
50  case fb::Stage::kFragment:
51  return RuntimeShaderStage::kFragment;
52  case fb::Stage::kCompute:
53  return RuntimeShaderStage::kCompute;
54  case fb::Stage::kTessellationControl:
55  return RuntimeShaderStage::kTessellationControl;
56  case fb::Stage::kTessellationEvaluation:
57  return RuntimeShaderStage::kTessellationEvaluation;
58  }
59  FML_UNREACHABLE();
60 }

References kCompute, kFragment, kTessellationControl, kTessellationEvaluation, and kVertex.

◆ ToShaderStage() [4/4]

constexpr ShaderStage impeller::ToShaderStage ( RuntimeShaderStage  stage)
constexpr

Definition at line 29 of file shader_types.h.

29  {
30  switch (stage) {
31  case RuntimeShaderStage::kVertex:
32  return ShaderStage::kVertex;
33  case RuntimeShaderStage::kFragment:
34  return ShaderStage::kFragment;
35  case RuntimeShaderStage::kCompute:
36  return ShaderStage::kCompute;
37  case RuntimeShaderStage::kTessellationControl:
38  return ShaderStage::kTessellationControl;
39  case RuntimeShaderStage::kTessellationEvaluation:
40  return ShaderStage::kTessellationEvaluation;
41  }
42  FML_UNREACHABLE();
43 }

References kCompute, kFragment, kTessellationControl, kTessellationEvaluation, and kVertex.

Referenced by impeller::RuntimeStagePlayground::RegisterStage(), impeller::RuntimeEffectContents::Render(), impeller::RuntimeStage::RuntimeStage(), and impeller::testing::TEST_P().

◆ ToShaderType()

constexpr BlobShaderType impeller::ToShaderType ( fb::Stage  stage)
constexpr

Definition at line 16 of file blob_library.cc.

16  {
17  switch (stage) {
18  case fb::Stage::kVertex:
19  return BlobShaderType::kVertex;
20  case fb::Stage::kFragment:
21  return BlobShaderType::kFragment;
22  case fb::Stage::kCompute:
23  return BlobShaderType::kCompute;
24  }
25  FML_UNREACHABLE();
26 }

References kCompute, kFragment, and kVertex.

Referenced by impeller::BlobLibrary::BlobLibrary().

◆ ToStage()

constexpr fb::Stage impeller::ToStage ( BlobShaderType  type)
constexpr

Definition at line 86 of file blob_writer.cc.

86  {
87  switch (type) {
88  case BlobShaderType::kVertex:
89  return fb::Stage::kVertex;
90  case BlobShaderType::kFragment:
91  return fb::Stage::kFragment;
92  case BlobShaderType::kCompute:
93  return fb::Stage::kCompute;
94  }
95  FML_UNREACHABLE();
96 }

References kCompute, kFragment, and kVertex.

Referenced by impeller::BlobWriter::CreateMapping().

◆ ToStencilOp()

constexpr GLenum impeller::ToStencilOp ( StencilOperation  op)
constexpr

Definition at line 46 of file formats_gles.h.

46  {
47  switch (op) {
48  case StencilOperation::kKeep:
49  return GL_KEEP;
50  case StencilOperation::kZero:
51  return GL_ZERO;
52  case StencilOperation::kSetToReferenceValue:
53  return GL_REPLACE;
54  case StencilOperation::kIncrementClamp:
55  return GL_INCR;
56  case StencilOperation::kDecrementClamp:
57  return GL_DECR;
58  case StencilOperation::kInvert:
59  return GL_INVERT;
60  case StencilOperation::kIncrementWrap:
61  return GL_INCR_WRAP;
62  case StencilOperation::kDecrementWrap:
63  return GL_DECR_WRAP;
64  }
65  FML_UNREACHABLE();
66 }

References kDecrementClamp, kDecrementWrap, kIncrementClamp, kIncrementWrap, kInvert, kKeep, kSetToReferenceValue, and kZero.

Referenced by ConfigureStencil().

◆ ToStyle()

static Paint::Style impeller::ToStyle ( flutter::DlDrawStyle  style)
static

Definition at line 195 of file dl_dispatcher.cc.

195  {
196  switch (style) {
197  case flutter::DlDrawStyle::kFill:
198  return Paint::Style::kFill;
199  case flutter::DlDrawStyle::kStroke:
200  return Paint::Style::kStroke;
201  case flutter::DlDrawStyle::kStrokeAndFill:
202  UNIMPLEMENTED;
203  break;
204  }
205  return Paint::Style::kFill;
206 }

References impeller::Paint::kFill, impeller::Paint::kStroke, and UNIMPLEMENTED.

Referenced by impeller::DlDispatcher::setDrawStyle().

◆ ToTarget()

static GLenum impeller::ToTarget ( DeviceBufferGLES::BindingType  type)
static

Definition at line 60 of file device_buffer_gles.cc.

60  {
61  switch (type) {
62  case DeviceBufferGLES::BindingType::kArrayBuffer:
63  return GL_ARRAY_BUFFER;
64  case DeviceBufferGLES::BindingType::kElementArrayBuffer:
65  return GL_ELEMENT_ARRAY_BUFFER;
66  }
67  FML_UNREACHABLE();
68 }

References impeller::DeviceBufferGLES::kArrayBuffer, and impeller::DeviceBufferGLES::kElementArrayBuffer.

Referenced by impeller::DeviceBufferGLES::BindAndUploadDataIfNecessary().

◆ ToTessWindingRule()

static int impeller::ToTessWindingRule ( FillType  fill_type)
static

Definition at line 45 of file tessellator.cc.

45  {
46  switch (fill_type) {
47  case FillType::kOdd:
48  return TESS_WINDING_ODD;
49  case FillType::kNonZero:
50  return TESS_WINDING_NONZERO;
51  case FillType::kPositive:
52  return TESS_WINDING_POSITIVE;
53  case FillType::kNegative:
54  return TESS_WINDING_NEGATIVE;
55  case FillType::kAbsGeqTwo:
56  return TESS_WINDING_ABS_GEQ_TWO;
57  }
58  return TESS_WINDING_ODD;
59 }

References kAbsGeqTwo, kNegative, kNonZero, kOdd, and kPositive.

Referenced by impeller::Tessellator::Tessellate().

◆ ToTextureTarget()

constexpr std::optional<GLenum> impeller::ToTextureTarget ( TextureType  type)
constexpr

Definition at line 183 of file formats_gles.h.

183  {
184  switch (type) {
185  case TextureType::kTexture2D:
186  return GL_TEXTURE_2D;
187  case TextureType::kTexture2DMultisample:
188  return std::nullopt;
189  case TextureType::kTextureCube:
190  return GL_TEXTURE_CUBE_MAP;
191  case TextureType::kTextureExternalOES:
192  return GL_TEXTURE_EXTERNAL_OES;
193  }
194  FML_UNREACHABLE();
195 }

References kTexture2D, kTexture2DMultisample, kTextureCube, and kTextureExternalOES.

Referenced by impeller::TextureGLES::Bind(), and impeller::SamplerGLES::ConfigureBoundTexture().

◆ ToTextureType()

constexpr GLenum impeller::ToTextureType ( TextureType  type)
constexpr

Definition at line 169 of file formats_gles.h.

169  {
170  switch (type) {
171  case TextureType::kTexture2D:
172  return GL_TEXTURE_2D;
173  case TextureType::kTexture2DMultisample:
174  return GL_TEXTURE_2D_MULTISAMPLE;
175  case TextureType::kTextureCube:
176  return GL_TEXTURE_CUBE_MAP;
177  case TextureType::kTextureExternalOES:
178  return GL_TEXTURE_EXTERNAL_OES;
179  }
180  FML_UNREACHABLE();
181 }

References kTexture2D, kTexture2DMultisample, kTextureCube, and kTextureExternalOES.

Referenced by impeller::TextureGLES::GenerateMipmap().

◆ ToTileMode()

static Entity::TileMode impeller::ToTileMode ( flutter::DlTileMode  tile_mode)
static

Definition at line 119 of file dl_dispatcher.cc.

119  {
120  switch (tile_mode) {
121  case flutter::DlTileMode::kClamp:
122  return Entity::TileMode::kClamp;
123  case flutter::DlTileMode::kRepeat:
124  return Entity::TileMode::kRepeat;
125  case flutter::DlTileMode::kMirror:
126  return Entity::TileMode::kMirror;
127  case flutter::DlTileMode::kDecal:
128  return Entity::TileMode::kDecal;
129  }
130 }

References impeller::Entity::kClamp, impeller::Entity::kDecal, impeller::Entity::kMirror, and impeller::Entity::kRepeat.

Referenced by impeller::DlDispatcher::setColorSource(), and ToImageFilter().

◆ ToType()

static RuntimeUniformType impeller::ToType ( fb::UniformDataType  type)
static

Definition at line 14 of file runtime_stage.cc.

14  {
15  switch (type) {
16  case fb::UniformDataType::kBoolean:
17  return RuntimeUniformType::kBoolean;
18  case fb::UniformDataType::kSignedByte:
19  return RuntimeUniformType::kSignedByte;
20  case fb::UniformDataType::kUnsignedByte:
21  return RuntimeUniformType::kUnsignedByte;
22  case fb::UniformDataType::kSignedShort:
23  return RuntimeUniformType::kSignedShort;
24  case fb::UniformDataType::kUnsignedShort:
25  return RuntimeUniformType::kUnsignedShort;
26  case fb::UniformDataType::kSignedInt:
27  return RuntimeUniformType::kSignedInt;
28  case fb::UniformDataType::kUnsignedInt:
29  return RuntimeUniformType::kUnsignedInt;
30  case fb::UniformDataType::kSignedInt64:
31  return RuntimeUniformType::kSignedInt64;
32  case fb::UniformDataType::kUnsignedInt64:
33  return RuntimeUniformType::kUnsignedInt64;
34  case fb::UniformDataType::kHalfFloat:
35  return RuntimeUniformType::kHalfFloat;
36  case fb::UniformDataType::kFloat:
37  return RuntimeUniformType::kFloat;
38  case fb::UniformDataType::kDouble:
39  return RuntimeUniformType::kDouble;
40  case fb::UniformDataType::kSampledImage:
41  return RuntimeUniformType::kSampledImage;
42  }
43  FML_UNREACHABLE();
44 }

References kBoolean, kDouble, kFloat, kHalfFloat, kSampledImage, kSignedByte, kSignedInt, kSignedInt64, kSignedShort, kUnsignedByte, kUnsignedInt, kUnsignedInt64, and kUnsignedShort.

Referenced by impeller::RuntimeStage::RuntimeStage().

◆ ToVector()

constexpr Vector4 impeller::ToVector ( Color  color)
inlineconstexpr

Definition at line 172 of file shader_types.h.

172  {
173  return {color.red, color.green, color.blue, color.alpha};
174 }

References impeller::Color::alpha, impeller::Color::blue, impeller::Color::green, and impeller::Color::red.

Referenced by impeller::TextContents::Render().

◆ ToVertexAttribType()

constexpr std::optional<GLenum> impeller::ToVertexAttribType ( ShaderType  type)
constexpr

Definition at line 138 of file formats_gles.h.

138  {
139  switch (type) {
140  case ShaderType::kSignedByte:
141  return GL_BYTE;
142  case ShaderType::kUnsignedByte:
143  return GL_UNSIGNED_BYTE;
144  case ShaderType::kSignedShort:
145  return GL_SHORT;
146  case ShaderType::kUnsignedShort:
147  return GL_UNSIGNED_SHORT;
148  case ShaderType::kFloat:
149  return GL_FLOAT;
150  case ShaderType::kUnknown:
151  case ShaderType::kVoid:
152  case ShaderType::kBoolean:
153  case ShaderType::kSignedInt:
154  case ShaderType::kUnsignedInt:
155  case ShaderType::kSignedInt64:
156  case ShaderType::kUnsignedInt64:
157  case ShaderType::kAtomicCounter:
158  case ShaderType::kHalfFloat:
159  case ShaderType::kDouble:
160  case ShaderType::kStruct:
161  case ShaderType::kImage:
162  case ShaderType::kSampledImage:
163  case ShaderType::kSampler:
164  return std::nullopt;
165  }
166  FML_UNREACHABLE();
167 }

References kAtomicCounter, kBoolean, kDouble, kFloat, kHalfFloat, kImage, kSampledImage, kSampler, kSignedByte, kSignedInt, kSignedInt64, kSignedShort, kStruct, kUnknown, kUnsignedByte, kUnsignedInt, kUnsignedInt64, kUnsignedShort, and kVoid.

Referenced by impeller::BufferBindingsGLES::RegisterVertexStageInput().

◆ ToVertexDescriptorFormat()

vk::Format impeller::ToVertexDescriptorFormat ( const ShaderStageIOSlot &  input)

Definition at line 9 of file vertex_descriptor_vk.cc.

9  {
10  if (input.columns != 1) {
11  // All matrix types are unsupported as vertex inputs.
12  return vk::Format::eUndefined;
13  }
14 
15  switch (input.type) {
16  case ShaderType::kFloat: {
17  if (input.bit_width == 8 * sizeof(float)) {
18  switch (input.vec_size) {
19  case 1:
20  return vk::Format::eR32Sfloat;
21  case 2:
22  return vk::Format::eR32G32Sfloat;
23  case 3:
24  return vk::Format::eR32G32B32Sfloat;
25  case 4:
26  return vk::Format::eR32G32B32A32Sfloat;
27  }
28  }
29  return vk::Format::eUndefined;
30  }
31  case ShaderType::kHalfFloat: {
32  if (input.bit_width == 8 * sizeof(float) / 2) {
33  switch (input.vec_size) {
34  case 1:
35  return vk::Format::eR16Sfloat;
36  case 2:
37  return vk::Format::eR16G16Sfloat;
38  case 3:
39  return vk::Format::eR16G16B16Sfloat;
40  case 4:
41  return vk::Format::eR16G16B16A16Sfloat;
42  }
43  }
44  return vk::Format::eUndefined;
45  }
46  case ShaderType::kDouble: {
47  // Unsupported.
48  return vk::Format::eUndefined;
49  }
50  case ShaderType::kBoolean: {
51  if (input.bit_width == 8 * sizeof(bool) && input.vec_size == 1) {
52  return vk::Format::eR8Uint;
53  }
54  return vk::Format::eUndefined;
55  }
56  case ShaderType::kSignedByte: {
57  if (input.bit_width == 8 * sizeof(char)) {
58  switch (input.vec_size) {
59  case 1:
60  return vk::Format::eR8Sint;
61  case 2:
62  return vk::Format::eR8G8Sint;
63  case 3:
64  return vk::Format::eR8G8B8Sint;
65  case 4:
66  return vk::Format::eR8G8B8A8Sint;
67  }
68  }
69  return vk::Format::eUndefined;
70  }
71  case ShaderType::kUnsignedByte: {
72  if (input.bit_width == 8 * sizeof(char)) {
73  switch (input.vec_size) {
74  case 1:
75  return vk::Format::eR8Uint;
76  case 2:
77  return vk::Format::eR8G8Uint;
78  case 3:
79  return vk::Format::eR8G8B8Uint;
80  case 4:
81  return vk::Format::eR8G8B8A8Uint;
82  }
83  }
84  return vk::Format::eUndefined;
85  }
86  case ShaderType::kSignedShort: {
87  if (input.bit_width == 8 * sizeof(int16_t)) {
88  switch (input.vec_size) {
89  case 1:
90  return vk::Format::eR16Sint;
91  case 2:
92  return vk::Format::eR16G16Sint;
93  case 3:
94  return vk::Format::eR16G16B16Sint;
95  case 4:
96  return vk::Format::eR16G16B16A16Sint;
97  }
98  }
99  return vk::Format::eUndefined;
100  }
101  case ShaderType::kUnsignedShort: {
102  if (input.bit_width == 8 * sizeof(uint16_t)) {
103  switch (input.vec_size) {
104  case 1:
105  return vk::Format::eR16Uint;
106  case 2:
107  return vk::Format::eR16G16Uint;
108  case 3:
109  return vk::Format::eR16G16B16Uint;
110  case 4:
111  return vk::Format::eR16G16B16A16Uint;
112  }
113  }
114  return vk::Format::eUndefined;
115  }
116  case ShaderType::kSignedInt: {
117  if (input.bit_width == 8 * sizeof(int32_t)) {
118  switch (input.vec_size) {
119  case 1:
120  return vk::Format::eR32Sint;
121  case 2:
122  return vk::Format::eR32G32Sint;
123  case 3:
124  return vk::Format::eR32G32B32Sint;
125  case 4:
126  return vk::Format::eR32G32B32A32Sint;
127  }
128  }
129  return vk::Format::eUndefined;
130  }
131  case ShaderType::kUnsignedInt: {
132  if (input.bit_width == 8 * sizeof(uint32_t)) {
133  switch (input.vec_size) {
134  case 1:
135  return vk::Format::eR32Uint;
136  case 2:
137  return vk::Format::eR32G32Uint;
138  case 3:
139  return vk::Format::eR32G32B32Uint;
140  case 4:
141  return vk::Format::eR32G32B32A32Uint;
142  }
143  }
144  return vk::Format::eUndefined;
145  }
146  case ShaderType::kSignedInt64: {
147  // Unsupported.
148  return vk::Format::eUndefined;
149  }
150  case ShaderType::kUnsignedInt64: {
151  // Unsupported.
152  return vk::Format::eUndefined;
153  }
154  case ShaderType::kAtomicCounter:
155  case ShaderType::kStruct:
156  case ShaderType::kImage:
157  case ShaderType::kSampledImage:
158  case ShaderType::kUnknown:
159  case ShaderType::kVoid:
160  case ShaderType::kSampler:
161  return vk::Format::eUndefined;
162  }
163 }

References impeller::ShaderStageIOSlot::bit_width, impeller::ShaderStageIOSlot::columns, kAtomicCounter, kBoolean, kDouble, kFloat, kHalfFloat, kImage, kSampledImage, kSampler, kSignedByte, kSignedInt, kSignedInt64, kSignedShort, kStruct, kUnknown, kUnsignedByte, kUnsignedInt, kUnsignedInt64, kUnsignedShort, kVoid, impeller::ShaderStageIOSlot::type, and impeller::ShaderStageIOSlot::vec_size.

◆ ToVertexMode()

static VerticesGeometry::VertexMode impeller::ToVertexMode ( flutter::DlVertexMode  mode)
static

Definition at line 20 of file dl_vertices_geometry.cc.

20  {
21  switch (mode) {
22  case flutter::DlVertexMode::kTriangles:
23  return VerticesGeometry::VertexMode::kTriangles;
24  case flutter::DlVertexMode::kTriangleStrip:
25  return VerticesGeometry::VertexMode::kTriangleStrip;
26  case flutter::DlVertexMode::kTriangleFan:
27  return VerticesGeometry::VertexMode::kTriangleFan;
28  };
29 }

References impeller::VerticesGeometry::kTriangleFan, impeller::VerticesGeometry::kTriangles, and impeller::VerticesGeometry::kTriangleStrip.

Referenced by MakeVertices().

◆ ToVKAttachmentLoadOp()

constexpr vk::AttachmentLoadOp impeller::ToVKAttachmentLoadOp ( LoadAction  load_action)
constexpr

Definition at line 305 of file formats_vk.h.

305  {
306  switch (load_action) {
307  case LoadAction::kLoad:
308  return vk::AttachmentLoadOp::eLoad;
309  case LoadAction::kClear:
310  return vk::AttachmentLoadOp::eClear;
311  case LoadAction::kDontCare:
312  return vk::AttachmentLoadOp::eDontCare;
313  }
314 
315  FML_UNREACHABLE();
316 }

References kClear, kDontCare, and kLoad.

Referenced by CreateAttachmentDescription().

◆ ToVKAttachmentStoreOp()

constexpr vk::AttachmentStoreOp impeller::ToVKAttachmentStoreOp ( StoreAction  store_action)
constexpr

Definition at line 318 of file formats_vk.h.

319  {
320  switch (store_action) {
321  case StoreAction::kStore:
322  return vk::AttachmentStoreOp::eStore;
323  case StoreAction::kDontCare:
324  return vk::AttachmentStoreOp::eDontCare;
325  case StoreAction::kMultisampleResolve:
326  case StoreAction::kStoreAndMultisampleResolve:
327  return vk::AttachmentStoreOp::eDontCare;
328  }
329 
330  FML_UNREACHABLE();
331 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by CreateAttachmentDescription().

◆ ToVKBlendFactor()

constexpr vk::BlendFactor impeller::ToVKBlendFactor ( BlendFactor  factor)
constexpr

Definition at line 25 of file formats_vk.h.

25  {
26  switch (factor) {
27  case BlendFactor::kZero:
28  return vk::BlendFactor::eZero;
29  case BlendFactor::kOne:
30  return vk::BlendFactor::eOne;
31  case BlendFactor::kSourceColor:
32  return vk::BlendFactor::eSrcColor;
33  case BlendFactor::kOneMinusSourceColor:
34  return vk::BlendFactor::eOneMinusSrcColor;
35  case BlendFactor::kSourceAlpha:
36  return vk::BlendFactor::eSrcAlpha;
37  case BlendFactor::kOneMinusSourceAlpha:
38  return vk::BlendFactor::eOneMinusSrcAlpha;
39  case BlendFactor::kDestinationColor:
40  return vk::BlendFactor::eDstColor;
41  case BlendFactor::kOneMinusDestinationColor:
42  return vk::BlendFactor::eOneMinusDstColor;
43  case BlendFactor::kDestinationAlpha:
44  return vk::BlendFactor::eDstAlpha;
45  case BlendFactor::kOneMinusDestinationAlpha:
46  return vk::BlendFactor::eOneMinusDstAlpha;
47  case BlendFactor::kSourceAlphaSaturated:
48  return vk::BlendFactor::eSrcAlphaSaturate;
49  case BlendFactor::kBlendColor:
50  return vk::BlendFactor::eConstantColor;
51  case BlendFactor::kOneMinusBlendColor:
52  return vk::BlendFactor::eOneMinusConstantColor;
53  case BlendFactor::kBlendAlpha:
54  return vk::BlendFactor::eConstantAlpha;
55  case BlendFactor::kOneMinusBlendAlpha:
56  return vk::BlendFactor::eOneMinusConstantAlpha;
57  }
58  FML_UNREACHABLE();
59 }

References kBlendAlpha, kBlendColor, kDestinationAlpha, kDestinationColor, kOne, kOneMinusBlendAlpha, kOneMinusBlendColor, kOneMinusDestinationAlpha, kOneMinusDestinationColor, kOneMinusSourceAlpha, kOneMinusSourceColor, kSourceAlpha, kSourceAlphaSaturated, kSourceColor, and kZero.

Referenced by ToVKPipelineColorBlendAttachmentState().

◆ ToVKBlendOp()

constexpr vk::BlendOp impeller::ToVKBlendOp ( BlendOperation  op)
constexpr

Definition at line 61 of file formats_vk.h.

61  {
62  switch (op) {
63  case BlendOperation::kAdd:
64  return vk::BlendOp::eAdd;
65  case BlendOperation::kSubtract:
66  return vk::BlendOp::eSubtract;
67  case BlendOperation::kReverseSubtract:
68  return vk::BlendOp::eReverseSubtract;
69  }
70  FML_UNREACHABLE();
71 }

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ToVKPipelineColorBlendAttachmentState().

◆ ToVKBufferMemoryPropertyFlags()

static constexpr vk::Flags<vk::MemoryPropertyFlagBits> impeller::ToVKBufferMemoryPropertyFlags ( StorageMode  mode)
staticconstexpr

Definition at line 19 of file allocator_vk.cc.

19  {
20  switch (mode) {
21  case StorageMode::kHostVisible:
22  return vk::MemoryPropertyFlagBits::eHostVisible;
23  case StorageMode::kDevicePrivate:
24  return vk::MemoryPropertyFlagBits::eDeviceLocal;
25  case StorageMode::kDeviceTransient:
26  return vk::MemoryPropertyFlagBits::eLazilyAllocated;
27  }
28  FML_UNREACHABLE();
29 }

References kDevicePrivate, kDeviceTransient, and kHostVisible.

Referenced by CreateBufferPool().

◆ ToVKColorComponentFlags()

constexpr vk::ColorComponentFlags impeller::ToVKColorComponentFlags ( std::underlying_type_t< ColorWriteMask >  type)
constexpr

Definition at line 73 of file formats_vk.h.

74  {
75  using UnderlyingType = decltype(type);
76 
77  vk::ColorComponentFlags mask;
78 
79  if (type & static_cast<UnderlyingType>(ColorWriteMask::kRed)) {
80  mask |= vk::ColorComponentFlagBits::eR;
81  }
82 
83  if (type & static_cast<UnderlyingType>(ColorWriteMask::kGreen)) {
84  mask |= vk::ColorComponentFlagBits::eG;
85  }
86 
87  if (type & static_cast<UnderlyingType>(ColorWriteMask::kBlue)) {
88  mask |= vk::ColorComponentFlagBits::eB;
89  }
90 
91  if (type & static_cast<UnderlyingType>(ColorWriteMask::kAlpha)) {
92  mask |= vk::ColorComponentFlagBits::eA;
93  }
94 
95  return mask;
96 }

References kAlpha, kBlue, kGreen, and kRed.

Referenced by ToVKPipelineColorBlendAttachmentState().

◆ ToVKCompareOp()

constexpr vk::CompareOp impeller::ToVKCompareOp ( CompareFunction  op)
constexpr

Definition at line 505 of file formats_vk.h.

505  {
506  switch (op) {
507  case CompareFunction::kNever:
508  return vk::CompareOp::eNever;
509  case CompareFunction::kAlways:
510  return vk::CompareOp::eAlways;
511  case CompareFunction::kLess:
512  return vk::CompareOp::eLess;
513  case CompareFunction::kEqual:
514  return vk::CompareOp::eEqual;
515  case CompareFunction::kLessEqual:
516  return vk::CompareOp::eLessOrEqual;
517  case CompareFunction::kGreater:
518  return vk::CompareOp::eGreater;
519  case CompareFunction::kNotEqual:
520  return vk::CompareOp::eNotEqual;
521  case CompareFunction::kGreaterEqual:
522  return vk::CompareOp::eGreaterOrEqual;
523  }
524  FML_UNREACHABLE();
525 }

References kAlways, kEqual, kGreater, kGreaterEqual, kLess, kLessEqual, kNever, and kNotEqual.

Referenced by ToVKPipelineDepthStencilStateCreateInfo(), and ToVKStencilOpState().

◆ ToVKCullModeFlags()

constexpr vk::CullModeFlags impeller::ToVKCullModeFlags ( CullMode  mode)
constexpr

Definition at line 493 of file formats_vk.h.

493  {
494  switch (mode) {
495  case CullMode::kNone:
496  return vk::CullModeFlagBits::eNone;
497  case CullMode::kFrontFace:
498  return vk::CullModeFlagBits::eFront;
499  case CullMode::kBackFace:
500  return vk::CullModeFlagBits::eBack;
501  }
502  FML_UNREACHABLE();
503 }

References kBackFace, kFrontFace, and kNone.

◆ ToVKDescriptorSetLayoutBinding()

constexpr vk::DescriptorSetLayoutBinding impeller::ToVKDescriptorSetLayoutBinding ( const DescriptorSetLayout &  layout)
constexpr

Definition at line 295 of file formats_vk.h.

296  {
297  vk::DescriptorSetLayoutBinding binding;
298  binding.binding = layout.binding;
299  binding.descriptorCount = 1u;
300  binding.descriptorType = ToVKDescriptorType(layout.descriptor_type);
301  binding.stageFlags = ToVkShaderStage(layout.shader_stage);
302  return binding;
303 }

References impeller::DescriptorSetLayout::binding, impeller::DescriptorSetLayout::descriptor_type, impeller::DescriptorSetLayout::shader_stage, ToVKDescriptorType(), and ToVkShaderStage().

◆ ToVKDescriptorType()

constexpr vk::DescriptorType impeller::ToVKDescriptorType ( DescriptorType  type)
constexpr

Definition at line 273 of file formats_vk.h.

273  {
274  switch (type) {
275  case DescriptorType::kSampledImage:
276  return vk::DescriptorType::eCombinedImageSampler;
277  break;
278  case DescriptorType::kUniformBuffer:
279  return vk::DescriptorType::eUniformBuffer;
280  break;
281  case DescriptorType::kStorageBuffer:
282  return vk::DescriptorType::eStorageBuffer;
283  break;
284  case DescriptorType::kImage:
285  return vk::DescriptorType::eSampledImage;
286  break;
287  case DescriptorType::kSampler:
288  return vk::DescriptorType::eSampler;
289  break;
290  }
291 
292  FML_UNREACHABLE();
293 }

References kImage, kSampledImage, kSampler, kStorageBuffer, and kUniformBuffer.

Referenced by AllocateAndBindDescriptorSets(), and ToVKDescriptorSetLayoutBinding().

◆ ToVKFrontFace()

constexpr vk::FrontFace impeller::ToVKFrontFace ( WindingOrder  order)
constexpr

Definition at line 142 of file pipeline_library_vk.cc.

142  {
143  switch (order) {
144  case WindingOrder::kClockwise:
145  return vk::FrontFace::eClockwise;
146  case WindingOrder::kCounterClockwise:
147  return vk::FrontFace::eCounterClockwise;
148  }
149  FML_UNREACHABLE();
150 }

References kClockwise, and kCounterClockwise.

◆ ToVKImageAspectFlags()

constexpr vk::ImageAspectFlags impeller::ToVKImageAspectFlags ( PixelFormat  format)
constexpr

Definition at line 565 of file formats_vk.h.

565  {
566  switch (format) {
567  case PixelFormat::kUnknown:
568  case PixelFormat::kA8UNormInt:
569  case PixelFormat::kR8UNormInt:
570  case PixelFormat::kR8G8UNormInt:
571  case PixelFormat::kR8G8B8A8UNormInt:
572  case PixelFormat::kR8G8B8A8UNormIntSRGB:
573  case PixelFormat::kB8G8R8A8UNormInt:
574  case PixelFormat::kB8G8R8A8UNormIntSRGB:
575  case PixelFormat::kR32G32B32A32Float:
576  case PixelFormat::kR16G16B16A16Float:
577  case PixelFormat::kB10G10R10XR:
578  case PixelFormat::kB10G10R10XRSRGB:
579  case PixelFormat::kB10G10R10A10XR:
580  return vk::ImageAspectFlagBits::eColor;
581  case PixelFormat::kS8UInt:
582  return vk::ImageAspectFlagBits::eStencil;
583  case PixelFormat::kD24UnormS8Uint:
584  case PixelFormat::kD32FloatS8UInt:
585  return vk::ImageAspectFlagBits::eDepth |
586  vk::ImageAspectFlagBits::eStencil;
587  }
588  FML_UNREACHABLE();
589 }

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, and kUnknown.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVKImageCreateFlags()

constexpr vk::ImageCreateFlags impeller::ToVKImageCreateFlags ( TextureType  type)
constexpr

Definition at line 619 of file formats_vk.h.

619  {
620  switch (type) {
621  case TextureType::kTexture2D:
622  case TextureType::kTexture2DMultisample:
623  return {};
624  case TextureType::kTextureCube:
625  return vk::ImageCreateFlagBits::eCubeCompatible;
626  case TextureType::kTextureExternalOES:
627  VALIDATION_LOG
628  << "kTextureExternalOES can not be used with the Vulkan backend.";
629  }
630  FML_UNREACHABLE();
631 }

References kTexture2D, kTexture2DMultisample, kTextureCube, kTextureExternalOES, and VALIDATION_LOG.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVKImageFormat()

constexpr vk::Format impeller::ToVKImageFormat ( PixelFormat  format)
constexpr

Definition at line 136 of file formats_vk.h.

136  {
137  switch (format) {
138  case PixelFormat::kUnknown:
139  case PixelFormat::kB10G10R10XR:
140  case PixelFormat::kB10G10R10A10XR:
141  case PixelFormat::kB10G10R10XRSRGB:
142  return vk::Format::eUndefined;
143  case PixelFormat::kA8UNormInt:
144  // TODO(csg): This is incorrect. Don't depend on swizzle support for GLES.
145  return vk::Format::eR8Unorm;
146  case PixelFormat::kR8G8B8A8UNormInt:
147  return vk::Format::eR8G8B8A8Unorm;
148  case PixelFormat::kR8G8B8A8UNormIntSRGB:
149  return vk::Format::eR8G8B8A8Srgb;
150  case PixelFormat::kB8G8R8A8UNormInt:
151  return vk::Format::eB8G8R8A8Unorm;
152  case PixelFormat::kB8G8R8A8UNormIntSRGB:
153  return vk::Format::eB8G8R8A8Srgb;
154  case PixelFormat::kR32G32B32A32Float:
155  return vk::Format::eR32G32B32A32Sfloat;
156  case PixelFormat::kR16G16B16A16Float:
157  return vk::Format::eR16G16B16A16Sfloat;
158  case PixelFormat::kS8UInt:
159  return vk::Format::eS8Uint;
160  case PixelFormat::kD24UnormS8Uint:
161  return vk::Format::eD24UnormS8Uint;
162  case PixelFormat::kD32FloatS8UInt:
163  return vk::Format::eD32SfloatS8Uint;
164  case PixelFormat::kR8UNormInt:
165  return vk::Format::eR8Unorm;
166  case PixelFormat::kR8G8UNormInt:
167  return vk::Format::eR8G8Unorm;
168  }
169 
170  FML_UNREACHABLE();
171 }

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, and kUnknown.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK(), ChooseSurfaceFormat(), CreateAttachmentDescription(), and impeller::SwapchainImageVK::SwapchainImageVK().

◆ ToVKImageUsageFlags()

static constexpr vk::ImageUsageFlags impeller::ToVKImageUsageFlags ( PixelFormat  format,
TextureUsageMask  usage,
StorageMode  mode,
bool  supports_memoryless_textures 
)
staticconstexpr

Definition at line 166 of file allocator_vk.cc.

170  {
171  vk::ImageUsageFlags vk_usage;
172 
173  switch (mode) {
174  case StorageMode::kHostVisible:
175  case StorageMode::kDevicePrivate:
176  break;
177  case StorageMode::kDeviceTransient:
178  if (supports_memoryless_textures) {
179  vk_usage |= vk::ImageUsageFlagBits::eTransientAttachment;
180  }
181  break;
182  }
183 
184  if (usage & static_cast<TextureUsageMask>(TextureUsage::kRenderTarget)) {
185  if (PixelFormatIsDepthStencil(format)) {
186  vk_usage |= vk::ImageUsageFlagBits::eDepthStencilAttachment;
187  } else {
188  vk_usage |= vk::ImageUsageFlagBits::eColorAttachment;
189  }
190  }
191 
192  if (usage & static_cast<TextureUsageMask>(TextureUsage::kShaderRead)) {
193  vk_usage |= vk::ImageUsageFlagBits::eSampled;
194  // Device transient images can only be used as attachments. The caller
195  // specified incorrect usage flags and is attempting to read a device
196  // transient image in a shader. Unset the transient attachment flag. See:
197  // https://github.com/flutter/flutter/issues/121633
198  if (mode == StorageMode::kDeviceTransient) {
199  vk_usage &= ~vk::ImageUsageFlagBits::eTransientAttachment;
200  }
201  }
202 
203  if (usage & static_cast<TextureUsageMask>(TextureUsage::kShaderWrite)) {
204  vk_usage |= vk::ImageUsageFlagBits::eStorage;
205  // Device transient images can only be used as attachments. The caller
206  // specified incorrect usage flags and is attempting to read a device
207  // transient image in a shader. Unset the transient attachment flag. See:
208  // https://github.com/flutter/flutter/issues/121633
209  if (mode == StorageMode::kDeviceTransient) {
210  vk_usage &= ~vk::ImageUsageFlagBits::eTransientAttachment;
211  }
212  }
213 
214  if (mode != StorageMode::kDeviceTransient) {
215  // Add transfer usage flags to support blit passes only if image isn't
216  // device transient.
217  vk_usage |= vk::ImageUsageFlagBits::eTransferSrc |
218  vk::ImageUsageFlagBits::eTransferDst;
219  }
220 
221  return vk_usage;
222 }

References PixelFormatIsDepthStencil().

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVKImageViewType()

constexpr vk::ImageViewType impeller::ToVKImageViewType ( TextureType  type)
constexpr

Definition at line 605 of file formats_vk.h.

605  {
606  switch (type) {
607  case TextureType::kTexture2D:
608  case TextureType::kTexture2DMultisample:
609  return vk::ImageViewType::e2D;
610  case TextureType::kTextureCube:
611  return vk::ImageViewType::eCube;
612  case TextureType::kTextureExternalOES:
613  VALIDATION_LOG
614  << "kTextureExternalOES can not be used with the Vulkan backend.";
615  }
616  FML_UNREACHABLE();
617 }

References kTexture2D, kTexture2DMultisample, kTextureCube, kTextureExternalOES, and VALIDATION_LOG.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVKIndexType()

constexpr vk::IndexType impeller::ToVKIndexType ( IndexType  index_type)
constexpr

Definition at line 333 of file formats_vk.h.

333  {
334  switch (index_type) {
335  case IndexType::k16bit:
336  return vk::IndexType::eUint16;
337  case IndexType::k32bit:
338  return vk::IndexType::eUint32;
339  case IndexType::kUnknown:
340  return vk::IndexType::eUint32;
341  case IndexType::kNone:
342  FML_UNREACHABLE();
343  }
344 
345  FML_UNREACHABLE();
346 }

References k16bit, k32bit, kNone, and kUnknown.

Referenced by EncodeCommand().

◆ ToVKPipelineColorBlendAttachmentState()

constexpr vk::PipelineColorBlendAttachmentState impeller::ToVKPipelineColorBlendAttachmentState ( const ColorAttachmentDescriptor &  desc)
constexpr

Definition at line 99 of file formats_vk.h.

99  {
100  vk::PipelineColorBlendAttachmentState res;
101 
102  res.setBlendEnable(desc.blending_enabled);
103 
104  res.setSrcColorBlendFactor(ToVKBlendFactor(desc.src_color_blend_factor));
105  res.setColorBlendOp(ToVKBlendOp(desc.color_blend_op));
106  res.setDstColorBlendFactor(ToVKBlendFactor(desc.dst_color_blend_factor));
107 
108  res.setSrcAlphaBlendFactor(ToVKBlendFactor(desc.src_alpha_blend_factor));
109  res.setAlphaBlendOp(ToVKBlendOp(desc.alpha_blend_op));
110  res.setDstAlphaBlendFactor(ToVKBlendFactor(desc.dst_alpha_blend_factor));
111 
112  res.setColorWriteMask(ToVKColorComponentFlags(desc.write_mask));
113 
114  return res;
115 }

References impeller::ColorAttachmentDescriptor::alpha_blend_op, impeller::ColorAttachmentDescriptor::blending_enabled, impeller::ColorAttachmentDescriptor::color_blend_op, impeller::ColorAttachmentDescriptor::dst_alpha_blend_factor, impeller::ColorAttachmentDescriptor::dst_color_blend_factor, impeller::ColorAttachmentDescriptor::src_alpha_blend_factor, impeller::ColorAttachmentDescriptor::src_color_blend_factor, ToVKBlendFactor(), ToVKBlendOp(), ToVKColorComponentFlags(), and impeller::ColorAttachmentDescriptor::write_mask.

◆ ToVKPipelineDepthStencilStateCreateInfo()

vk::PipelineDepthStencilStateCreateInfo impeller::ToVKPipelineDepthStencilStateCreateInfo ( std::optional< DepthAttachmentDescriptor >  depth,
std::optional< StencilAttachmentDescriptor >  front,
std::optional< StencilAttachmentDescriptor >  back 
)

Definition at line 9 of file formats_vk.cc.

12  {
13  vk::PipelineDepthStencilStateCreateInfo info;
14 
15  if (depth.has_value()) {
16  info.depthTestEnable = true;
17  info.depthWriteEnable = depth->depth_write_enabled;
18  info.depthCompareOp = ToVKCompareOp(depth->depth_compare);
19  info.minDepthBounds = 0.0f;
20  info.maxDepthBounds = 1.0f;
21  }
22 
23  if (front.has_value()) {
24  info.stencilTestEnable = true;
25  info.front = ToVKStencilOpState(*front);
26  }
27 
28  if (back.has_value()) {
29  info.stencilTestEnable = true;
30  info.back = ToVKStencilOpState(*back);
31  }
32 
33  return info;
34 }

References ToVKCompareOp(), and ToVKStencilOpState().

◆ ToVKPolygonMode()

constexpr vk::PolygonMode impeller::ToVKPolygonMode ( PolygonMode  mode)
constexpr

Definition at line 348 of file formats_vk.h.

348  {
349  switch (mode) {
350  case PolygonMode::kFill:
351  return vk::PolygonMode::eFill;
352  case PolygonMode::kLine:
353  return vk::PolygonMode::eLine;
354  }
355  FML_UNREACHABLE();
356 }

References kFill, and kLine.

◆ ToVKPrimitiveTopology()

constexpr vk::PrimitiveTopology impeller::ToVKPrimitiveTopology ( PrimitiveType  primitive)
constexpr

Definition at line 358 of file formats_vk.h.

358  {
359  switch (primitive) {
360  case PrimitiveType::kTriangle:
361  return vk::PrimitiveTopology::eTriangleList;
362  case PrimitiveType::kTriangleStrip:
363  return vk::PrimitiveTopology::eTriangleStrip;
364  case PrimitiveType::kLine:
365  return vk::PrimitiveTopology::eLineList;
366  case PrimitiveType::kLineStrip:
367  return vk::PrimitiveTopology::eLineStrip;
368  case PrimitiveType::kPoint:
369  return vk::PrimitiveTopology::ePointList;
370  }
371 
372  FML_UNREACHABLE();
373 }

References kLine, kLineStrip, kPoint, kTriangle, and kTriangleStrip.

◆ ToVKSampleCount()

constexpr vk::SampleCountFlagBits impeller::ToVKSampleCount ( SampleCount  sample_count)
constexpr

Definition at line 204 of file formats_vk.h.

204  {
205  switch (sample_count) {
206  case SampleCount::kCount1:
207  return vk::SampleCountFlagBits::e1;
208  case SampleCount::kCount4:
209  return vk::SampleCountFlagBits::e4;
210  }
211 
212  FML_UNREACHABLE();
213 }

References kCount1, and kCount4.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK(), and CreateAttachmentDescription().

◆ ToVKSampleCountFlagBits()

constexpr vk::SampleCountFlagBits impeller::ToVKSampleCountFlagBits ( SampleCount  count)
constexpr

Definition at line 15 of file formats_vk.h.

15  {
16  switch (count) {
17  case SampleCount::kCount1:
18  return vk::SampleCountFlagBits::e1;
19  case SampleCount::kCount4:
20  return vk::SampleCountFlagBits::e4;
21  }
22  FML_UNREACHABLE();
23 }

References kCount1, and kCount4.

◆ ToVKSamplerAddressMode()

constexpr vk::SamplerAddressMode impeller::ToVKSamplerAddressMode ( SamplerAddressMode  mode)
constexpr

Definition at line 238 of file formats_vk.h.

239  {
240  switch (mode) {
241  case SamplerAddressMode::kRepeat:
242  return vk::SamplerAddressMode::eRepeat;
243  case SamplerAddressMode::kMirror:
244  return vk::SamplerAddressMode::eMirroredRepeat;
245  case SamplerAddressMode::kClampToEdge:
246  return vk::SamplerAddressMode::eClampToEdge;
247  case SamplerAddressMode::kDecal:
248  return vk::SamplerAddressMode::eClampToBorder;
249  }
250 
251  FML_UNREACHABLE();
252 }

References kClampToEdge, kDecal, kMirror, and kRepeat.

◆ ToVKSamplerMinMagFilter()

constexpr vk::Filter impeller::ToVKSamplerMinMagFilter ( MinMagFilter  filter)
constexpr

Definition at line 215 of file formats_vk.h.

215  {
216  switch (filter) {
217  case MinMagFilter::kNearest:
218  return vk::Filter::eNearest;
219  case MinMagFilter::kLinear:
220  return vk::Filter::eLinear;
221  }
222 
223  FML_UNREACHABLE();
224 }

References kLinear, and kNearest.

◆ ToVKSamplerMipmapMode()

constexpr vk::SamplerMipmapMode impeller::ToVKSamplerMipmapMode ( MipFilter  filter)
constexpr

Definition at line 226 of file formats_vk.h.

226  {
227  vk::SamplerCreateInfo sampler_info;
228  switch (filter) {
229  case MipFilter::kNearest:
230  return vk::SamplerMipmapMode::eNearest;
231  case MipFilter::kLinear:
232  return vk::SamplerMipmapMode::eLinear;
233  }
234 
235  FML_UNREACHABLE();
236 }

References kLinear, and kNearest.

◆ ToVkShaderStage()

constexpr vk::ShaderStageFlags impeller::ToVkShaderStage ( ShaderStage  stage)
constexpr

Definition at line 254 of file formats_vk.h.

254  {
255  switch (stage) {
256  case ShaderStage::kUnknown:
257  return vk::ShaderStageFlagBits::eAll;
258  case ShaderStage::kFragment:
259  return vk::ShaderStageFlagBits::eFragment;
260  case ShaderStage::kTessellationControl:
261  return vk::ShaderStageFlagBits::eTessellationControl;
262  case ShaderStage::kTessellationEvaluation:
263  return vk::ShaderStageFlagBits::eTessellationEvaluation;
264  case ShaderStage::kCompute:
265  return vk::ShaderStageFlagBits::eCompute;
266  case ShaderStage::kVertex:
267  return vk::ShaderStageFlagBits::eVertex;
268  }
269 
270  FML_UNREACHABLE();
271 }

References kCompute, kFragment, kTessellationControl, kTessellationEvaluation, kUnknown, and kVertex.

Referenced by ToVKDescriptorSetLayoutBinding().

◆ ToVKShaderStageFlagBits()

constexpr std::optional<vk::ShaderStageFlagBits> impeller::ToVKShaderStageFlagBits ( ShaderStage  stage)
constexpr

Definition at line 117 of file formats_vk.h.

118  {
119  switch (stage) {
120  case ShaderStage::kUnknown:
121  return std::nullopt;
122  case ShaderStage::kVertex:
123  return vk::ShaderStageFlagBits::eVertex;
124  case ShaderStage::kFragment:
125  return vk::ShaderStageFlagBits::eFragment;
126  case ShaderStage::kTessellationControl:
127  return vk::ShaderStageFlagBits::eTessellationControl;
128  case ShaderStage::kTessellationEvaluation:
129  return vk::ShaderStageFlagBits::eTessellationEvaluation;
130  case ShaderStage::kCompute:
131  return vk::ShaderStageFlagBits::eCompute;
132  }
133  FML_UNREACHABLE();
134 }

References kCompute, kFragment, kTessellationControl, kTessellationEvaluation, kUnknown, and kVertex.

◆ ToVKStencilOp()

constexpr vk::StencilOp impeller::ToVKStencilOp ( StencilOperation  op)
constexpr

Definition at line 527 of file formats_vk.h.

527  {
528  switch (op) {
529  case StencilOperation::kKeep:
530  return vk::StencilOp::eKeep;
531  case StencilOperation::kZero:
532  return vk::StencilOp::eZero;
533  case StencilOperation::kSetToReferenceValue:
534  return vk::StencilOp::eReplace;
535  case StencilOperation::kIncrementClamp:
536  return vk::StencilOp::eIncrementAndClamp;
537  case StencilOperation::kDecrementClamp:
538  return vk::StencilOp::eDecrementAndClamp;
539  case StencilOperation::kInvert:
540  return vk::StencilOp::eInvert;
541  case StencilOperation::kIncrementWrap:
542  return vk::StencilOp::eIncrementAndWrap;
543  case StencilOperation::kDecrementWrap:
544  return vk::StencilOp::eDecrementAndWrap;
545  break;
546  }
547  FML_UNREACHABLE();
548 }

References kDecrementClamp, kDecrementWrap, kIncrementClamp, kIncrementWrap, kInvert, kKeep, kSetToReferenceValue, and kZero.

Referenced by ToVKStencilOpState().

◆ ToVKStencilOpState()

constexpr vk::StencilOpState impeller::ToVKStencilOpState ( const StencilAttachmentDescriptor &  desc)
constexpr

Definition at line 550 of file formats_vk.h.

551  {
552  vk::StencilOpState state;
553  state.failOp = ToVKStencilOp(desc.stencil_failure);
554  state.passOp = ToVKStencilOp(desc.depth_stencil_pass);
555  state.depthFailOp = ToVKStencilOp(desc.depth_failure);
556  state.compareOp = ToVKCompareOp(desc.stencil_compare);
557  state.compareMask = desc.read_mask;
558  state.writeMask = desc.write_mask;
559  // This is irrelevant as the stencil references are always dynamic state and
560  // will be set in the render pass.
561  state.reference = 1988;
562  return state;
563 }

References impeller::StencilAttachmentDescriptor::depth_failure, impeller::StencilAttachmentDescriptor::depth_stencil_pass, impeller::StencilAttachmentDescriptor::read_mask, impeller::StencilAttachmentDescriptor::stencil_compare, impeller::StencilAttachmentDescriptor::stencil_failure, ToVKCompareOp(), ToVKStencilOp(), and impeller::StencilAttachmentDescriptor::write_mask.

Referenced by ToVKPipelineDepthStencilStateCreateInfo().

◆ ToVKTextureMemoryPropertyFlags()

static constexpr vk::Flags<vk::MemoryPropertyFlagBits> impeller::ToVKTextureMemoryPropertyFlags ( StorageMode  mode,
bool  supports_memoryless_textures 
)
staticconstexpr

Definition at line 229 of file allocator_vk.cc.

230  {
231  switch (mode) {
232  case StorageMode::kHostVisible:
233  return vk::MemoryPropertyFlagBits::eHostVisible |
234  vk::MemoryPropertyFlagBits::eDeviceLocal;
235  case StorageMode::kDevicePrivate:
236  return vk::MemoryPropertyFlagBits::eDeviceLocal;
237  case StorageMode::kDeviceTransient:
238  if (supports_memoryless_textures) {
239  return vk::MemoryPropertyFlagBits::eLazilyAllocated |
240  vk::MemoryPropertyFlagBits::eDeviceLocal;
241  }
242  return vk::MemoryPropertyFlagBits::eDeviceLocal;
243  }
244  FML_UNREACHABLE();
245 }

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVmaAllocationBufferCreateFlags()

static VmaAllocationCreateFlags impeller::ToVmaAllocationBufferCreateFlags ( StorageMode  mode)
static

Definition at line 31 of file allocator_vk.cc.

32  {
33  VmaAllocationCreateFlags flags = 0;
34  switch (mode) {
35  case StorageMode::kHostVisible:
36  flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
37  flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
38  return flags;
39  case StorageMode::kDevicePrivate:
40  return flags;
41  case StorageMode::kDeviceTransient:
42  return flags;
43  }
44  FML_UNREACHABLE();
45 }

References kDevicePrivate, kDeviceTransient, and kHostVisible.

Referenced by CreateBufferPool().

◆ ToVmaAllocationCreateFlags()

static VmaAllocationCreateFlags impeller::ToVmaAllocationCreateFlags ( StorageMode  mode)
static

Definition at line 247 of file allocator_vk.cc.

247  {
248  VmaAllocationCreateFlags flags = 0;
249  switch (mode) {
250  case StorageMode::kHostVisible:
251  return flags;
252  case StorageMode::kDevicePrivate:
253  return flags;
254  case StorageMode::kDeviceTransient:
255  return flags;
256  }
257  FML_UNREACHABLE();
258 }

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVMAMemoryUsage()

static constexpr VmaMemoryUsage impeller::ToVMAMemoryUsage ( )
staticconstexpr

Definition at line 224 of file allocator_vk.cc.

224  {
225  return VMA_MEMORY_USAGE_AUTO;
226 }

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ UpdateAtlasBitmap() [1/2]

static bool impeller::UpdateAtlasBitmap ( const GlyphAtlas &  atlas,
const std::shared_ptr< BitmapSTB > &  bitmap,
const std::vector< FontGlyphPair > &  new_pairs 
)
static

Definition at line 273 of file typographer_context_stb.cc.

275  {
276  TRACE_EVENT0("impeller", __FUNCTION__);
277  FML_DCHECK(bitmap != nullptr);
278 
279  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
280 
281  for (const FontGlyphPair& pair : new_pairs) {
282  auto pos = atlas.FindFontGlyphBounds(pair);
283  if (!pos.has_value()) {
284  continue;
285  }
286  DrawGlyph(bitmap.get(), pair.scaled_font, pair.glyph, pos.value(),
287  has_color);
288  }
289  return true;
290 }

References DrawGlyph(), impeller::GlyphAtlas::FindFontGlyphBounds(), impeller::GlyphAtlas::GetType(), and impeller::GlyphAtlas::kColorBitmap.

◆ UpdateAtlasBitmap() [2/2]

static bool impeller::UpdateAtlasBitmap ( const GlyphAtlas &  atlas,
const std::shared_ptr< SkBitmap > &  bitmap,
const std::vector< FontGlyphPair > &  new_pairs 
)
static

Definition at line 188 of file typographer_context_skia.cc.

190  {
191  TRACE_EVENT0("impeller", __FUNCTION__);
192  FML_DCHECK(bitmap != nullptr);
193 
194  auto surface = SkSurfaces::WrapPixels(bitmap->pixmap());
195  if (!surface) {
196  return false;
197  }
198  auto canvas = surface->getCanvas();
199  if (!canvas) {
200  return false;
201  }
202 
203  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
204 
205  for (const FontGlyphPair& pair : new_pairs) {
206  auto pos = atlas.FindFontGlyphBounds(pair);
207  if (!pos.has_value()) {
208  continue;
209  }
210  DrawGlyph(canvas, pair.scaled_font, pair.glyph, pos.value(), has_color);
211  }
212  return true;
213 }

References DrawGlyph(), impeller::GlyphAtlas::FindFontGlyphBounds(), impeller::GlyphAtlas::GetType(), and impeller::GlyphAtlas::kColorBitmap.

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas(), and impeller::TypographerContextSTB::CreateGlyphAtlas().

◆ UpdateBindingLayouts() [1/6]

static bool impeller::UpdateBindingLayouts ( const Bindings &  bindings,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 35 of file compute_pass_vk.cc.

36  {
37  BarrierVK barrier;
38  barrier.cmd_buffer = buffer;
39  barrier.src_access = vk::AccessFlagBits::eTransferWrite;
40  barrier.src_stage = vk::PipelineStageFlagBits::eTransfer;
41  barrier.dst_access = vk::AccessFlagBits::eShaderRead;
42  barrier.dst_stage = vk::PipelineStageFlagBits::eComputeShader;
43 
44  barrier.new_layout = vk::ImageLayout::eShaderReadOnlyOptimal;
45 
46  for (const auto& [_, data] : bindings.sampled_images) {
47  if (!TextureVK::Cast(*data.texture.resource).SetLayout(barrier)) {
48  return false;
49  }
50  }
51  return true;
52 }

References impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::BarrierVK::cmd_buffer, impeller::BarrierVK::dst_access, impeller::BarrierVK::dst_stage, impeller::BarrierVK::new_layout, impeller::Bindings::sampled_images, impeller::TextureVK::SetLayout(), impeller::BarrierVK::src_access, and impeller::BarrierVK::src_stage.

Referenced by UpdateBindingLayouts().

◆ UpdateBindingLayouts() [2/6]

static bool impeller::UpdateBindingLayouts ( const Bindings &  bindings,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 287 of file render_pass_vk.cc.

288  {
289  // All previous writes via a render or blit pass must be done before another
290  // shader attempts to read the resource.
291  BarrierVK barrier;
292  barrier.cmd_buffer = buffer;
293  barrier.src_access = vk::AccessFlagBits::eColorAttachmentWrite |
294  vk::AccessFlagBits::eTransferWrite;
295  barrier.src_stage = vk::PipelineStageFlagBits::eColorAttachmentOutput |
296  vk::PipelineStageFlagBits::eTransfer;
297  barrier.dst_access = vk::AccessFlagBits::eShaderRead;
298  barrier.dst_stage = vk::PipelineStageFlagBits::eFragmentShader;
299 
300  barrier.new_layout = vk::ImageLayout::eShaderReadOnlyOptimal;
301 
302  for (const auto& [_, data] : bindings.sampled_images) {
303  if (!TextureVK::Cast(*data.texture.resource).SetLayout(barrier)) {
304  return false;
305  }
306  }
307  return true;
308 }

References impeller::BarrierVK::cmd_buffer, impeller::BarrierVK::dst_access, impeller::BarrierVK::dst_stage, impeller::BarrierVK::new_layout, impeller::Bindings::sampled_images, impeller::BarrierVK::src_access, and impeller::BarrierVK::src_stage.

◆ UpdateBindingLayouts() [3/6]

static bool impeller::UpdateBindingLayouts ( const Command &  command,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 310 of file render_pass_vk.cc.

311  {
312  return UpdateBindingLayouts(command.vertex_bindings, buffer) &&
313  UpdateBindingLayouts(command.fragment_bindings, buffer);
314 }

References impeller::Command::fragment_bindings, UpdateBindingLayouts(), and impeller::Command::vertex_bindings.

◆ UpdateBindingLayouts() [4/6]

static bool impeller::UpdateBindingLayouts ( const ComputeCommand &  command,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 54 of file compute_pass_vk.cc.

55  {
56  return UpdateBindingLayouts(command.bindings, buffer);
57 }

References impeller::ComputeCommand::bindings, and UpdateBindingLayouts().

◆ UpdateBindingLayouts() [5/6]

static bool impeller::UpdateBindingLayouts ( const std::vector< Command > &  commands,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 316 of file render_pass_vk.cc.

317  {
318  for (const auto& command : commands) {
319  if (!UpdateBindingLayouts(command, buffer)) {
320  return false;
321  }
322  }
323  return true;
324 }

Referenced by UpdateBindingLayouts().

◆ UpdateBindingLayouts() [6/6]

static bool impeller::UpdateBindingLayouts ( const std::vector< ComputeCommand > &  commands,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 59 of file compute_pass_vk.cc.

60  {
61  for (const auto& command : commands) {
62  if (!UpdateBindingLayouts(command, buffer)) {
63  return false;
64  }
65  }
66  return true;
67 }

References UpdateBindingLayouts().

◆ UpdateGlyphTextureAtlas() [1/2]

static bool impeller::UpdateGlyphTextureAtlas ( std::shared_ptr< BitmapSTB > &  bitmap,
const std::shared_ptr< Texture > &  texture 
)
static

Definition at line 317 of file typographer_context_stb.cc.

318  {
319  TRACE_EVENT0("impeller", __FUNCTION__);
320 
321  FML_DCHECK(bitmap != nullptr);
322 
323  auto texture_descriptor = texture->GetTextureDescriptor();
324 
325  auto mapping = std::make_shared<fml::NonOwnedMapping>(
326  reinterpret_cast<const uint8_t*>(bitmap->GetPixels()), // data
327  texture_descriptor.GetByteSizeOfBaseMipLevel() // size
328  // As the bitmap is static in this module I believe we don't need to
329  // specify a release proc.
330  );
331 
332  return texture->SetContents(mapping);
333 }

◆ UpdateGlyphTextureAtlas() [2/2]

static bool impeller::UpdateGlyphTextureAtlas ( std::shared_ptr< SkBitmap >  bitmap,
const std::shared_ptr< Texture > &  texture 
)
static

Definition at line 256 of file typographer_context_skia.cc.

257  {
258  TRACE_EVENT0("impeller", __FUNCTION__);
259 
260  FML_DCHECK(bitmap != nullptr);
261  auto texture_descriptor = texture->GetTextureDescriptor();
262 
263  auto mapping = std::make_shared<fml::NonOwnedMapping>(
264  reinterpret_cast<const uint8_t*>(bitmap->getAddr(0, 0)), // data
265  texture_descriptor.GetByteSizeOfBaseMipLevel(), // size
266  [bitmap](auto, auto) mutable { bitmap.reset(); } // proc
267  );
268 
269  return texture->SetContents(mapping);
270 }

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas(), and impeller::TypographerContextSTB::CreateGlyphAtlas().

◆ UploadGlyphTextureAtlas() [1/2]

static std::shared_ptr<Texture> impeller::UploadGlyphTextureAtlas ( const std::shared_ptr< Allocator > &  allocator,
std::shared_ptr< BitmapSTB > &  bitmap,
const ISize &  atlas_size,
PixelFormat  format 
)
static

Definition at line 335 of file typographer_context_stb.cc.

339  {
340  TRACE_EVENT0("impeller", __FUNCTION__);
341  if (!allocator) {
342  return nullptr;
343  }
344 
345  FML_DCHECK(bitmap != nullptr);
346 
347  TextureDescriptor texture_descriptor;
348  texture_descriptor.storage_mode = StorageMode::kHostVisible;
349  texture_descriptor.format = format;
350  texture_descriptor.size = atlas_size;
351 
352  if (bitmap->GetRowBytes() * bitmap->GetHeight() !=
353  texture_descriptor.GetByteSizeOfBaseMipLevel()) {
354  return nullptr;
355  }
356 
357  auto texture = allocator->CreateTexture(texture_descriptor);
358  if (!texture || !texture->IsValid()) {
359  return nullptr;
360  }
361  texture->SetLabel("GlyphAtlas");
362 
363  auto mapping = std::make_shared<fml::NonOwnedMapping>(
364  reinterpret_cast<const uint8_t*>(bitmap->GetPixels()), // data
365  texture_descriptor.GetByteSizeOfBaseMipLevel() // size
366  // As the bitmap is static in this module I believe we don't need to
367  // specify a release proc.
368  );
369 
370  if (!texture->SetContents(mapping)) {
371  return nullptr;
372  }
373  return texture;
374 }

References impeller::TextureDescriptor::format, impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), kHostVisible, impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

◆ UploadGlyphTextureAtlas() [2/2]

static std::shared_ptr<Texture> impeller::UploadGlyphTextureAtlas ( const std::shared_ptr< Allocator > &  allocator,
std::shared_ptr< SkBitmap >  bitmap,
const ISize &  atlas_size,
PixelFormat  format 
)
static

Definition at line 272 of file typographer_context_skia.cc.

276  {
277  TRACE_EVENT0("impeller", __FUNCTION__);
278  if (!allocator) {
279  return nullptr;
280  }
281 
282  FML_DCHECK(bitmap != nullptr);
283  const auto& pixmap = bitmap->pixmap();
284 
285  TextureDescriptor texture_descriptor;
286  texture_descriptor.storage_mode = StorageMode::kHostVisible;
287  texture_descriptor.format = format;
288  texture_descriptor.size = atlas_size;
289 
290  if (pixmap.rowBytes() * pixmap.height() !=
291  texture_descriptor.GetByteSizeOfBaseMipLevel()) {
292  return nullptr;
293  }
294 
295  auto texture = allocator->CreateTexture(texture_descriptor);
296  if (!texture || !texture->IsValid()) {
297  return nullptr;
298  }
299  texture->SetLabel("GlyphAtlas");
300 
301  auto mapping = std::make_shared<fml::NonOwnedMapping>(
302  reinterpret_cast<const uint8_t*>(bitmap->getAddr(0, 0)), // data
303  texture_descriptor.GetByteSizeOfBaseMipLevel(), // size
304  [bitmap](auto, auto) mutable { bitmap.reset(); } // proc
305  );
306 
307  if (!texture->SetContents(mapping)) {
308  return nullptr;
309  }
310  return texture;
311 }

References impeller::TextureDescriptor::format, impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), kHostVisible, impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas(), and impeller::TypographerContextSTB::CreateGlyphAtlas().

◆ UseColorSourceContents()

static bool impeller::UseColorSourceContents ( const std::shared_ptr< VerticesGeometry > &  vertices,
const Paint &  paint 
)
static

Definition at line 575 of file canvas.cc.

577  {
578  // If there are no vertex color or texture coordinates. Or if there
579  // are vertex coordinates then only if the contents are an image or
580  // a solid color.
581  if (vertices->HasVertexColors()) {
582  return false;
583  }
584  if (vertices->HasTextureCoordinates() &&
585  (paint.color_source.GetType() == ColorSource::Type::kImage ||
586  paint.color_source.GetType() == ColorSource::Type::kColor)) {
587  return true;
588  }
589  return !vertices->HasTextureCoordinates();
590 }

References impeller::Paint::color_source, impeller::ColorSource::GetType(), impeller::ColorSource::kColor, and impeller::ColorSource::kImage.

Referenced by impeller::Canvas::DrawVertices().

◆ ValidateBlendModes()

static constexpr bool impeller::ValidateBlendModes ( )
inlinestaticconstexpr

Definition at line 28 of file color.cc.

28  {
29  std::underlying_type_t<BlendMode> i = 0;
30  // Ensure the order of the blend modes match.
31  IMPELLER_FOR_EACH_BLEND_MODE(_IMPELLER_ASSERT_BLEND_MODE)
32  // Ensure the total number of blend modes match.
33  if (i - 1 !=
34  static_cast<std::underlying_type_t<BlendMode>>(BlendMode::kLast)) {
35  return false;
36  }
37  return true;
38 }

References _IMPELLER_ASSERT_BLEND_MODE, IMPELLER_FOR_EACH_BLEND_MODE, and kLast.

◆ VerifyExistingCache()

static bool impeller::VerifyExistingCache ( const fml::Mapping &  mapping,
const CapabilitiesVK &  caps 
)
static

Definition at line 19 of file pipeline_cache_vk.cc.

20  {
21  return true;
22 }

Referenced by OpenCacheFile().

◆ VKClearValueFromColor()

static vk::ClearColorValue impeller::VKClearValueFromColor ( Color  color)
static

Definition at line 198 of file render_pass_vk.cc.

198  {
199  vk::ClearColorValue value;
200  value.setFloat32(
201  std::array<float, 4>{color.red, color.green, color.blue, color.alpha});
202  return value;
203 }

References impeller::Color::alpha, impeller::Color::blue, impeller::Color::green, and impeller::Color::red.

Referenced by GetVKClearValues().

◆ VKClearValueFromDepthStencil()

static vk::ClearDepthStencilValue impeller::VKClearValueFromDepthStencil ( uint32_t  stencil,
Scalar  depth 
)
static

Definition at line 205 of file render_pass_vk.cc.

206  {
207  vk::ClearDepthStencilValue value;
208  value.depth = depth;
209  value.stencil = stencil;
210  return value;
211 }

Referenced by GetVKClearValues().

◆ VKShaderNameToShaderKeyName()

static std::string impeller::VKShaderNameToShaderKeyName ( const std::string &  name,
ShaderStage  stage 
)
static

Definition at line 27 of file shader_library_vk.cc.

28  {
29  std::stringstream stream;
30  stream << name;
31  switch (stage) {
32  case ShaderStage::kUnknown:
33  stream << "_unknown_";
34  break;
35  case ShaderStage::kVertex:
36  stream << "_vertex_";
37  break;
38  case ShaderStage::kFragment:
39  stream << "_fragment_";
40  break;
41  case ShaderStage::kTessellationControl:
42  stream << "_tessellation_control_";
43  break;
44  case ShaderStage::kTessellationEvaluation:
45  stream << "_tessellation_evaluation_";
46  break;
47  case ShaderStage::kCompute:
48  stream << "_compute_";
49  break;
50  }
51  stream << "main";
52  return stream.str();
53 }

References kCompute, kFragment, kTessellationControl, kTessellationEvaluation, kUnknown, and kVertex.

◆ WrappedResolver()

ProcTableGLES::Resolver impeller::WrappedResolver ( const ProcTableGLES::Resolver &  resolver)

Definition at line 35 of file proc_table_gles.cc.

36  {
37  return [resolver](const char* function_name) -> void* {
38  auto resolved = resolver(function_name);
39  if (resolved) {
40  return resolved;
41  }
42  // If there are certain known suffixes (usually for extensions), strip them
43  // out and try to resolve the same proc addresses again.
44  auto function = std::string{function_name};
45  if (function.find("KHR", function.size() - 3) != std::string::npos) {
46  auto truncated = function.substr(0u, function.size() - 3);
47  return resolver(truncated.c_str());
48  }
49  if (function.find("EXT", function.size() - 3) != std::string::npos) {
50  auto truncated = function.substr(0u, function.size() - 3);
51  return resolver(truncated.c_str());
52  }
53  return nullptr;
54  };
55 }

Referenced by impeller::ProcTableGLES::ProcTableGLES().

◆ WrapperMTL()

std::shared_ptr<Texture> impeller::WrapperMTL ( TextureDescriptor  desc,
const void *  mtl_texture,
std::function< void()>  deletion_proc 
)

Definition at line 12 of file texture_mtl.mm.

14  {
15  return TextureMTL::Wrapper(desc, (__bridge id<MTLTexture>)mtl_texture,
16  std::move(deletion_proc));
17 }

References impeller::TextureMTL::Wrapper().

◆ WrapTextureMTL()

std::shared_ptr< Texture > impeller::WrapTextureMTL ( TextureDescriptor  desc,
const void *  mtl_texture,
std::function< void()>  deletion_proc = nullptr 
)

Definition at line 14 of file texture_wrapper_mtl.mm.

16  {
17  auto texture = (__bridge id<MTLTexture>)mtl_texture;
18  desc.format = FromMTLPixelFormat(texture.pixelFormat);
19  return TextureMTL::Wrapper(desc, texture, std::move(deletion_proc));
20 }

References impeller::TextureDescriptor::format, FromMTLPixelFormat(), and impeller::TextureMTL::Wrapper().

◆ WrapTextureWithRenderTarget()

static std::optional<RenderTarget> impeller::WrapTextureWithRenderTarget ( Allocator &  allocator,
id< MTLTexture >  texture,
bool  requires_blit,
std::optional< IRect >  clip_rect 
)
static

Definition at line 43 of file surface_mtl.mm.

47  {
48  // compositor_context.cc will offset the rendering by the clip origin. Here we
49  // shrink to the size of the clip. This has the same effect as clipping the
50  // rendering but also creates smaller intermediate passes.
51  ISize root_size;
52  if (requires_blit) {
53  if (!clip_rect.has_value()) {
54  VALIDATION_LOG << "Missing clip rectangle.";
55  return std::nullopt;
56  }
57  root_size = ISize(clip_rect->size.width, clip_rect->size.height);
58  } else {
59  root_size = {static_cast<ISize::Type>(texture.width),
60  static_cast<ISize::Type>(texture.height)};
61  }
62 
63  TextureDescriptor resolve_tex_desc;
64  resolve_tex_desc.format = FromMTLPixelFormat(texture.pixelFormat);
65  resolve_tex_desc.size = root_size;
66  resolve_tex_desc.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget) |
67  static_cast<uint64_t>(TextureUsage::kShaderRead);
68  resolve_tex_desc.sample_count = SampleCount::kCount1;
69  resolve_tex_desc.storage_mode = StorageMode::kDevicePrivate;
70 
71  if (resolve_tex_desc.format == PixelFormat::kUnknown) {
72  VALIDATION_LOG << "Unknown drawable color format.";
73  return std::nullopt;
74  }
75 
76  // Create color resolve texture.
77  std::shared_ptr<Texture> resolve_tex;
78  if (requires_blit) {
79  resolve_tex_desc.compression_type = CompressionType::kLossy;
80  resolve_tex = allocator.CreateTexture(resolve_tex_desc);
81  } else {
82  resolve_tex = std::make_shared<TextureMTL>(resolve_tex_desc, texture);
83  }
84 
85  if (!resolve_tex) {
86  VALIDATION_LOG << "Could not wrap resolve texture.";
87  return std::nullopt;
88  }
89  resolve_tex->SetLabel("ImpellerOnscreenResolve");
90 
91  TextureDescriptor msaa_tex_desc;
92  msaa_tex_desc.storage_mode = StorageMode::kDeviceTransient;
93  msaa_tex_desc.type = TextureType::kTexture2DMultisample;
94  msaa_tex_desc.sample_count = SampleCount::kCount4;
95  msaa_tex_desc.format = resolve_tex->GetTextureDescriptor().format;
96  msaa_tex_desc.size = resolve_tex->GetSize();
97  msaa_tex_desc.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget);
98 
99  auto msaa_tex = allocator.CreateTexture(msaa_tex_desc);
100  if (!msaa_tex) {
101  VALIDATION_LOG << "Could not allocate MSAA color texture.";
102  return std::nullopt;
103  }
104  msaa_tex->SetLabel("ImpellerOnscreenColorMSAA");
105 
106  ColorAttachment color0;
107  color0.texture = msaa_tex;
108  color0.clear_color = Color::DarkSlateGray();
109  color0.load_action = LoadAction::kClear;
110  color0.store_action = StoreAction::kMultisampleResolve;
111  color0.resolve_texture = std::move(resolve_tex);
112 
113  auto render_target_desc = std::make_optional<RenderTarget>();
114  render_target_desc->SetColorAttachment(color0, 0u);
115 
116  return render_target_desc;
117 }

References impeller::ColorAttachment::clear_color, impeller::TextureDescriptor::compression_type, impeller::Allocator::CreateTexture(), impeller::Color::DarkSlateGray(), impeller::TextureDescriptor::format, FromMTLPixelFormat(), kClear, kCount1, kCount4, kDevicePrivate, kDeviceTransient, kLossy, kMultisampleResolve, kRenderTarget, kShaderRead, kTexture2DMultisample, kUnknown, impeller::Attachment::load_action, impeller::Attachment::resolve_texture, impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, impeller::Attachment::texture, impeller::TextureDescriptor::type, impeller::TextureDescriptor::usage, and VALIDATION_LOG.

Referenced by impeller::SurfaceMTL::MakeFromTexture().

Variable Documentation

◆ g_all_pools_map_mutex

Mutex impeller::g_all_pools_map_mutex
static

Definition at line 138 of file command_pool_vk.cc.

Referenced by impeller::CommandPoolRecyclerVK::DestroyThreadLocalPools(), and impeller::CommandPoolRecyclerVK::Get().

◆ gHasValidationLayers

bool impeller::gHasValidationLayers = false
static

Definition at line 38 of file context_vk.cc.

Referenced by HasValidationLayers().

◆ gShouldOpenNewPlaygrounds

std::atomic_bool impeller::gShouldOpenNewPlaygrounds = true
static

Definition at line 150 of file playground.cc.

Referenced by PlaygroundKeyCallback(), and impeller::Playground::ShouldOpenNewPlaygrounds().

◆ k1OverPi

constexpr float impeller::k1OverPi = 0.31830988618379067154f
constexpr

Definition at line 37 of file constants.h.

◆ k1OverSqrt2

constexpr float impeller::k1OverSqrt2 = 0.70710678118654752440f
constexpr

Definition at line 49 of file constants.h.

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

◆ k2OverPi

constexpr float impeller::k2OverPi = 0.63661977236758134308f
constexpr

Definition at line 40 of file constants.h.

◆ k2OverSqrtPi

constexpr float impeller::k2OverSqrtPi = 1.12837916709551257390f
constexpr

Definition at line 43 of file constants.h.

◆ k2Pi

constexpr float impeller::k2Pi = 6.28318530717958647693f
constexpr

Definition at line 28 of file constants.h.

Referenced by impeller::PathBuilder::AddArc(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ kAlloc

const TESSalloc impeller::kAlloc
static
Initial value:
= {
HeapAlloc, HeapRealloc, HeapFree, 0,
16,
16,
16,
16,
16,
0
}

Definition at line 24 of file tessellator.cc.

Referenced by impeller::Tessellator::Tessellator().

◆ kArchivePrimaryKeyColumnName

constexpr const char* impeller::kArchivePrimaryKeyColumnName = "primary_key"
staticconstexpr

Definition at line 15 of file archive_class_registration.cc.

Referenced by impeller::ArchiveClassRegistration::CreateQueryStatement().

◆ kBlendModeNames

constexpr const char* impeller::kBlendModeNames[]
staticconstexpr
Initial value:
= {
IMPELLER_FOR_EACH_BLEND_MODE(_IMPELLER_BLEND_MODE_NAME_LIST)}

Definition at line 44 of file color.cc.

Referenced by BlendModeToString().

◆ kColorInversion

constexpr ColorMatrix impeller::kColorInversion
constexpr
Initial value:
= {
.array = {
-1.0, 0, 0, 1.0, 0,
0, -1.0, 0, 1.0, 0,
0, 0, -1.0, 1.0, 0,
1.0, 1.0, 1.0, 1.0, 0
}
}

A color matrix which inverts colors.

Definition at line 131 of file paint.cc.

◆ kDefaultCurveTolerance

constexpr Scalar impeller::kDefaultCurveTolerance = .1f
staticconstexpr

Definition at line 25 of file path_component.h.

Referenced by impeller::QuadraticPathComponent::FillPointsForPolyline().

◆ kE

constexpr float impeller::kE = 2.7182818284590452354f
constexpr

Definition at line 10 of file constants.h.

◆ kEhCloseEnough

constexpr float impeller::kEhCloseEnough = 1e-3f
constexpr

Definition at line 55 of file constants.h.

Referenced by impeller::Color::Blend(), ClipColor(), impeller::VerticesGeometry::GetPositionUVBuffer(), and impeller::TextureContents::RenderToSnapshot().

◆ kElementsWindowName

const char* impeller::kElementsWindowName = "Elements"
static

Definition at line 17 of file aiks_playground_inspector.cc.

◆ kImageSizeThresholdForDedicatedMemoryAllocation

constexpr size_t impeller::kImageSizeThresholdForDedicatedMemoryAllocation
constexpr
Initial value:
=
4 * 1024 * 1024

Definition at line 11 of file limits_vk.h.

◆ kInstanceLayer

constexpr const char* impeller::kInstanceLayer = "ImpellerInstance"
staticconstexpr

Definition at line 15 of file capabilities_vk.cc.

Referenced by impeller::CapabilitiesVK::CapabilitiesVK().

◆ kKernelRadiusPerSigma

constexpr static float impeller::kKernelRadiusPerSigma = 1.73205080757
staticconstexpr

For filters that use a Gaussian distribution, this is the Radius size to use per Sigma (standard deviation).

This cutoff (sqrt(3)) is taken from Flutter and Skia (where the multiplicative inverse of this constant is used (1 / sqrt(3)): https://api.flutter.dev/flutter/dart-ui/Shadow/convertRadiusToSigma.html

In practice, this value is somewhat arbitrary, and can be changed to a higher number to integrate more of the Gaussian function and render higher quality blurs (with exponentially diminishing returns for the same sigma input). Making this value any lower results in a noticable loss of quality in the blur.

Definition at line 23 of file sigma.h.

Referenced by impeller::Sigma::operator Radius(), and impeller::Radius::operator Sigma().

◆ kLog10_E

constexpr float impeller::kLog10_E = 0.43429448190325182765f
constexpr

Definition at line 16 of file constants.h.

◆ kLog2_E

constexpr float impeller::kLog2_E = 1.4426950408889634074f
constexpr

Definition at line 13 of file constants.h.

◆ klogE_10

constexpr float impeller::klogE_10 = 2.30258509299404568402f
constexpr

Definition at line 22 of file constants.h.

◆ klogE_2

constexpr float impeller::klogE_2 = 0.69314718055994530942f
constexpr

Definition at line 19 of file constants.h.

◆ kMatrixBT601FullRange

constexpr Matrix impeller::kMatrixBT601FullRange
constexpr
Initial value:
= {
1.0, 1.0, 1.0, 0.0,
0.0, -0.344, 1.772, 0.0,
1.402, -0.714, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0
}

Definition at line 24 of file yuv_to_rgb_filter_contents.cc.

◆ kMatrixBT601LimitedRange

constexpr Matrix impeller::kMatrixBT601LimitedRange
constexpr
Initial value:
= {
1.164, 1.164, 1.164, 0.0,
0.0, -0.392, 2.017, 0.0,
1.596, -0.813, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0
}

Definition at line 17 of file yuv_to_rgb_filter_contents.cc.

◆ kMaxFramesInFlight

constexpr size_t impeller::kMaxFramesInFlight = 3u
staticconstexpr

Definition at line 17 of file swapchain_impl_vk.cc.

◆ kPadding

constexpr size_t impeller::kPadding = 2
constexpr

Definition at line 28 of file typographer_context_skia.cc.

Referenced by CanAppendToExistingAtlas(), DrawGlyph(), and PairsFitInAtlasOfSize().

◆ kPhi

constexpr float impeller::kPhi = 1.61803398874989484820f
constexpr

Definition at line 52 of file constants.h.

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

◆ kPi

constexpr float impeller::kPi = 3.14159265358979323846f
constexpr

Definition at line 25 of file constants.h.

Referenced by impeller::Degrees::operator Radians(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ kPiOver2

constexpr float impeller::kPiOver2 = 1.57079632679489661923f
constexpr

Definition at line 31 of file constants.h.

Referenced by impeller::PathBuilder::AddArc(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ kPiOver4

constexpr float impeller::kPiOver4 = 0.78539816339744830962f
constexpr

Definition at line 34 of file constants.h.

Referenced by impeller::testing::TEST(), and impeller::scene::testing::TEST_P().

◆ kPipelineCacheFileName

constexpr const char* impeller::kPipelineCacheFileName
staticconstexpr
Initial value:
=
"flutter.impeller.vkcache"

Definition at line 16 of file pipeline_cache_vk.cc.

Referenced by impeller::PipelineCacheVK::PersistCacheToDisk(), and impeller::PipelineCacheVK::PipelineCacheVK().

◆ kPollFramesForOrientation

constexpr size_t impeller::kPollFramesForOrientation = 1u
staticconstexpr

Definition at line 22 of file swapchain_impl_vk.cc.

Referenced by impeller::SwapchainImplVK::AcquireNextDrawable().

◆ kPorterDuffCoefficients

constexpr std::array<std::array<Scalar, 5>, 15> impeller::kPorterDuffCoefficients
constexpr
Initial value:
= {{
{0, 0, 0, 0, 0},
{1, 0, 0, 0, 0},
{0, 0, 1, 0, 0},
{1, 0, 1, -1, 0},
{1, -1, 1, 0, 0},
{0, 1, 0, 0, 0},
{0, 0, 0, 1, 0},
{1, -1, 0, 0, 0},
{0, 0, 1, -1, 0},
{0, 1, 1, -1, 0},
{1, -1, 0, 1, 0},
{1, -1, 1, -1, 0},
{1, 0, 1, 0, 0},
{0, 0, 0, 0, 1},
{0, 0, 1, 0, -1},
}}

Definition at line 14 of file blend_filter_contents.h.

Referenced by impeller::AtlasContents::Render().

◆ kPropertiesProcTable

const auto impeller::kPropertiesProcTable
static

Definition at line 70 of file aiks_playground_inspector.cc.

◆ kPropertiesWindowName

const char* impeller::kPropertiesWindowName = "Properties"
static

Definition at line 18 of file aiks_playground_inspector.cc.

◆ kResetOnBackgroundThread

bool impeller::kResetOnBackgroundThread = false
static

Definition at line 59 of file command_pool_vk.cc.

Referenced by impeller::CommandPoolVK::~CommandPoolVK().

◆ kScaleSize

constexpr Scalar impeller::kScaleSize = 100000.0f
staticconstexpr

Definition at line 39 of file text_frame_skia.cc.

Referenced by MakeTextFrameFromTextBlobSkia().

◆ kSkipTests

const std::vector<std::string> impeller::kSkipTests
static

Definition at line 21 of file golden_playground_test_mac.cc.

Referenced by impeller::GoldenPlaygroundTest::SetUp().

◆ kSqrt2

constexpr float impeller::kSqrt2 = 1.41421356237309504880f
constexpr

Definition at line 46 of file constants.h.

◆ kSupportedDocuments

const std::initializer_list<std::string> impeller::kSupportedDocuments
static
Initial value:
= {
EntityPass::kCaptureDocumentName}

Definition at line 20 of file aiks_playground_inspector.cc.

Referenced by impeller::AiksInspector::RenderInspector().

◆ kUnusedAttachmentReference

constexpr vk::AttachmentReference impeller::kUnusedAttachmentReference
staticconstexpr
Initial value:
= {
VK_ATTACHMENT_UNUSED, vk::ImageLayout::eUndefined}

Definition at line 490 of file formats_vk.h.

Referenced by CreateCompatRenderPassForPipeline().

◆ kVectorKeys

constexpr const char* impeller::kVectorKeys = "keys"
staticconstexpr

Definition at line 18 of file archive_vector.cc.

Referenced by impeller::ArchiveVector::Read(), and impeller::ArchiveVector::Write().

◆ sLastID

std::atomic_size_t impeller::sLastID
static

Definition at line 11 of file comparable.cc.

◆ sValidationLogsAreFatal

bool impeller::sValidationLogsAreFatal = false
static

Definition at line 14 of file validation.cc.

Referenced by ImpellerValidationBreak(), and ImpellerValidationErrorsSetFatal().

◆ sValidationLogsDisabledCount

std::atomic_int32_t impeller::sValidationLogsDisabledCount = 0
static

Definition at line 13 of file validation.cc.

Referenced by impeller::ScopedValidationDisable::ScopedValidationDisable(), impeller::ScopedValidationDisable::~ScopedValidationDisable(), and impeller::ValidationLog::~ValidationLog().

◆ tess

Tessellator impeller::tess
static

Definition at line 21 of file geometry_benchmarks.cc.

Referenced by BM_Polyline().

◆ tls_command_pool_map

FML_THREAD_LOCAL fml::ThreadLocalUniquePtr<CommandPoolMap> impeller::tls_command_pool_map

Definition at line 134 of file command_pool_vk.cc.

Referenced by impeller::CommandPoolRecyclerVK::DestroyThreadLocalPools(), impeller::CommandPoolRecyclerVK::Dispose(), and impeller::CommandPoolRecyclerVK::Get().

impeller::OptionalDeviceExtensionVK
OptionalDeviceExtensionVK
Definition: capabilities_vk.h:21
impeller::PixelFormat::kB8G8R8A8UNormIntSRGB
@ kB8G8R8A8UNormIntSRGB
impeller::StoreAction::kMultisampleResolve
@ kMultisampleResolve
impeller::TextureType::kTextureExternalOES
@ kTextureExternalOES
impeller::kBoolean
@ kBoolean
Definition: runtime_types.h:14
impeller::kFloat
@ kFloat
Definition: runtime_types.h:24
impeller::DeepComparePointer
bool DeepComparePointer(const std::shared_ptr< ComparableType > &lhs, const std::shared_ptr< ComparableType > &rhs)
Definition: comparable.h:60
impeller::OptionsFromPass
ContentContextOptions OptionsFromPass(const RenderPass &pass)
Definition: contents.cc:20
DEBUG_COMMAND_INFO
#define DEBUG_COMMAND_INFO(obj, arg)
Definition: command.h:31
impeller::ToVKSampleCount
constexpr vk::SampleCountFlagBits ToVKSampleCount(SampleCount sample_count)
Definition: formats_vk.h:204
impeller::SetViewportAndScissor
static void SetViewportAndScissor(const Command &command, const vk::CommandBuffer &cmd_buffer, PassBindingsCache &cmd_buffer_cache, const ISize &target_size)
Definition: render_pass_vk.cc:462
impeller::LoadAction::kLoad
@ kLoad
impeller::ToMTLColorWriteMask
constexpr MTLColorWriteMask ToMTLColorWriteMask(std::underlying_type_t< ColorWriteMask > type)
Definition: formats_mtl.h:208
impeller::VKClearValueFromDepthStencil
static vk::ClearDepthStencilValue VKClearValueFromDepthStencil(uint32_t stencil, Scalar depth)
Definition: render_pass_vk.cc:205
impeller::HandleType::kRenderBuffer
@ kRenderBuffer
impeller::ConfigureStencil
void ConfigureStencil(const ProcTableGLES &gl, const PipelineDescriptor &pipeline, uint32_t stencil_reference)
Definition: render_pass_gles.cc:89
impeller::BlendModeToString
const char * BlendModeToString(BlendMode blend_mode)
Definition: color.cc:47
impeller::PixelFormatIsDepthStencil
constexpr bool PixelFormatIsDepthStencil(PixelFormat format)
Definition: formats_vk.h:375
impeller::ColorWriteMask
ColorWriteMask
Definition: formats.h:390
impeller::gHasValidationLayers
static bool gHasValidationLayers
Definition: context_vk.cc:38
impeller::StoreAction::kStoreAndMultisampleResolve
@ kStoreAndMultisampleResolve
impeller::ColorToString
std::string ColorToString(const Color &color)
Definition: color.cc:398
impeller::TextureUsageMask
uint64_t TextureUsageMask
Definition: formats.h:274
impeller::ShaderType::kAtomicCounter
@ kAtomicCounter
impeller::PixelFormat::kB10G10R10XR
@ kB10G10R10XR
impeller::ConfigureColorAttachment
static bool ConfigureColorAttachment(const ColorAttachment &desc, MTLRenderPassColorAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:71
impeller::ToVmaAllocationBufferCreateFlags
static VmaAllocationCreateFlags ToVmaAllocationBufferCreateFlags(StorageMode mode)
Definition: allocator_vk.cc:31
impeller::IndexType::k16bit
@ k16bit
impeller::PixelFormatToString
constexpr const char * PixelFormatToString(PixelFormat format)
Definition: formats.h:114
impeller::Scalar
float Scalar
Definition: scalar.h:15
impeller::Font
Describes a typeface along with any modifications to its intrinsic properties.
Definition: font.h:21
impeller::CompareFunction::kGreater
@ kGreater
Comparison test passes if new_value > current_value.
impeller::kUnsignedShort
@ kUnsignedShort
Definition: runtime_types.h:18
impeller::DeviceSupportsComputeSubgroups
static bool DeviceSupportsComputeSubgroups(id< MTLDevice > device)
Definition: context_mtl.mm:40
impeller::ConfigureStencilAttachment
static bool ConfigureStencilAttachment(const StencilAttachment &desc, MTLRenderPassStencilAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:91
impeller::BlendMode::kMultiply
@ kMultiply
impeller::SafeMTLPixelFormatBGRA10_XR
MTLPixelFormat SafeMTLPixelFormatBGRA10_XR()
Definition: formats_mtl.mm:138
impeller::ToVKBlendFactor
constexpr vk::BlendFactor ToVKBlendFactor(BlendFactor factor)
Definition: formats_vk.h:25
impeller::DeleteFBO
static void DeleteFBO(const ProcTableGLES &gl, GLuint fbo, GLenum type)
Definition: blit_command_gles.cc:16
impeller::BlendFactor::kSourceAlphaSaturated
@ kSourceAlphaSaturated
impeller::PixelFormat::kB10G10R10XRSRGB
@ kB10G10R10XRSRGB
impeller::ReportPipelineCreationFeedbackToTrace
static void ReportPipelineCreationFeedbackToTrace(const PipelineDescriptor &desc, const vk::PipelineCreationFeedbackCreateInfoEXT &feedback)
Definition: pipeline_library_vk.cc:203
impeller::FillType::kOdd
@ kOdd
impeller::NearZero
static bool NearZero(Scalar a)
Definition: path_component.cc:251
impeller::compiler::SourceType::kUnknown
@ kUnknown
impeller::HeapRealloc
static void * HeapRealloc(void *userData, void *ptr, unsigned int size)
Definition: tessellator.cc:15
impeller::PixelFormat::kR8G8B8A8UNormIntSRGB
@ kR8G8B8A8UNormIntSRGB
impeller::ReportPipelineCreationFeedbackToLog
static void ReportPipelineCreationFeedbackToLog(const PipelineDescriptor &desc, const vk::PipelineCreationFeedbackCreateInfoEXT &feedback)
Definition: pipeline_library_vk.cc:178
impeller::ToImageFilter
static std::shared_ptr< ImageFilter > ToImageFilter(const flutter::DlImageFilter *filter)
Definition: dl_dispatcher.cc:539
impeller::ToVKDescriptorType
constexpr vk::DescriptorType ToVKDescriptorType(DescriptorType type)
Definition: formats_vk.h:273
impeller::BlendFactor::kOneMinusSourceAlpha
@ kOneMinusSourceAlpha
impeller::kEhCloseEnough
constexpr float kEhCloseEnough
Definition: constants.h:55
impeller::CompareFunction::kNotEqual
@ kNotEqual
Comparison test passes if new_value != current_value.
impeller::ToBlendFactor
constexpr GLenum ToBlendFactor(BlendFactor factor)
Definition: formats_gles.h:90
impeller::ToMTLStencilOperation
constexpr MTLStencilOperation ToMTLStencilOperation(StencilOperation op)
Definition: formats_mtl.h:255
impeller::TextureDescriptor::format
PixelFormat format
Definition: texture_descriptor.h:42
impeller::kScaleSize
static constexpr Scalar kScaleSize
Definition: text_frame_skia.cc:39
impeller::HeapFree
static void HeapFree(void *userData, void *ptr)
Definition: tessellator.cc:19
impeller::LoadActionToString
constexpr const char * LoadActionToString(LoadAction action)
Definition: formats.h:189
impeller::PlaygroundBackend::kMetal
@ kMetal
impeller::CreatePlaceholderAttachmentDescription
static vk::AttachmentDescription CreatePlaceholderAttachmentDescription(PixelFormat format, SampleCount sample_count)
Creates an attachment description that does just enough to ensure render pass compatibility with the ...
Definition: pipeline_library_vk.cc:57
impeller::ColorWriteMask::kGreen
@ kGreen
impeller::PairsFitInAtlasOfSize
static size_t PairsFitInAtlasOfSize(const std::vector< FontGlyphPair > &pairs, const ISize &atlas_size, std::vector< Rect > &glyph_positions, const std::shared_ptr< RectanglePacker > &rect_packer)
Definition: typographer_context_skia.cc:43
impeller::HandleType::kTexture
@ kTexture
impeller::ConfigureAttachment
static bool ConfigureAttachment(const Attachment &desc, MTLRenderPassAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:54
impeller::FillType::kAbsGeqTwo
@ kAbsGeqTwo
impeller::HasSuitableDepthStencilFormat
static bool HasSuitableDepthStencilFormat(const vk::PhysicalDevice &device, vk::Format format)
Definition: capabilities_vk.cc:244
impeller::PointStyle::kRound
@ kRound
Points are drawn as squares.
impeller::kSignedByte
@ kSignedByte
Definition: runtime_types.h:15
impeller::TextureDescriptor::mip_count
size_t mip_count
Definition: texture_descriptor.h:44
impeller::BlendMode::kSourceIn
@ kSourceIn
impeller::ShaderType::kImage
@ kImage
impeller::ColorWriteMask::kRed
@ kRed
impeller::SampleCount::kCount1
@ kCount1
impeller::tess
static Tessellator tess
Definition: geometry_benchmarks.cc:21
impeller::MTLCommandBufferErrorToString
static NSString * MTLCommandBufferErrorToString(MTLCommandBufferError code)
Definition: command_buffer_mtl.mm:36
impeller::Color::alpha
Scalar alpha
Definition: color.h:141
impeller::TextureUsage::kRenderTarget
@ kRenderTarget
impeller::BlendMode::kSaturation
@ kSaturation
impeller::PixelFormat::kR16G16B16A16Float
@ kR16G16B16A16Float
impeller::kSampledImage
@ kSampledImage
Definition: runtime_types.h:26
impeller::SafeMTLPixelFormatDepth24Unorm_Stencil8
MTLPixelFormat SafeMTLPixelFormatDepth24Unorm_Stencil8()
Definition: formats_mtl.mm:113
impeller::skia_conversions::ToColor
Color ToColor(const flutter::DlColor &color)
Definition: skia_conversions.cc:142
impeller::TextureDescriptorToString
std::string TextureDescriptorToString(const TextureDescriptor &desc)
Definition: texture_descriptor.cc:11
impeller::ShaderType::kVoid
@ kVoid
impeller::PixelFormat::kR8G8B8A8UNormInt
@ kR8G8B8A8UNormInt
impeller::BlendMode::kHue
@ kHue
impeller::WindingOrder::kClockwise
@ kClockwise
impeller::SamplerAddressMode::kClampToEdge
@ kClampToEdge
impeller::BlendFactor::kDestinationAlpha
@ kDestinationAlpha
impeller::ToMTLStoreAction
constexpr MTLStoreAction ToMTLStoreAction(StoreAction action)
Definition: formats_mtl.h:305
impeller::IndexType::k32bit
@ k32bit
impeller::StorageMode::kHostVisible
@ kHostVisible
impeller::OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback
@ kEXTPipelineCreationFeedback
impeller::ToMTLCompareFunction
constexpr MTLCompareFunction ToMTLCompareFunction(CompareFunction func)
Definition: formats_mtl.h:233
impeller::BlendMode::kDestinationIn
@ kDestinationIn
impeller::BlendMode::kDarken
@ kDarken
impeller::LogShaderCompilationFailure
static void LogShaderCompilationFailure(const ProcTableGLES &gl, GLuint shader, const std::string &name, const fml::Mapping &source_mapping, ShaderStage stage)
Definition: pipeline_library_gles.cc:35
impeller::Cap::kButt
@ kButt
kColorFontBitsPerPixel
constexpr auto kColorFontBitsPerPixel
Definition: typographer_context_stb.cc:20
impeller::CreateMappingFromAllocation
std::shared_ptr< fml::Mapping > CreateMappingFromAllocation(const std::shared_ptr< Allocation > &allocation)
Definition: allocation.cc:100
impeller::ToVKStencilOpState
constexpr vk::StencilOpState ToVKStencilOpState(const StencilAttachmentDescriptor &desc)
Definition: formats_vk.h:550
impeller::SampleCount::kCount4
@ kCount4
impeller::NormalizeUniformKey
static std::string NormalizeUniformKey(const std::string &key)
Definition: buffer_bindings_gles.cc:53
impeller::AttachmentKind::kDepthStencil
@ kDepthStencil
impeller::ToMTLClearColor
MTLClearColor ToMTLClearColor(const Color &color)
Definition: formats_mtl.h:370
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: dl_dispatcher.cc:44
impeller::ToTileMode
static Entity::TileMode ToTileMode(flutter::DlTileMode tile_mode)
Definition: dl_dispatcher.cc:119
impeller::PolygonMode::kFill
@ kFill
impeller::FillType::kPositive
@ kPositive
impeller::PrimitiveType::kTriangleStrip
@ kTriangleStrip
impeller::ToVKCompareOp
constexpr vk::CompareOp ToVKCompareOp(CompareFunction op)
Definition: formats_vk.h:505
impeller::BlendMode::kLuminosity
@ kLuminosity
impeller::Join::kMiter
@ kMiter
impeller::BlendFactor::kSourceColor
@ kSourceColor
impeller::PrimitiveType::kPoint
@ kPoint
impeller::BlendMode::kXor
@ kXor
impeller::ToMTLDepthStencilDescriptor
MTLDepthStencilDescriptor * ToMTLDepthStencilDescriptor(std::optional< DepthAttachmentDescriptor > depth, std::optional< StencilAttachmentDescriptor > front, std::optional< StencilAttachmentDescriptor > back)
Definition: formats_mtl.mm:54
impeller::Font::GetTypeface
const std::shared_ptr< Typeface > & GetTypeface() const
The typeface whose intrinsic properties this font modifies.
Definition: font.cc:23
impeller::BlendFactor::kDestinationColor
@ kDestinationColor
IPLR_ACQUIRE
#define IPLR_ACQUIRE(...)
Definition: thread_safety.h:35
impeller::ToMatrix
static Matrix ToMatrix(const SkMatrix &m)
Definition: dl_dispatcher.cc:174
impeller::BlendMode::kOverlay
@ kOverlay
impeller::MinMagFilter::kNearest
@ kNearest
Select nearest to the sample point. Most widely supported.
impeller::ToVKStencilOp
constexpr vk::StencilOp ToVKStencilOp(StencilOperation op)
Definition: formats_vk.h:527
impeller::SamplerDescriptor::mag_filter
MinMagFilter mag_filter
Definition: sampler_descriptor.h:20
impeller::TextureCoordinateSystem::kUploadFromHost
@ kUploadFromHost
impeller::SamplerDescriptor
Definition: sampler_descriptor.h:18
impeller::kColor
@ kColor
Definition: geometry.h:27
impeller::BlendMode::kColorBurn
@ kColorBurn
impeller::UpdateBindingLayouts
static bool UpdateBindingLayouts(const std::vector< ComputeCommand > &commands, const vk::CommandBuffer &buffer)
Definition: compute_pass_vk.cc:59
impeller::BlendFactor::kZero
@ kZero
impeller::TextureType::kTexture2DMultisample
@ kTexture2DMultisample
impeller::StencilOperation::kKeep
@ kKeep
Don't modify the current stencil value.
impeller::StencilOperation::kInvert
@ kInvert
Perform a logical bitwise invert on the current stencil value.
impeller::ConfigureDepthAttachment
static bool ConfigureDepthAttachment(const DepthAttachment &desc, MTLRenderPassDepthAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:81
impeller::TextureCoordinateSystem::kRenderToTexture
@ kRenderToTexture
impeller::ToSamplerDescriptor
static impeller::SamplerDescriptor ToSamplerDescriptor(const flutter::DlFilterMode options)
Definition: dl_dispatcher.cc:156
impeller::kSignedInt
@ kSignedInt
Definition: runtime_types.h:19
impeller::ToIndexType
constexpr GLenum ToIndexType(IndexType type)
Definition: formats_gles.h:33
impeller::LoadAction::kClear
@ kClear
impeller::BlendFactor::kOneMinusDestinationColor
@ kOneMinusDestinationColor
impeller::PointStyle::kSquare
@ kSquare
Points are drawn as circles.
impeller::SamplerDescriptor::min_filter
MinMagFilter min_filter
Definition: sampler_descriptor.h:19
impeller::ToCompareFunction
constexpr GLenum ToCompareFunction(CompareFunction func)
Definition: formats_gles.h:68
impeller::StorageMode::kDeviceTransient
@ kDeviceTransient
impeller::Point
TPoint< Scalar > Point
Definition: point.h:306
impeller::CullMode::kBackFace
@ kBackFace
impeller::BlendMode::kLighten
@ kLighten
impeller::ToMTLLoadAction
constexpr MTLLoadAction ToMTLLoadAction(LoadAction action)
Definition: formats_mtl.h:277
impeller::TRect::Intersection
constexpr std::optional< TRect< T > > Intersection(const TRect &o) const
Definition: rect.h:219
impeller::CullMode::kNone
@ kNone
impeller::BlendMode::kSourceOver
@ kSourceOver
impeller::ToMTLBlendOperation
constexpr MTLBlendOperation ToMTLBlendOperation(BlendOperation type)
Definition: formats_mtl.h:196
impeller::ToMTLStencilDescriptor
MTLStencilDescriptor * ToMTLStencilDescriptor(const StencilAttachmentDescriptor &descriptor)
Definition: formats_mtl.mm:38
impeller::ToVKImageFormat
constexpr vk::Format ToVKImageFormat(PixelFormat format)
Definition: formats_vk.h:136
impeller::BlendOperation::kReverseSubtract
@ kReverseSubtract
impeller::ToVKIndexType
constexpr vk::IndexType ToVKIndexType(IndexType index_type)
Definition: formats_vk.h:333
IPLR_RELEASE
#define IPLR_RELEASE(...)
Definition: thread_safety.h:41
impeller::BlendMode::kHardLight
@ kHardLight
impeller::BlendFactor::kBlendAlpha
@ kBlendAlpha
impeller::UpdateBindingLayouts
static bool UpdateBindingLayouts(const std::vector< Command > &commands, const vk::CommandBuffer &buffer)
Definition: render_pass_vk.cc:316
impeller::BlendMode::kPlus
@ kPlus
impeller::compiler::TargetPlatform::kVulkan
@ kVulkan
impeller::SPrintF
std::string SPrintF(const char *format,...)
Definition: strings.cc:12
impeller::StencilOperation::kSetToReferenceValue
@ kSetToReferenceValue
Reset the stencil value to the reference value.
impeller::BlendMode::kDestination
@ kDestination
impeller::AttachmentKind::kStencil
@ kStencil
impeller::ToVertexMode
static VerticesGeometry::VertexMode ToVertexMode(flutter::DlVertexMode mode)
Definition: dl_vertices_geometry.cc:20
impeller::AttachmentKindFromFormat
constexpr AttachmentKind AttachmentKindFromFormat(PixelFormat format)
Definition: formats_vk.h:406
impeller::ContainsFormat
static bool ContainsFormat(const std::vector< vk::SurfaceFormatKHR > &formats, vk::SurfaceFormatKHR format)
Definition: swapchain_impl_vk.cc:69
impeller::gShouldOpenNewPlaygrounds
static std::atomic_bool gShouldOpenNewPlaygrounds
Definition: playground.cc:150
impeller::ToMTLRenderPipelineColorAttachmentDescriptor
MTLRenderPipelineColorAttachmentDescriptor * ToMTLRenderPipelineColorAttachmentDescriptor(ColorAttachmentDescriptor descriptor)
Definition: formats_mtl.mm:15
impeller::DeviceSupportsFramebufferFetch
static bool DeviceSupportsFramebufferFetch(id< MTLDevice > device)
Definition: context_mtl.mm:20
impeller::YUVColorSpace::kBT601FullRange
@ kBT601FullRange
impeller::ToMode
constexpr GLenum ToMode(PrimitiveType primitive_type)
Definition: formats_gles.h:17
impeller::BlendOperation::kAdd
@ kAdd
impeller::RuntimeShaderStage::kTessellationEvaluation
@ kTessellationEvaluation
impeller::ShaderType::kSampler
@ kSampler
impeller::MinMagFilter::kLinear
@ kLinear
impeller::StorageMode::kDevicePrivate
@ kDevicePrivate
impeller::StorageModeToString
constexpr const char * StorageModeToString(StorageMode mode)
Definition: formats.h:55
impeller::BlendFactor::kBlendColor
@ kBlendColor
impeller::ColorMatrix::array
Scalar array[20]
Definition: color.h:116
impeller::CompressionType::kLossless
@ kLossless
impeller::PixelFormat::kD32FloatS8UInt
@ kD32FloatS8UInt
impeller::BlendMode::kDestinationATop
@ kDestinationATop
impeller::AttachmentToString
std::string AttachmentToString(const Attachment &attachment)
Definition: formats.cc:104
impeller::TextureUsage::kShaderRead
@ kShaderRead
impeller::CompareFunction::kNever
@ kNever
Comparison test never passes.
impeller::WindingOrder::kCounterClockwise
@ kCounterClockwise
impeller::GetDefaultStencilConfig
static RenderTarget::AttachmentConfig GetDefaultStencilConfig(bool readable)
Definition: entity_pass.cc:261
impeller::BlendFactor::kOneMinusBlendColor
@ kOneMinusBlendColor
InternalHalf
_Float16 InternalHalf
Definition: half.h:19
impeller::TRect::Scale
constexpr TRect Scale(Type scale) const
Definition: rect.h:108
impeller::TextureType::kTextureCube
@ kTextureCube
impeller::BlobShaderType::kVertex
@ kVertex
impeller::FillType
FillType
Definition: path.h:29
impeller::kUnsignedByte
@ kUnsignedByte
Definition: runtime_types.h:16
impeller::kUnsignedInt64
@ kUnsignedInt64
Definition: runtime_types.h:22
impeller::PixelFormat::kR8G8UNormInt
@ kR8G8UNormInt
impeller::ScalarNearlyZero
constexpr bool ScalarNearlyZero(Scalar x, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:22
impeller::PixelFormat::kD24UnormS8Uint
@ kD24UnormS8Uint
impeller::AttachmentKind::kDepth
@ kDepth
impeller::StoreAction::kStore
@ kStore
impeller::ToVkShaderStage
constexpr vk::ShaderStageFlags ToVkShaderStage(ShaderStage stage)
Definition: formats_vk.h:254
impeller::CompressionTypeToString
constexpr const char * CompressionTypeToString(CompressionType type)
Definition: texture_descriptor.h:25
impeller::Absolute
constexpr T Absolute(const T &val)
Definition: scalar.h:18
impeller::Rect
TRect< Scalar > Rect
Definition: rect.h:306
impeller::kHalfFloat
@ kHalfFloat
Definition: runtime_types.h:23
impeller::BlendFactor::kOne
@ kOne
impeller::Luminosity
static constexpr Scalar Luminosity(Vector3 color)
Definition: color.cc:140
impeller::BlendFactor::kOneMinusBlendAlpha
@ kOneMinusBlendAlpha
impeller::CompressionType::kLossy
@ kLossy
impeller::kUnsignedInt
@ kUnsignedInt
Definition: runtime_types.h:20
impeller::DebugResourceType::kShader
@ kShader
impeller::BlendMode::kDestinationOut
@ kDestinationOut
impeller::StencilOperation::kIncrementClamp
@ kIncrementClamp
Increment the current stencil value by 1. Clamp it to the maximum.
impeller::ToFont
static Font ToFont(const SkTextBlobRunIterator &run)
Definition: text_frame_skia.cc:19
impeller::AppendColor
static void AppendColor(const Color &color, GradientData *data)
Definition: gradient.cc:12
impeller::PixelFormat::kB8G8R8A8UNormInt
@ kB8G8R8A8UNormInt
impeller::BlobShaderType::kFragment
@ kFragment
impeller::PrimitiveType::kLine
@ kLine
impeller::skia_conversions::ToPoint
Point ToPoint(const SkPoint &point)
Definition: skia_conversions.cc:138
impeller::kPadding
constexpr auto kPadding
Definition: typographer_context_skia.cc:28
impeller::YUVColorSpace::kBT601LimitedRange
@ kBT601LimitedRange
impeller::ConfigureResolveTextureAttachment
static bool ConfigureResolveTextureAttachment(const Attachment &desc, MTLRenderPassAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:25
impeller::kSignedShort
@ kSignedShort
Definition: runtime_types.h:17
impeller::BlendMode::kSoftLight
@ kSoftLight
impeller::TextureType::kTexture2D
@ kTexture2D
impeller::FillType::kNonZero
@ kNonZero
impeller::DescriptorType::kUniformBuffer
@ kUniformBuffer
impeller::ToVKAttachmentStoreOp
constexpr vk::AttachmentStoreOp ToVKAttachmentStoreOp(StoreAction store_action)
Definition: formats_vk.h:318
impeller::SamplerDescriptor::mip_filter
MipFilter mip_filter
Definition: sampler_descriptor.h:21
IMPELLER_FOR_EACH_BLEND_MODE
#define IMPELLER_FOR_EACH_BLEND_MODE(V)
Definition: color.h:17
impeller::HandleType::kProgram
@ kProgram
impeller::PrimitiveType::kLineStrip
@ kLineStrip
impeller::TPoint::x
Type x
Definition: point.h:23
impeller::VerifyExistingCache
static bool VerifyExistingCache(const fml::Mapping &mapping, const CapabilitiesVK &caps)
Definition: pipeline_cache_vk.cc:19
impeller::kUV
@ kUV
Definition: geometry.h:28
impeller::ToMTLPixelFormat
constexpr MTLPixelFormat ToMTLPixelFormat(PixelFormat format)
Definition: formats_mtl.h:75
impeller::SafeMTLPixelFormatBGR10_XR
MTLPixelFormat SafeMTLPixelFormatBGR10_XR()
Definition: formats_mtl.mm:130
impeller::StripPrefix
std::string StripPrefix(const std::string &string, const std::string &to_strip)
Definition: strings.cc:42
impeller::CompareFunction::kLess
@ kLess
Comparison test passes if new_value < current_value.
impeller::ISize
TSize< int64_t > ISize
Definition: size.h:136
impeller::HeapAlloc
static void * HeapAlloc(void *userData, unsigned int size)
Definition: tessellator.cc:11
impeller::TextureDescriptor::size
ISize size
Definition: texture_descriptor.h:43
impeller::ToVKAttachmentLoadOp
constexpr vk::AttachmentLoadOp ToVKAttachmentLoadOp(LoadAction load_action)
Definition: formats_vk.h:305
impeller::BlendMode::kDifference
@ kDifference
impeller::NearEqual
static bool NearEqual(Scalar a, Scalar b, Scalar epsilon)
Definition: path_component.cc:247
impeller::ToMTLTextureType
constexpr MTLTextureType ToMTLTextureType(TextureType type)
Definition: formats_mtl.h:374
impeller::Join::kBevel
@ kBevel
VALIDATION_LOG
#define VALIDATION_LOG
Definition: validation.h:60
impeller::CullMode::kFrontFace
@ kFrontFace
impeller::PixelFormat::kB10G10R10A10XR
@ kB10G10R10A10XR
_IMPELLER_ASSERT_BLEND_MODE
#define _IMPELLER_ASSERT_BLEND_MODE(blend_mode)
Definition: color.cc:20
impeller::TextureTypeToString
constexpr const char * TextureTypeToString(TextureType type)
Definition: formats.h:243
impeller::ShaderType::kStruct
@ kStruct
impeller::CompareFunction::kGreaterEqual
@ kGreaterEqual
Comparison test passes if new_value >= current_value.
impeller::StencilOperation::kDecrementClamp
@ kDecrementClamp
Decrement the current stencil value by 1. Clamp it to zero.
impeller::ClipColor
static constexpr Vector3 ClipColor(Vector3 color)
Definition: color.cc:144
impeller::Tessellator::Tessellate
Tessellator::Result Tessellate(FillType fill_type, const Path::Polyline &polyline, const BuilderCallback &callback) const
Generates filled triangles from the polyline. A callback is invoked once for the entire tessellation.
Definition: tessellator.cc:61
impeller::ColorWriteMask::kAll
@ kAll
impeller::CompareFunction::kAlways
@ kAlways
Comparison test passes always passes.
impeller::SafeMTLPixelFormatBGR10_XR_sRGB
MTLPixelFormat SafeMTLPixelFormatBGR10_XR_sRGB()
Definition: formats_mtl.mm:122
impeller::SamplerAddressMode::kMirror
@ kMirror
impeller::RemoveMetadataFromCache
static std::unique_ptr< fml::Mapping > RemoveMetadataFromCache(std::unique_ptr< fml::Mapping > data)
Definition: pipeline_cache_vk.cc:29
impeller::kDouble
@ kDouble
Definition: runtime_types.h:25
impeller::BlendMode::kExclusion
@ kExclusion
impeller::HasSuitableColorFormat
static bool HasSuitableColorFormat(const vk::PhysicalDevice &device, vk::Format format)
Definition: capabilities_vk.cc:236
impeller::AllocateAndBindDescriptorSets
static bool AllocateAndBindDescriptorSets(const ContextVK &context, const Command &command, CommandEncoderVK &encoder, const PipelineVK &pipeline, size_t command_count)
Definition: render_pass_vk.cc:326
impeller::ConfigureBlending
void ConfigureBlending(const ProcTableGLES &gl, const ColorAttachmentDescriptor *color)
Definition: render_pass_gles.cc:36
impeller::BlendMode::kDestinationOver
@ kDestinationOver
impeller::LoadAction::kDontCare
@ kDontCare
impeller::kSignedInt64
@ kSignedInt64
Definition: runtime_types.h:21
impeller::PixelFormat::kS8UInt
@ kS8UInt
DISABLE_COLOR_FONT_SUPPORT
#define DISABLE_COLOR_FONT_SUPPORT
Definition: typographer_context_stb.cc:18
impeller::ToMTLBlendFactor
constexpr MTLBlendFactor ToMTLBlendFactor(BlendFactor type)
Definition: formats_mtl.h:113
impeller::BlobShaderType::kCompute
@ kCompute
impeller::BlendFactor::kOneMinusSourceColor
@ kOneMinusSourceColor
impeller::PixelFormat::kA8UNormInt
@ kA8UNormInt
impeller::HasPrefix
bool HasPrefix(const std::string &string, const std::string &prefix)
Definition: strings.cc:30
impeller::compiler::TargetPlatform::kOpenGLES
@ kOpenGLES
impeller::MipFilter::kLinear
@ kLinear
impeller::FromMTLPixelFormat
constexpr PixelFormat FromMTLPixelFormat(MTLPixelFormat format)
Definition: formats_mtl.h:21
impeller::kUnusedAttachmentReference
static constexpr vk::AttachmentReference kUnusedAttachmentReference
Definition: formats_vk.h:490
impeller::ScalarNearlyEqual
constexpr bool ScalarNearlyEqual(Scalar x, Scalar y, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:27
impeller::SamplerDescriptor::label
std::string label
Definition: sampler_descriptor.h:27
impeller::BlendMode::kLast
@ kLast
impeller::ToBlendMode
static BlendMode ToBlendMode(flutter::DlBlendMode mode)
Definition: dl_dispatcher.cc:55
impeller::sValidationLogsAreFatal
static bool sValidationLogsAreFatal
Definition: validation.cc:14
impeller::ColorWriteMask::kAlpha
@ kAlpha
impeller::ColorWriteMask::kBlue
@ kBlue
impeller::FromRGB
static constexpr Color FromRGB(Vector3 color, Scalar alpha)
Definition: color.cc:192
impeller::CompareFunction::kEqual
@ kEqual
Comparison test passes if new_value == current_value.
impeller::PrimitiveType::kTriangle
@ kTriangle
impeller::FillType::kNegative
@ kNegative
impeller::TextureDescriptor::storage_mode
StorageMode storage_mode
Definition: texture_descriptor.h:40
impeller::DrawGlyph
static void DrawGlyph(BitmapSTB *bitmap, const ScaledFont &scaled_font, const Glyph &glyph, const Rect &location, bool has_color)
Definition: typographer_context_stb.cc:198
impeller::StoreActionToString
constexpr const char * StoreActionToString(StoreAction action)
Definition: formats.h:200
impeller::BlendMode::kColorDodge
@ kColorDodge
impeller::PixelFormat::kR8UNormInt
@ kR8UNormInt
impeller::ToColorFilter
static std::shared_ptr< ColorFilter > ToColorFilter(const flutter::DlColorFilter *filter)
Definition: dl_dispatcher.cc:458
impeller::TextureDescriptor
A lightweight object that describes the attributes of a texture that can then used an allocator to cr...
Definition: texture_descriptor.h:39
impeller::ToBlendOperation
constexpr GLenum ToBlendOperation(BlendOperation op)
Definition: formats_gles.h:126
impeller::BlendMode::kSourceATop
@ kSourceATop
impeller::kBlendModeNames
static constexpr const char * kBlendModeNames[]
Definition: color.cc:44
impeller::HandleType::kFrameBuffer
@ kFrameBuffer
impeller::BlendMode::kModulate
@ kModulate
impeller::ToVKBlendOp
constexpr vk::BlendOp ToVKBlendOp(BlendOperation op)
Definition: formats_vk.h:61
impeller::HandleType::kBuffer
@ kBuffer
impeller::Convexity::kConvex
@ kConvex
impeller::CreateAttachmentDescription
constexpr vk::AttachmentDescription CreateAttachmentDescription(PixelFormat format, SampleCount sample_count, LoadAction load_action, StoreAction store_action, vk::ImageLayout current_layout)
Definition: formats_vk.h:431
impeller::BlendFactor::kSourceAlpha
@ kSourceAlpha
impeller::AttachmentTypeString
static const char * AttachmentTypeString(GLint type)
Definition: proc_table_gles.cc:162
impeller::ToVKBufferMemoryPropertyFlags
static constexpr vk::Flags< vk::MemoryPropertyFlagBits > ToVKBufferMemoryPropertyFlags(StorageMode mode)
Definition: allocator_vk.cc:19
impeller::ColorMatrix
Definition: color.h:115
impeller::RuntimeShaderStage::kTessellationControl
@ kTessellationControl
impeller::GetShaderInfoLog
static std::string GetShaderInfoLog(const ProcTableGLES &gl, GLuint shader)
Definition: pipeline_library_gles.cc:21
impeller::ToStencilOp
constexpr GLenum ToStencilOp(StencilOperation op)
Definition: formats_gles.h:46
impeller::StencilOperation::kDecrementWrap
@ kDecrementWrap
Decrement the current stencil value by 1. If at zero, set to maximum.
impeller::ToRect
static Rect ToRect(const SkRect &rect)
Definition: text_frame_skia.cc:35
impeller::CompareFunction::kLessEqual
@ kLessEqual
Comparison test passes if new_value <= current_value.
impeller::BlendMode::kScreen
@ kScreen
impeller::TextureUsage::kShaderWrite
@ kShaderWrite
impeller::TextureUsageToString
constexpr const char * TextureUsageToString(TextureUsage usage)
Definition: formats.h:287
impeller::CreateAttachmentDescription
static vk::AttachmentDescription CreateAttachmentDescription(const Attachment &attachment, const std::shared_ptr< Texture > Attachment::*texture_ptr)
Definition: render_pass_vk.cc:31
impeller::kPosition
@ kPosition
Definition: geometry.h:26
impeller::BlendMode::kSourceOut
@ kSourceOut
impeller::StencilOperation::kIncrementWrap
@ kIncrementWrap
Increment the current stencil value by 1. If at maximum, set to zero.
impeller::BlendOperation::kSubtract
@ kSubtract
impeller::Color::Premultiply
constexpr Color Premultiply() const
Definition: color.h:212
impeller::BlendMode::kSource
@ kSource
impeller::DrawGlyph
static void DrawGlyph(SkCanvas *canvas, const ScaledFont &scaled_font, const Glyph &glyph, const Rect &location, bool has_color)
Definition: typographer_context_skia.cc:155
impeller::BlendFactor::kOneMinusDestinationAlpha
@ kOneMinusDestinationAlpha
impeller::VKClearValueFromColor
static vk::ClearColorValue VKClearValueFromColor(Color color)
Definition: render_pass_vk.cc:198
impeller::DescriptorType::kStorageBuffer
@ kStorageBuffer
impeller::PixelFormat::kR32G32B32A32Float
@ kR32G32B32A32Float
impeller::ToVKColorComponentFlags
constexpr vk::ColorComponentFlags ToVKColorComponentFlags(std::underlying_type_t< ColorWriteMask > type)
Definition: formats_vk.h:73
impeller::ToRGB
static constexpr Vector3 ToRGB(Color color)
Definition: color.cc:188
_IMPELLER_BLEND_MODE_NAME_LIST
#define _IMPELLER_BLEND_MODE_NAME_LIST(blend_mode)
Definition: color.cc:42
impeller::SamplerAddressMode::kRepeat
@ kRepeat
impeller::SamplerAddressMode::kDecal
@ kDecal
decal sampling mode is only supported on devices that pass the Capabilities.SupportsDecalSamplerAddre...