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
 
class  BackgroundDescriptorPoolVK
 
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  BlurImageFilter
 
struct  BlurParameters
 
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
 
class  CapabilitiesGLES
 The Vulkan layers and extensions wrangler. More...
 
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  CircleGeometry
 
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  ComposedColorFilter
 Applies color filters as f(g(x)), where x is the input color. More...
 
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  ConditionVariable
 A condition variable exactly similar to the one in libcxx with two major differences: 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  DescriptorPoolRecyclerVK
 Creates and manages the lifecycle of |vk::DescriptorPoolVK| objects. More...
 
class  DescriptorPoolVK
 A short-lived fixed-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  EllipseGeometry
 
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  GaussianBlurFilterContents
 
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
 
class  GPUProbe
 
class  GPUTracerGLES
 Trace GPU execution times using GL_EXT_disjoint_timer_query on GLES. More...
 
class  GPUTracerMTL
 Approximate the GPU frame time by computing a difference between the smallest GPUStartTime and largest GPUEndTime for all command buffers submitted in a frame workload. More...
 
class  GPUTracerVK
 A class that uses timestamp queries to record the approximate GPU execution time. More...
 
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
 
class  ImageFilterVisitor
 
struct  ImageVMA
 
struct  ImageVMATraits
 
class  InlinePassContext
 
struct  IPoint16
 
class  LazyGlyphAtlas
 
class  LinearGradientContents
 
struct  LinearPathComponent
 
class  LinearToSrgbColorFilter
 
class  LinearToSrgbFilterContents
 
class  LineGeometry
 
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  MultiArchShaderArchive
 
class  MultiArchShaderArchiveWriter
 
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
 The reactor attempts to make thread-safe usage of OpenGL ES easier to reason about. More...
 
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  RoundRectGeometry
 
class  RuntimeEffectContents
 
class  RuntimeStage
 
class  RuntimeStagePlayground
 
struct  RuntimeUniformDescription
 
struct  RuntimeUniformDimensions
 
struct  SampledImageSlot
 Metadata required to bind a combined texture and sampler. More...
 
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  ShaderArchive
 
class  ShaderArchiveWriter
 
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
 Metadata required to bind a buffer. More...
 
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  TraceSerializer
 
class  TrackedObjectsVK
 
struct  TRect
 
struct  Trig
 A structure to store the sine and cosine of an angle. More...
 
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 CanvasType = Canvas
 
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 KernelDecalPipeline = RenderPipelineT< GaussianBlurVertexShader, KernelDecalFragmentShader >
 
using KernelPipeline = RenderPipelineT< GaussianBlurVertexShader, KernelNodecalFragmentShader >
 
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, AdvancedBlendFragmentShader >
 
using BlendColorBurnPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendColorDodgePipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendDarkenPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendDifferencePipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendExclusionPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendHardLightPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendHuePipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendLightenPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendLuminosityPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendMultiplyPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendOverlayPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendSaturationPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendScreenPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using BlendSoftLightPipeline = RenderPipelineT< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
 
using FramebufferBlendColorPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendColorBurnPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendColorDodgePipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendDarkenPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendDifferencePipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendExclusionPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendHardLightPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendHuePipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendLightenPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendLuminosityPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendMultiplyPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendOverlayPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendSaturationPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendScreenPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using FramebufferBlendSoftLightPipeline = RenderPipelineT< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
 
using PointsComputeShaderPipeline = ComputePipelineBuilder< PointsComputeShader >
 Geometry Pipelines. More...
 
using UvComputeShaderPipeline = ComputePipelineBuilder< UvComputeShader >
 
using PipelineProc = std::shared_ptr< Pipeline< PipelineDescriptor > >(ContentContext::*)(ContentContextOptions) const
 
using GaussianBlurVertexShader = KernelPipeline::VertexShader
 
using GaussianBlurFragmentShader = KernelPipeline::FragmentShader
 
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 Quad = std::array< Point, 4 >
 
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 Callback = std::function< void(MTLRenderPipelineDescriptor *)>
 
using CommandPoolMap = std::unordered_map< uint64_t, std::shared_ptr< CommandPoolVK > >
 
using DescriptorPoolAndSize = std::pair< vk::UniqueDescriptorPool, uint32_t >
 
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 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 TessellatedVertexProc = Tessellator::TessellatedVertexProc
 
using EllipticalVertexGenerator = Tessellator::EllipticalVertexGenerator
 
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  CanvasRecorderOp : uint16_t {
  kNew,
  kSave,
  kSaveLayer,
  kRestore,
  kRestoreToCount,
  kResetTransform,
  kTransform,
  kConcat,
  kPreConcat,
  kTranslate,
  kScale2,
  kScale3,
  kSkew,
  kRotate,
  kDrawPath,
  kDrawPaint,
  kDrawRect,
  kDrawRRect,
  kDrawCircle,
  kDrawPoints,
  kDrawImage,
  kDrawImageRect,
  kClipPath,
  kClipRect,
  kClipRRect,
  kDrawPicture,
  kDrawTextFrame,
  kDrawVertices,
  kDrawAtlas
}
 
enum  StorageMode {
  StorageMode::kHostVisible,
  StorageMode::kDevicePrivate,
  StorageMode::kDeviceTransient
}
 Specified where the allocation resides and how it is used. More...
 
enum  PixelFormat : uint8_t {
  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 : uint8_t {
  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 : uint8_t {
  PrimitiveType::kTriangle,
  PrimitiveType::kTriangleStrip,
  PrimitiveType::kLine,
  PrimitiveType::kLineStrip,
  PrimitiveType::kPoint
}
 Decides how backend draws pixels based on input vertices. More...
 
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 : uint8_t {
  CompareFunction::kNever,
  CompareFunction::kAlways,
  CompareFunction::kLess,
  CompareFunction::kEqual,
  CompareFunction::kLessEqual,
  CompareFunction::kGreater,
  CompareFunction::kNotEqual,
  CompareFunction::kGreaterEqual
}
 
enum  StencilOperation : uint8_t {
  StencilOperation::kKeep,
  StencilOperation::kZero,
  StencilOperation::kSetToReferenceValue,
  StencilOperation::kIncrementClamp,
  StencilOperation::kDecrementClamp,
  StencilOperation::kInvert,
  StencilOperation::kIncrementWrap,
  StencilOperation::kDecrementWrap
}
 
enum  RuntimeStageBackend {
  RuntimeStageBackend::kSkSL,
  RuntimeStageBackend::kMetal,
  RuntimeStageBackend::kOpenGLES,
  RuntimeStageBackend::kVulkan
}
 
enum  RuntimeUniformType {
  kBoolean,
  kSignedByte,
  kUnsignedByte,
  kSignedShort,
  kUnsignedShort,
  kSignedInt,
  kUnsignedInt,
  kSignedInt64,
  kUnsignedInt64,
  kHalfFloat,
  kFloat,
  kDouble,
  kSampledImage
}
 
enum  RuntimeShaderStage {
  RuntimeShaderStage::kVertex,
  RuntimeShaderStage::kFragment,
  RuntimeShaderStage::kCompute
}
 
enum  ShaderStage {
  ShaderStage::kUnknown,
  ShaderStage::kVertex,
  ShaderStage::kFragment,
  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,
  DescriptorType::kInputAttachment
}
 
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  BlendSelectValues {
  BlendSelectValues::kScreen = 0,
  BlendSelectValues::kOverlay,
  BlendSelectValues::kDarken,
  BlendSelectValues::kLighten,
  BlendSelectValues::kColorDodge,
  BlendSelectValues::kColorBurn,
  BlendSelectValues::kHardLight,
  BlendSelectValues::kSoftLight,
  BlendSelectValues::kDifference,
  BlendSelectValues::kExclusion,
  BlendSelectValues::kMultiply,
  BlendSelectValues::kHue,
  BlendSelectValues::kSaturation,
  kColor,
  BlendSelectValues::kLuminosity
}
 
enum  GeometryVertexType {
  kPosition,
  kColor,
  kColor,
  kUV
}
 
enum  YUVColorSpace {
  YUVColorSpace::kBT601LimitedRange,
  YUVColorSpace::kBT601FullRange
}
 
enum  BlendMode : uint8_t {
  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::kARMRasterizationOrderAttachmentAccess,
  OptionalDeviceExtensionVK::kEXTRasterizationOrderAttachmentAccess,
  OptionalDeviceExtensionVK::kLast
}
 
enum  AttachmentKind {
  AttachmentKind::kColor,
  AttachmentKind::kDepth,
  AttachmentKind::kStencil,
  AttachmentKind::kDepthStencil
}
 
enum  UseSubpassInput {
  UseSubpassInput::kYes,
  UseSubpassInput::kNo
}
 
enum  ArchiveShaderType {
  ArchiveShaderType::kVertex,
  ArchiveShaderType::kFragment,
  ArchiveShaderType::kCompute
}
 
enum  ArchiveRenderingBackend {
  ArchiveRenderingBackend::kMetal,
  ArchiveRenderingBackend::kVulkan,
  ArchiveRenderingBackend::kOpenGLES
}
 
enum  WindingOrder {
  WindingOrder::kClockwise,
  WindingOrder::kCounterClockwise
}
 

Functions

static bool UseColorSourceContents (const std::shared_ptr< VerticesGeometry > &vertices, const Paint &paint)
 
template<class... Args>
static void BM_CanvasRecord (benchmark::State &state, Args &&... args)
 
 BENCHMARK_CAPTURE (BM_CanvasRecord, draw_rect, &DrawRect)
 
 BENCHMARK_CAPTURE (BM_CanvasRecord, draw_circle, &DrawCircle)
 
 BENCHMARK_CAPTURE (BM_CanvasRecord, draw_line, &DrawLine)
 
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)
 
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 bool IsDepthWritable (PixelFormat format)
 
constexpr bool IsStencilWritable (PixelFormat format)
 
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 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)
 
Sigma ScaleSigma (Sigma sigma)
 
KernelPipeline::FragmentShader::KernelSamples GenerateBlurInfo (BlurParameters parameters)
 
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 ShaderType GetShaderType (RuntimeUniformType type)
 
static std::shared_ptr< ShaderMetadata > MakeShaderMetadata (const RuntimeUniformDescription &uniform)
 
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)
 
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)
 
template<class... Args>
static void BM_Convex (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)
 
 BENCHMARK_CAPTURE (BM_Convex, rrect_convex, CreateRRect(), 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)
 
constexpr RuntimeStageBackend PlaygroundBackendToRuntimeStageBackend (PlaygroundBackend backend)
 
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)
 
std::string DebugToFramebufferError (int status)
 
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 std::string GetShaderSource (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)
 
bool GLErrorIsFatal (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, const std::shared_ptr< GPUTracerGLES > &tracer)
 
static GLint ToParam (MinMagFilter minmag_filter, std::optional< MipFilter > mip_filter=std::nullopt)
 
static GLint ToAddressMode (SamplerAddressMode mode, bool supports_decal_sampler_address_mode)
 
static ShaderStage ToShaderStage (ArchiveShaderType 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)
 
std::shared_future< id< CAMetalDrawable > > GetDrawableDeferred (CAMetalLayer *layer)
 Create a deferred drawable from a CAMetalLayer. More...
 
std::shared_ptr< TextureMTL > CreateTextureFromDrawableFuture (TextureDescriptor desc, const std::shared_future< id< CAMetalDrawable >> &drawble_future)
 Create a TextureMTL from a deferred drawable. More...
 
static void GetMTLRenderPipelineDescriptor (const PipelineDescriptor &desc, const Callback &callback)
 
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, bool supports_framebuffer_fetch)
 
static constexpr VmaMemoryUsage ToVMAMemoryUsage ()
 
static constexpr vk::Flags< vk::MemoryPropertyFlagBits > ToVKTextureMemoryPropertyFlags (StorageMode mode, bool supports_memoryless_textures)
 
static VmaAllocationCreateFlags ToVmaAllocationCreateFlags (StorageMode mode)
 
static bool BindImages (const Bindings &bindings, Allocator &allocator, const std::shared_ptr< CommandEncoderVK > &encoder, vk::DescriptorSet &vk_desc_set, std::vector< vk::DescriptorImageInfo > &images, std::vector< vk::WriteDescriptorSet > &writes)
 
static bool BindBuffers (const Bindings &bindings, Allocator &allocator, const std::shared_ptr< CommandEncoderVK > &encoder, vk::DescriptorSet &vk_desc_set, const std::vector< DescriptorSetLayout > &desc_set, std::vector< vk::DescriptorBufferInfo > &buffers, std::vector< vk::WriteDescriptorSet > &writes)
 
fml::StatusOr< std::vector< vk::DescriptorSet > > AllocateAndBindDescriptorSets (const ContextVK &context, const std::shared_ptr< CommandEncoderVK > &encoder, const std::vector< Command > &commands, const TextureVK &input_attachment)
 
fml::StatusOr< std::vector< vk::DescriptorSet > > AllocateAndBindDescriptorSets (const ContextVK &context, const std::shared_ptr< CommandEncoderVK > &encoder, const std::vector< ComputeCommand > &commands)
 
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)
 
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 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, bool supports_framebuffer_fetch)
 
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, bool supports_framebuffer_fetch)
 
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, bool supports_framebuffer_fetch)
 
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 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, const vk::DescriptorSet vk_desc_set)
 
static ShaderStage ToShaderStage (ArchiveShaderType 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)
 
constexpr ArchiveRenderingBackend ToArchiveRenderingBackend (fb::RenderingBackend backend)
 
constexpr fb::RenderingBackend ToRenderingBackend (ArchiveRenderingBackend backend)
 
constexpr ArchiveShaderType ToShaderType (fb::Stage stage)
 
bool Main (const fml::CommandLine &command_line)
 
std::optional< ArchiveShaderType > InferShaderTypefromFileExtension (const std::filesystem::path &path)
 
constexpr fb::Stage ToStage (ArchiveShaderType type)
 
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 size_t ComputeQuadrantDivisions (Scalar pixel_radius)
 
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 const GeometryResult kEmptyResult
 
static constexpr const char * kBlendModeNames []
 
constexpr float kE = 2.7182818284590452354f
 
constexpr float kLog2E = 1.4426950408889634074f
 
constexpr float kLog10E = 0.43429448190325182765f
 
constexpr float kLogE2 = 0.69314718055994530942f
 
constexpr float kLogE10 = 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 const constexpr char * kFramebufferFetchExt
 
static const constexpr char * kTextureBorderClampExt
 
static const constexpr char * kNvidiaTextureBorderClampExt
 
static const constexpr char * kMultisampledRenderToTextureExt
 
static constexpr size_t kMagicSubpassInputBinding = 64
 
static constexpr const char * kInstanceLayer = "ImpellerInstance"
 
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
 
static constexpr uint32_t kPoolSize = 1024u
 
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 int kPrecomputedDivisionCount = 1024
 
static int kPrecomputedDivisions [kPrecomputedDivisionCount]
 
static constexpr Scalar kScaleSize = 100000.0f
 
constexpr auto kPadding = 2
 

Typedef Documentation

◆ BlendColorBurnPipeline

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

Definition at line 179 of file content_context.h.

◆ BlendColorDodgePipeline

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

Definition at line 181 of file content_context.h.

◆ BlendColorPipeline

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

Definition at line 177 of file content_context.h.

◆ BlendDarkenPipeline

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

Definition at line 183 of file content_context.h.

◆ BlendDifferencePipeline

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

Definition at line 185 of file content_context.h.

◆ BlendExclusionPipeline

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

Definition at line 187 of file content_context.h.

◆ BlendHardLightPipeline

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

Definition at line 189 of file content_context.h.

◆ BlendHuePipeline

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

Definition at line 191 of file content_context.h.

◆ BlendLightenPipeline

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

Definition at line 193 of file content_context.h.

◆ BlendLuminosityPipeline

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

Definition at line 195 of file content_context.h.

◆ BlendMultiplyPipeline

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

Definition at line 197 of file content_context.h.

◆ BlendOverlayPipeline

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

Definition at line 199 of file content_context.h.

◆ BlendPipeline

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

Definition at line 129 of file content_context.h.

◆ BlendSaturationPipeline

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

Definition at line 201 of file content_context.h.

◆ BlendScreenPipeline

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

Definition at line 203 of file content_context.h.

◆ BlendSoftLightPipeline

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

Definition at line 205 of file content_context.h.

◆ BorderMaskBlurPipeline

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

Definition at line 147 of file content_context.h.

◆ BufferResource

using impeller::BufferResource = typedef Resource<BufferView>

Definition at line 57 of file command.h.

◆ Callback

using impeller::Callback = typedef std::function<void(MTLRenderPipelineDescriptor*)>

Definition at line 26 of file pipeline_library_mtl.mm.

◆ CanvasType

using impeller::CanvasType = typedef Canvas

CanvasType defines what is the concrete type of the Canvas to be used. When the recorder is enabled it will be swapped out in place of the Canvas at compile-time.

Definition at line 20 of file canvas_type.h.

◆ ClipPipeline

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

Definition at line 168 of file content_context.h.

◆ Clock

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

Definition at line 14 of file timing.h.

◆ ColorMatrixColorFilterPipeline

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

Definition at line 153 of file content_context.h.

◆ CommandPoolMap

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

Definition at line 131 of file command_pool_vk.cc.

◆ ComputePipelineMap

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

Definition at line 28 of file pipeline_library.h.

◆ ConicalGradientFillPipeline

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

Definition at line 112 of file content_context.h.

◆ ConicalGradientSSBOFillPipeline

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

Definition at line 120 of file content_context.h.

◆ CTessellator

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

Definition at line 25 of file tessellator.h.

◆ DescriptorPoolAndSize

using impeller::DescriptorPoolAndSize = typedef std::pair<vk::UniqueDescriptorPool, uint32_t>

Definition at line 50 of file descriptor_pool_vk.h.

◆ EllipticalVertexGenerator

using impeller::EllipticalVertexGenerator = typedef Tessellator::EllipticalVertexGenerator

Definition at line 377 of file tessellator.cc.

◆ FontGlyphMap

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

Definition at line 29 of file font_glyph_pair.h.

◆ FramebufferBlendColorBurnPipeline

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

Definition at line 212 of file content_context.h.

◆ FramebufferBlendColorDodgePipeline

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

Definition at line 215 of file content_context.h.

◆ FramebufferBlendColorPipeline

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

Definition at line 209 of file content_context.h.

◆ FramebufferBlendDarkenPipeline

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

Definition at line 218 of file content_context.h.

◆ FramebufferBlendDifferencePipeline

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

Definition at line 221 of file content_context.h.

◆ FramebufferBlendExclusionPipeline

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

Definition at line 224 of file content_context.h.

◆ FramebufferBlendHardLightPipeline

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

Definition at line 227 of file content_context.h.

◆ FramebufferBlendHuePipeline

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

Definition at line 230 of file content_context.h.

◆ FramebufferBlendLightenPipeline

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

Definition at line 233 of file content_context.h.

◆ FramebufferBlendLuminosityPipeline

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

Definition at line 236 of file content_context.h.

◆ FramebufferBlendMultiplyPipeline

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

Definition at line 239 of file content_context.h.

◆ FramebufferBlendOverlayPipeline

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

Definition at line 242 of file content_context.h.

◆ FramebufferBlendSaturationPipeline

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

Definition at line 245 of file content_context.h.

◆ FramebufferBlendScreenPipeline

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

Definition at line 248 of file content_context.h.

◆ FramebufferBlendSoftLightPipeline

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

Definition at line 251 of file content_context.h.

◆ GaussianBlurDecalPipeline

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

Definition at line 138 of file content_context.h.

◆ GaussianBlurFragmentShader

using impeller::GaussianBlurFragmentShader = typedef KernelPipeline::FragmentShader

Definition at line 19 of file gaussian_blur_filter_contents.cc.

◆ GaussianBlurPipeline

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

Definition at line 141 of file content_context.h.

◆ GaussianBlurVertexShader

using impeller::GaussianBlurVertexShader = typedef KernelPipeline::VertexShader

Definition at line 18 of file gaussian_blur_filter_contents.cc.

◆ GeometryColorPipeline

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

Definition at line 171 of file content_context.h.

◆ GlyphAtlasColorPipeline

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

Definition at line 163 of file content_context.h.

◆ GlyphAtlasPipeline

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

Definition at line 161 of file content_context.h.

◆ IPoint

using impeller::IPoint = typedef TPoint<int64_t>

Definition at line 309 of file point.h.

◆ IPoint32

using impeller::IPoint32 = typedef TPoint<int32_t>

Definition at line 310 of file point.h.

◆ IRect

using impeller::IRect = typedef TRect<int64_t>

Definition at line 489 of file rect.h.

◆ ISize

using impeller::ISize = typedef TSize<int64_t>

Definition at line 138 of file size.h.

◆ KernelDecalPipeline

using impeller::KernelDecalPipeline = typedef RenderPipelineT<GaussianBlurVertexShader, KernelDecalFragmentShader>

Definition at line 143 of file content_context.h.

◆ KernelPipeline

using impeller::KernelPipeline = typedef RenderPipelineT<GaussianBlurVertexShader, KernelNodecalFragmentShader>

Definition at line 145 of file content_context.h.

◆ LinearGradientFillPipeline

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

Definition at line 105 of file content_context.h.

◆ LinearGradientSSBOFillPipeline

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

Definition at line 117 of file content_context.h.

◆ LinearToSrgbFilterPipeline

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

Definition at line 156 of file content_context.h.

◆ MillisecondsF

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

Definition at line 12 of file timing.h.

◆ MixedOp

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

Definition at line 19 of file type_traits.h.

◆ MorphologyFilterPipeline

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

Definition at line 150 of file content_context.h.

◆ PathComponentVariant

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

Definition at line 163 of file path_component.h.

◆ PipelineMap

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

Definition at line 22 of file pipeline_library.h.

◆ PipelineProc

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

Definition at line 68 of file blend_filter_contents.cc.

◆ Point

using impeller::Point = typedef TPoint<Scalar>

Definition at line 308 of file point.h.

◆ PointsComputeShaderPipeline

using impeller::PointsComputeShaderPipeline = typedef ComputePipelineBuilder<PointsComputeShader>

Geometry Pipelines.

Definition at line 254 of file content_context.h.

◆ PorterDuffBlendPipeline

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

Definition at line 165 of file content_context.h.

◆ PositionUVPipeline

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

Definition at line 133 of file content_context.h.

◆ PrimaryKey

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

Definition at line 22 of file archivable.h.

◆ Quad

using impeller::Quad = typedef std::array<Point, 4>

Definition at line 313 of file point.h.

◆ RadialGradientFillPipeline

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

Definition at line 109 of file content_context.h.

◆ RadialGradientSSBOFillPipeline

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

Definition at line 123 of file content_context.h.

◆ Rect

using impeller::Rect = typedef TRect<Scalar>

Definition at line 488 of file rect.h.

◆ RRectBlurPipeline

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

Definition at line 128 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 37 of file sampler.h.

◆ Scalar

using impeller::Scalar = typedef float

Definition at line 18 of file scalar.h.

◆ SecondsF

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

Definition at line 13 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 44 of file shader_key.h.

◆ SharedHandleVK

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

Definition at line 52 of file shared_object_vk.h.

◆ Size

using impeller::Size = typedef TSize<Scalar>

Definition at line 137 of file size.h.

◆ SolidFillPipeline

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

Definition at line 107 of file content_context.h.

◆ SrgbToLinearFilterPipeline

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

Definition at line 159 of file content_context.h.

◆ SweepGradientFillPipeline

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

Definition at line 114 of file content_context.h.

◆ SweepGradientSSBOFillPipeline

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

Definition at line 126 of file content_context.h.

◆ TessellatedVertexProc

using impeller::TessellatedVertexProc = typedef Tessellator::TessellatedVertexProc

Definition at line 376 of file tessellator.cc.

◆ TexturePipeline

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

Definition at line 131 of file content_context.h.

◆ TextureResource

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

Definition at line 58 of file command.h.

◆ TextureUsageMask

using impeller::TextureUsageMask = typedef uint64_t

Definition at line 295 of file formats.h.

◆ TiledTexturePipeline

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

Definition at line 135 of file content_context.h.

◆ TimePoint

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

Definition at line 15 of file timing.h.

◆ UintPoint32

using impeller::UintPoint32 = typedef TPoint<uint32_t>

Definition at line 311 of file point.h.

◆ UniqueAllocatorVMA

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

Definition at line 31 of file vma.h.

◆ UniqueBufferVMA

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

Definition at line 98 of file vma.h.

◆ UniqueEGLImage

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

Definition at line 42 of file image.h.

◆ UniqueEGLImageKHR

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

Definition at line 73 of file image.h.

◆ UniqueGLTexture

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

Definition at line 38 of file texture.h.

◆ UniqueImageVMA

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

Definition at line 133 of file vma.h.

◆ UniquePoolVMA

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

Definition at line 63 of file vma.h.

◆ UvComputeShaderPipeline

using impeller::UvComputeShaderPipeline = typedef ComputePipelineBuilder<UvComputeShader>

Definition at line 255 of file content_context.h.

◆ Vector2

using impeller::Vector2 = typedef Point

Definition at line 312 of file point.h.

◆ WaitSet

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

Definition at line 25 of file fence_waiter_vk.h.

◆ YUVToRGBFilterPipeline

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

Definition at line 173 of file content_context.h.

Enumeration Type Documentation

◆ ArchiveRenderingBackend

enum impeller::ArchiveRenderingBackend
strong
Enumerator
kMetal 
kVulkan 
kOpenGLES 

Definition at line 16 of file shader_archive_types.h.

16  {
17  kMetal,
18  kVulkan,
19  kOpenGLES,
20 };

◆ ArchiveShaderType

enum impeller::ArchiveShaderType
strong
Enumerator
kVertex 
kFragment 
kCompute 

Definition at line 10 of file shader_archive_types.h.

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

◆ AttachmentKind

enum impeller::AttachmentKind
strong
Enumerator
kColor 
kDepth 
kStencil 
kDepthStencil 

Definition at line 397 of file formats_vk.h.

397  {
398  kColor,
399  kDepth,
400  kStencil,
401  kDepthStencil,
402 };

◆ BlendFactor

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

Definition at line 173 of file formats.h.

173  {
174  kZero,
175  kOne,
176  kSourceColor,
177  kOneMinusSourceColor,
178  kSourceAlpha,
179  kOneMinusSourceAlpha,
180  kDestinationColor,
181  kOneMinusDestinationColor,
182  kDestinationAlpha,
183  kOneMinusDestinationAlpha,
184  kSourceAlphaSaturated,
185  kBlendColor,
186  kOneMinusBlendColor,
187  kBlendAlpha,
188  kOneMinusBlendAlpha,
189 };

◆ BlendMode

enum impeller::BlendMode : uint8_t
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 59 of file color.h.

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

◆ BlendOperation

enum impeller::BlendOperation
strong
Enumerator
kAdd 
kSubtract 
kReverseSubtract 

Definition at line 191 of file formats.h.

191  {
192  kAdd,
193  kSubtract,
194  kReverseSubtract,
195 };

◆ BlendSelectValues

enum impeller::BlendSelectValues
strong
Enumerator
kScreen 
kOverlay 
kDarken 
kLighten 
kColorDodge 
kColorBurn 
kHardLight 
kSoftLight 
kDifference 
kExclusion 
kMultiply 
kHue 
kSaturation 
kColor 
kLuminosity 

Definition at line 15 of file framebuffer_blend_contents.h.

15  {
16  kScreen = 0,
17  kOverlay,
18  kDarken,
19  kLighten,
20  kColorDodge,
21  kColorBurn,
22  kHardLight,
23  kSoftLight,
24  kDifference,
25  kExclusion,
26  kMultiply,
27  kHue,
28  kSaturation,
29  kColor,
30  kLuminosity,
31 };

◆ CanvasRecorderOp

enum impeller::CanvasRecorderOp : uint16_t

TODO(tbd): These are very similar to flutter::DisplayListOpType. When golden tests can be written at a higher level, migrate these to flutter::DisplayListOpType.

Enumerator
kNew 
kSave 
kSaveLayer 
kRestore 
kRestoreToCount 
kResetTransform 
kTransform 
kConcat 
kPreConcat 
kTranslate 
kScale2 
kScale3 
kSkew 
kRotate 
kDrawPath 
kDrawPaint 
kDrawRect 
kDrawRRect 
kDrawCircle 
kDrawPoints 
kDrawImage 
kDrawImageRect 
kClipPath 
kClipRect 
kClipRRect 
kDrawPicture 
kDrawTextFrame 
kDrawVertices 
kDrawAtlas 

Definition at line 19 of file canvas_recorder.h.

19  : uint16_t {
20  kNew,
21  kSave,
22  kSaveLayer,
23  kRestore,
24  kRestoreToCount,
25  kResetTransform,
26  kTransform,
27  kConcat,
28  kPreConcat,
29  kTranslate,
30  kScale2,
31  kScale3,
32  kSkew,
33  kRotate,
34  kDrawPath,
35  kDrawPaint,
36  kDrawRect,
37  kDrawRRect,
38  kDrawCircle,
39  kDrawPoints,
40  kDrawImage,
41  kDrawImageRect,
42  kClipPath,
43  kClipRect,
44  kClipRRect,
45  kDrawPicture,
46  kDrawTextFrame,
47  kDrawVertices,
48  kDrawAtlas,
49 };

◆ Cap

enum impeller::Cap
strong
Enumerator
kButt 
kRound 
kSquare 

Definition at line 18 of file path.h.

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

◆ ColorWriteMask

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

Definition at line 433 of file formats.h.

433  : uint64_t {
434  kNone = 0,
435  kRed = 1 << 0,
436  kGreen = 1 << 1,
437  kBlue = 1 << 2,
438  kAlpha = 1 << 3,
439  kAll = kRed | kGreen | kBlue | kAlpha,
440 };

◆ CompareFunction

enum impeller::CompareFunction : uint8_t
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 529 of file formats.h.

529  : uint8_t {
530  /// Comparison test never passes.
531  kNever,
532  /// Comparison test passes always passes.
533  kAlways,
534  /// Comparison test passes if new_value < current_value.
535  kLess,
536  /// Comparison test passes if new_value == current_value.
537  kEqual,
538  /// Comparison test passes if new_value <= current_value.
539  kLessEqual,
540  /// Comparison test passes if new_value > current_value.
541  kGreater,
542  /// Comparison test passes if new_value != current_value.
543  kNotEqual,
544  /// Comparison test passes if new_value >= current_value.
545  kGreaterEqual,
546 };

◆ 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 18 of file texture_descriptor.h.

18  {
19  kLossless,
20  kLossy,
21 };

◆ Convexity

enum impeller::Convexity
strong
Enumerator
kUnknown 
kConvex 

Definition at line 38 of file path.h.

38  {
39  kUnknown,
40  kConvex,
41 };

◆ CullMode

enum impeller::CullMode
strong
Enumerator
kNone 
kFrontFace 
kBackFace 

Definition at line 335 of file formats.h.

335  {
336  kNone,
337  kFrontFace,
338  kBackFace,
339 };

◆ DebugResourceType

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

Definition at line 208 of file proc_table_gles.h.

208  {
209  kTexture,
210  kBuffer,
211  kProgram,
212  kShader,
213  kRenderBuffer,
214  kFrameBuffer,
215 };

◆ DescriptorType

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

Definition at line 153 of file shader_types.h.

153  {
154  kUniformBuffer,
155  kStorageBuffer,
156  kSampledImage,
157  kImage,
158  kSampler,
159  kInputAttachment,
160 };

◆ FillType

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

Definition at line 30 of file path.h.

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

◆ GeometryVertexType

enum impeller::GeometryVertexType
Enumerator
kPosition 
kColor 
kColor 
kUV 

Definition at line 34 of file geometry.h.

34  {
35  kPosition,
36  kColor,
37  kUV,
38 };

◆ HandleType

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

Definition at line 22 of file handle_gles.h.

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

◆ IndexType

enum impeller::IndexType
strong
Enumerator
kUnknown 
k16bit 
k32bit 
kNone 

Does not use the index buffer.

Definition at line 341 of file formats.h.

341  {
342  kUnknown,
343  k16bit,
344  k32bit,
345  /// Does not use the index buffer.
346  kNone,
347 };

◆ Join

enum impeller::Join
strong
Enumerator
kMiter 
kRound 
kBevel 

Definition at line 24 of file path.h.

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

◆ LoadAction

enum impeller::LoadAction
strong
Enumerator
kDontCare 
kLoad 
kClear 

Definition at line 197 of file formats.h.

197  {
198  kDontCare,
199  kLoad,
200  kClear,
201 };

◆ 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 404 of file formats.h.

404  {
405  /// Select nearest to the sample point. Most widely supported.
406  kNearest,
407  /// Select two points and linearly interpolate between them. Some formats
408  /// may not support this.
409  kLinear,
410 };

◆ 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 412 of file formats.h.

412  {
413  /// Sample from the nearest mip level.
414  kNearest,
415  /// Sample from the two nearest mip levels and linearly interpolate between
416  /// them.
417  kLinear,
418 };

◆ OptionalDeviceExtensionVK

enum impeller::OptionalDeviceExtensionVK : uint32_t
strong
Enumerator
kEXTPipelineCreationFeedback 
kARMRasterizationOrderAttachmentAccess 
kEXTRasterizationOrderAttachmentAccess 
kLast 

Definition at line 22 of file capabilities_vk.h.

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

◆ PixelFormat

enum impeller::PixelFormat : uint8_t
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  : uint8_t {
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 29 of file playground.h.

29  {
30  kMetal,
31  kOpenGLES,
32  kVulkan,
33 };

◆ PointStyle

enum impeller::PointStyle
strong
Enumerator
kRound 

Points are drawn as squares.

kSquare 

Points are drawn as circles.

Definition at line 40 of file canvas.h.

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

◆ PolygonMode

enum impeller::PolygonMode
strong
Enumerator
kFill 
kLine 

Definition at line 381 of file formats.h.

381  {
382  kFill,
383  kLine,
384 };

◆ PrimitiveType

enum impeller::PrimitiveType : uint8_t
strong

Decides how backend draws pixels based on input vertices.

Enumerator
kTriangle 

Draws a triage for each separate set of three vertices.

Vertices [A, B, C, D, E, F] will produce triages [ABC, DEF].

kTriangleStrip 

Draws a triage for every adjacent three vertices.

Vertices [A, B, C, D, E, F] will produce triages [ABC, BCD, CDE, DEF].

kLine 

Draws a line for each separate set of two vertices.

Vertices [A, B, C] will produce discontinued line [AB, BC].

kLineStrip 

Draws a continuous line that connect every input vertices

Vertices [A, B, C] will produce one continuous line [ABC].

kPoint 

Draws a point at each input vertex.

Definition at line 350 of file formats.h.

350  : uint8_t {
351  /// Draws a triage for each separate set of three vertices.
352  ///
353  /// Vertices [A, B, C, D, E, F] will produce triages
354  /// [ABC, DEF].
355  kTriangle,
356 
357  /// Draws a triage for every adjacent three vertices.
358  ///
359  /// Vertices [A, B, C, D, E, F] will produce triages
360  /// [ABC, BCD, CDE, DEF].
361  kTriangleStrip,
362 
363  /// Draws a line for each separate set of two vertices.
364  ///
365  /// Vertices [A, B, C] will produce discontinued line
366  /// [AB, BC].
367  kLine,
368 
369  /// Draws a continuous line that connect every input vertices
370  ///
371  /// Vertices [A, B, C] will produce one continuous line
372  /// [ABC].
373  kLineStrip,
374 
375  /// Draws a point at each input vertex.
376  kPoint,
377  // Triangle fans are implementation dependent and need extra extensions
378  // checks. Hence, they are not supported here.
379 };

◆ RuntimeShaderStage

enum impeller::RuntimeShaderStage
strong
Enumerator
kVertex 
kFragment 
kCompute 

Definition at line 37 of file runtime_types.h.

37  {
38  kVertex,
39  kFragment,
40  kCompute,
41 };

◆ RuntimeStageBackend

enum impeller::RuntimeStageBackend
strong
Enumerator
kSkSL 
kMetal 
kOpenGLES 
kVulkan 

Definition at line 14 of file runtime_types.h.

14  {
15  kSkSL,
16  kMetal,
17  kOpenGLES,
18  kVulkan,
19 };

◆ RuntimeUniformType

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

Definition at line 21 of file runtime_types.h.

21  {
22  kBoolean,
23  kSignedByte,
24  kUnsignedByte,
25  kSignedShort,
26  kUnsignedShort,
27  kSignedInt,
28  kUnsignedInt,
29  kSignedInt64,
30  kUnsignedInt64,
31  kHalfFloat,
32  kFloat,
33  kDouble,
34  kSampledImage,
35 };

◆ SampleCount

enum impeller::SampleCount : uint8_t
strong
Enumerator
kCount1 
kCount4 

Definition at line 290 of file formats.h.

290  : uint8_t {
291  kCount1 = 1,
292  kCount4 = 4,
293 };

◆ 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 420 of file formats.h.

420  {
421  kClampToEdge,
422  kRepeat,
423  kMirror,
424  // More modes are almost always supported but they are usually behind
425  // extensions checks. The ones current in these structs are safe (always
426  // supported) defaults.
427 
428  /// @brief decal sampling mode is only supported on devices that pass
429  /// the `Capabilities.SupportsDecalSamplerAddressMode` check.
430  kDecal,
431 };

◆ ShaderStage

enum impeller::ShaderStage
strong
Enumerator
kUnknown 
kVertex 
kFragment 
kCompute 

Definition at line 22 of file shader_types.h.

22  {
23  kUnknown,
24  kVertex,
25  kFragment,
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 41 of file shader_types.h.

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

◆ StencilOperation

enum impeller::StencilOperation : uint8_t
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 548 of file formats.h.

548  : uint8_t {
549  /// Don't modify the current stencil value.
550  kKeep,
551  /// Reset the stencil value to zero.
552  kZero,
553  /// Reset the stencil value to the reference value.
554  kSetToReferenceValue,
555  /// Increment the current stencil value by 1. Clamp it to the maximum.
556  kIncrementClamp,
557  /// Decrement the current stencil value by 1. Clamp it to zero.
558  kDecrementClamp,
559  /// Perform a logical bitwise invert on the current stencil value.
560  kInvert,
561  /// Increment the current stencil value by 1. If at maximum, set to zero.
562  kIncrementWrap,
563  /// Decrement the current stencil value by 1. If at zero, set to maximum.
564  kDecrementWrap,
565 };

◆ 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 203 of file formats.h.

203  {
204  kDontCare,
205  kStore,
206  kMultisampleResolve,
207  kStoreAndMultisampleResolve,
208 };

◆ TextureCoordinateSystem

enum impeller::TextureCoordinateSystem
strong
Enumerator
kUploadFromHost 
kRenderToTexture 

Definition at line 325 of file formats.h.

325  {
326  // Alternative coordinate system used when uploading texture data from the
327  // host.
328  // (0, 0) is the bottom-left of the image with +Y going up.
329  kUploadFromHost,
330  // Default coordinate system.
331  // (0, 0) is the top-left of the image with +Y going down.
332  kRenderToTexture,
333 };

◆ TextureType

enum impeller::TextureType
strong
Enumerator
kTexture2D 
kTexture2DMultisample 
kTextureCube 
kTextureExternalOES 

Definition at line 257 of file formats.h.

257  {
258  kTexture2D,
259  kTexture2DMultisample,
260  kTextureCube,
261  kTextureExternalOES,
262 };

◆ TextureUsage

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

Definition at line 297 of file formats.h.

297  : TextureUsageMask {
298  kUnknown = 0,
299  kShaderRead = 1 << 0,
300  kShaderWrite = 1 << 1,
301  kRenderTarget = 1 << 2,
302 };

◆ UseSubpassInput

enum impeller::UseSubpassInput
strong
Enumerator
kYes 
kNo 

Definition at line 24 of file pipeline_descriptor.h.

24  {
25  kYes,
26  kNo,
27 };

◆ WindingOrder

enum impeller::WindingOrder
strong
Enumerator
kClockwise 
kCounterClockwise 

Definition at line 27 of file tessellator.h.

27  {
28  kClockwise,
29  kCounterClockwise,
30 };

◆ YUVColorSpace

enum impeller::YUVColorSpace
strong
Enumerator
kBT601LimitedRange 
kBT601FullRange 

Definition at line 55 of file color.h.

55 { 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 21 of file scalar.h.

21  {
22  return val >= T{} ? val : -val;
23 }

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 71 of file blend_filter_contents.cc.

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

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::GetClipDepth(), impeller::Entity::GetContents(), impeller::ContentContext::GetContext(), impeller::ContentContext::GetDeviceCapabilities(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::Intersection(), kDecal, kSource, kTriangleStrip, impeller::ColorFilterContents::kYes, impeller::ContentContext::MakeSubpass(), impeller::Matrix::MakeTranslation(), OptionsFromPass(), impeller::Command::pipeline, SPrintF(), impeller::Capabilities::SupportsDecalSamplerAddressMode(), and impeller::Snapshot::texture.

◆ AllocateAndBindDescriptorSets() [1/2]

fml::StatusOr< std::vector< vk::DescriptorSet > > impeller::AllocateAndBindDescriptorSets ( const ContextVK &  context,
const std::shared_ptr< CommandEncoderVK > &  encoder,
const std::vector< Command > &  commands,
const TextureVK &  input_attachment 
)

Definition at line 123 of file binding_helpers_vk.cc.

127  {
128  if (commands.empty()) {
129  return std::vector<vk::DescriptorSet>{};
130  }
131 
132  // Step 1: Determine the total number of buffer and sampler descriptor
133  // sets required. Collect this information along with the layout information
134  // to allocate a correctly sized descriptor pool.
135  size_t buffer_count = 0;
136  size_t samplers_count = 0;
137  size_t subpass_count = 0;
138  std::vector<vk::DescriptorSetLayout> layouts;
139  layouts.reserve(commands.size());
140 
141  for (const auto& command : commands) {
142  buffer_count += command.vertex_bindings.buffers.size();
143  buffer_count += command.fragment_bindings.buffers.size();
144  samplers_count += command.fragment_bindings.sampled_images.size();
145  subpass_count +=
146  command.pipeline->GetDescriptor().UsesSubpassInput() ? 1 : 0;
147 
148  layouts.emplace_back(
149  PipelineVK::Cast(*command.pipeline).GetDescriptorSetLayout());
150  }
151  auto descriptor_result = encoder->AllocateDescriptorSets(
152  buffer_count, samplers_count, subpass_count, layouts);
153  if (!descriptor_result.ok()) {
154  return descriptor_result.status();
155  }
156  auto descriptor_sets = descriptor_result.value();
157  if (descriptor_sets.empty()) {
158  return fml::Status();
159  }
160 
161  // Step 2: Update the descriptors for all image and buffer descriptors used
162  // in the render pass.
163  std::vector<vk::DescriptorImageInfo> images;
164  std::vector<vk::DescriptorBufferInfo> buffers;
165  std::vector<vk::WriteDescriptorSet> writes;
166  images.reserve(samplers_count + subpass_count);
167  buffers.reserve(buffer_count);
168  writes.reserve(samplers_count + buffer_count + subpass_count);
169 
170  auto& allocator = *context.GetResourceAllocator();
171  auto desc_index = 0u;
172  for (const auto& command : commands) {
173  auto desc_set = command.pipeline->GetDescriptor()
174  .GetVertexDescriptor()
175  ->GetDescriptorSetLayouts();
176 
177  if (!BindBuffers(command.vertex_bindings, allocator, encoder,
178  descriptor_sets[desc_index], desc_set, buffers, writes) ||
179  !BindBuffers(command.fragment_bindings, allocator, encoder,
180  descriptor_sets[desc_index], desc_set, buffers, writes) ||
181  !BindImages(command.fragment_bindings, allocator, encoder,
182  descriptor_sets[desc_index], images, writes)) {
183  return fml::Status(fml::StatusCode::kUnknown,
184  "Failed to bind texture or buffer.");
185  }
186 
187  if (command.pipeline->GetDescriptor().UsesSubpassInput()) {
188  vk::DescriptorImageInfo image_info;
189  image_info.imageLayout = vk::ImageLayout::eGeneral;
190  image_info.sampler = VK_NULL_HANDLE;
191  image_info.imageView = input_attachment.GetImageView();
192  images.push_back(image_info);
193 
194  vk::WriteDescriptorSet write_set;
195  write_set.dstSet = descriptor_sets[desc_index];
196  write_set.dstBinding = kMagicSubpassInputBinding;
197  write_set.descriptorCount = 1u;
198  write_set.descriptorType = vk::DescriptorType::eInputAttachment;
199  write_set.pImageInfo = &images.back();
200 
201  writes.push_back(write_set);
202  }
203  desc_index += 1;
204  }
205 
206  context.GetDevice().updateDescriptorSets(writes, {});
207  return descriptor_sets;
208 }

References BindBuffers(), BindImages(), impeller::BackendCast< PipelineVK, Pipeline< PipelineDescriptor > >::Cast(), impeller::PipelineVK::GetDescriptorSetLayout(), impeller::ContextVK::GetDevice(), impeller::TextureVK::GetImageView(), impeller::ContextVK::GetResourceAllocator(), and kMagicSubpassInputBinding.

◆ AllocateAndBindDescriptorSets() [2/2]

fml::StatusOr< std::vector< vk::DescriptorSet > > impeller::AllocateAndBindDescriptorSets ( const ContextVK &  context,
const std::shared_ptr< CommandEncoderVK > &  encoder,
const std::vector< ComputeCommand > &  commands 
)

Definition at line 210 of file binding_helpers_vk.cc.

213  {
214  if (commands.empty()) {
215  return std::vector<vk::DescriptorSet>{};
216  }
217  // Step 1: Determine the total number of buffer and sampler descriptor
218  // sets required. Collect this information along with the layout information
219  // to allocate a correctly sized descriptor pool.
220  size_t buffer_count = 0;
221  size_t samplers_count = 0;
222  std::vector<vk::DescriptorSetLayout> layouts;
223  layouts.reserve(commands.size());
224 
225  for (const auto& command : commands) {
226  buffer_count += command.bindings.buffers.size();
227  samplers_count += command.bindings.sampled_images.size();
228 
229  layouts.emplace_back(
230  ComputePipelineVK::Cast(*command.pipeline).GetDescriptorSetLayout());
231  }
232  auto descriptor_result =
233  encoder->AllocateDescriptorSets(buffer_count, samplers_count, 0, layouts);
234  if (!descriptor_result.ok()) {
235  return descriptor_result.status();
236  }
237  auto descriptor_sets = descriptor_result.value();
238  if (descriptor_sets.empty()) {
239  return fml::Status();
240  }
241  // Step 2: Update the descriptors for all image and buffer descriptors used
242  // in the render pass.
243  std::vector<vk::DescriptorImageInfo> images;
244  std::vector<vk::DescriptorBufferInfo> buffers;
245  std::vector<vk::WriteDescriptorSet> writes;
246  images.reserve(samplers_count);
247  buffers.reserve(buffer_count);
248  writes.reserve(samplers_count + buffer_count);
249 
250  auto& allocator = *context.GetResourceAllocator();
251  auto desc_index = 0u;
252  for (const auto& command : commands) {
253  auto desc_set = command.pipeline->GetDescriptor().GetDescriptorSetLayouts();
254 
255  if (!BindBuffers(command.bindings, allocator, encoder,
256  descriptor_sets[desc_index], desc_set, buffers, writes) ||
257  !BindImages(command.bindings, allocator, encoder,
258  descriptor_sets[desc_index], images, writes)) {
259  return fml::Status(fml::StatusCode::kUnknown,
260  "Failed to bind texture or buffer.");
261  }
262  desc_index += 1;
263  }
264 
265  context.GetDevice().updateDescriptorSets(writes, {});
266  return descriptor_sets;
267 }

References BindBuffers(), BindImages(), impeller::BackendCast< ComputePipelineVK, Pipeline< ComputePipelineDescriptor > >::Cast(), impeller::ComputePipelineVK::GetDescriptorSetLayout(), impeller::ContextVK::GetDevice(), and impeller::ContextVK::GetResourceAllocator().

◆ 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 101 of file path_component.cc.

101  {
102  constexpr Scalar d = 0.67;
103  return x / (1.0 - d + sqrt(sqrt(pow(d, 4) + 0.25 * x * x)));
104 }

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

◆ AttachmentKindFromFormat()

constexpr AttachmentKind impeller::AttachmentKindFromFormat ( PixelFormat  format)
constexpr

Definition at line 404 of file formats_vk.h.

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

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 220 of file proc_table_gles.cc.

220  {
221  switch (type) {
222  case GL_RENDERBUFFER:
223  return "GL_RENDERBUFFER";
224  case GL_TEXTURE:
225  return "GL_TEXTURE";
226  case GL_NONE:
227  return "GL_NONE";
228  }
229 
230  return "Unknown Type";
231 }

Referenced by DescribeFramebufferAttachment().

◆ BENCHMARK_CAPTURE() [1/8]

impeller::BENCHMARK_CAPTURE ( BM_CanvasRecord  ,
draw_circle  ,
&  DrawCircle 
)

◆ BENCHMARK_CAPTURE() [2/8]

impeller::BENCHMARK_CAPTURE ( BM_CanvasRecord  ,
draw_line  ,
&  DrawLine 
)

◆ BENCHMARK_CAPTURE() [3/8]

impeller::BENCHMARK_CAPTURE ( BM_CanvasRecord  ,
draw_rect  ,
&  DrawRect 
)

◆ BENCHMARK_CAPTURE() [4/8]

impeller::BENCHMARK_CAPTURE ( BM_Convex  ,
rrect_convex  ,
CreateRRect()  ,
true   
)

◆ BENCHMARK_CAPTURE() [5/8]

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

◆ BENCHMARK_CAPTURE() [6/8]

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

◆ BENCHMARK_CAPTURE() [7/8]

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

◆ BENCHMARK_CAPTURE() [8/8]

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 166 of file compute_pass_mtl.mm.

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

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 189 of file compute_pass_mtl.mm.

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

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 358 of file render_pass_mtl.mm.

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

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 381 of file render_pass_mtl.mm.

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

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

◆ BindBuffers()

static bool impeller::BindBuffers ( const Bindings &  bindings,
Allocator &  allocator,
const std::shared_ptr< CommandEncoderVK > &  encoder,
vk::DescriptorSet &  vk_desc_set,
const std::vector< DescriptorSetLayout > &  desc_set,
std::vector< vk::DescriptorBufferInfo > &  buffers,
std::vector< vk::WriteDescriptorSet > &  writes 
)
static

Definition at line 63 of file binding_helpers_vk.cc.

69  {
70  for (const BufferAndUniformSlot& data : bindings.buffers) {
71  const auto& buffer_view = data.view.resource.buffer;
72 
73  auto device_buffer = buffer_view->GetDeviceBuffer(allocator);
74  if (!device_buffer) {
75  VALIDATION_LOG << "Failed to get device buffer for vertex binding";
76  return false;
77  }
78 
79  auto buffer = DeviceBufferVK::Cast(*device_buffer).GetBuffer();
80  if (!buffer) {
81  return false;
82  }
83 
84  if (!encoder->Track(device_buffer)) {
85  return false;
86  }
87 
88  uint32_t offset = data.view.resource.range.offset;
89 
90  vk::DescriptorBufferInfo buffer_info;
91  buffer_info.buffer = buffer;
92  buffer_info.offset = offset;
93  buffer_info.range = data.view.resource.range.length;
94  buffers.push_back(buffer_info);
95 
96  // TODO(jonahwilliams): remove this part by storing more data in
97  // ShaderUniformSlot.
98  const ShaderUniformSlot& uniform = data.slot;
99  auto layout_it =
100  std::find_if(desc_set.begin(), desc_set.end(),
101  [&uniform](const DescriptorSetLayout& layout) {
102  return layout.binding == uniform.binding;
103  });
104  if (layout_it == desc_set.end()) {
105  VALIDATION_LOG << "Failed to get descriptor set layout for binding "
106  << uniform.binding;
107  return false;
108  }
109  auto layout = *layout_it;
110 
111  vk::WriteDescriptorSet write_set;
112  write_set.dstSet = vk_desc_set;
113  write_set.dstBinding = uniform.binding;
114  write_set.descriptorCount = 1u;
115  write_set.descriptorType = ToVKDescriptorType(layout.descriptor_type);
116  write_set.pBufferInfo = &buffers.back();
117 
118  writes.push_back(write_set);
119  }
120  return true;
121 }

References impeller::ShaderUniformSlot::binding, impeller::BufferView::buffer, impeller::Bindings::buffers, impeller::BackendCast< DeviceBufferVK, Buffer >::Cast(), impeller::DescriptorSetLayout::descriptor_type, impeller::DeviceBufferVK::GetBuffer(), impeller::Range::length, impeller::Range::offset, impeller::BufferView::range, impeller::Resource< T >::resource, impeller::BufferAndUniformSlot::slot, ToVKDescriptorType(), VALIDATION_LOG, and impeller::BufferAndUniformSlot::view.

Referenced by AllocateAndBindDescriptorSets().

◆ BindImages()

static bool impeller::BindImages ( const Bindings &  bindings,
Allocator &  allocator,
const std::shared_ptr< CommandEncoderVK > &  encoder,
vk::DescriptorSet &  vk_desc_set,
std::vector< vk::DescriptorImageInfo > &  images,
std::vector< vk::WriteDescriptorSet > &  writes 
)
static

Definition at line 26 of file binding_helpers_vk.cc.

31  {
32  for (const TextureAndSampler& data : bindings.sampled_images) {
33  auto texture = data.texture.resource;
34  const auto& texture_vk = TextureVK::Cast(*texture);
35  const SamplerVK& sampler = SamplerVK::Cast(*data.sampler);
36 
37  if (!encoder->Track(texture) ||
38  !encoder->Track(sampler.GetSharedSampler())) {
39  return false;
40  }
41 
42  const SampledImageSlot& slot = data.slot;
43 
44  vk::DescriptorImageInfo image_info;
45  image_info.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
46  image_info.sampler = sampler.GetSampler();
47  image_info.imageView = texture_vk.GetImageView();
48  images.push_back(image_info);
49 
50  vk::WriteDescriptorSet write_set;
51  write_set.dstSet = vk_desc_set;
52  write_set.dstBinding = slot.binding;
53  write_set.descriptorCount = 1u;
54  write_set.descriptorType = vk::DescriptorType::eCombinedImageSampler;
55  write_set.pImageInfo = &images.back();
56 
57  writes.push_back(write_set);
58  }
59 
60  return true;
61 };

References impeller::SampledImageSlot::binding, impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::BackendCast< SamplerVK, Sampler >::Cast(), impeller::SamplerVK::GetSampler(), impeller::SamplerVK::GetSharedSampler(), impeller::Resource< T >::resource, impeller::Bindings::sampled_images, impeller::TextureAndSampler::sampler, impeller::TextureAndSampler::slot, and impeller::TextureAndSampler::texture.

Referenced by AllocateAndBindDescriptorSets().

◆ 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(), impeller::testing::TEST(), and impeller::TraceSerializer::Write().

◆ BM_CanvasRecord()

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

Definition at line 42 of file canvas_benchmarks.cc.

42  {
43  auto args_tuple = std::make_tuple(std::move(args)...);
44  auto test_proc = std::get<CanvasCallback>(args_tuple);
45 
46  size_t op_count = 0u;
47  size_t canvas_count = 0u;
48  while (state.KeepRunning()) {
49  // A new canvas is allocated for each iteration to avoid the benchmark
50  // becoming a measurement of only the entity vector re-allocation time.
51  Canvas canvas;
52  op_count += test_proc(canvas);
53  canvas_count++;
54  }
55  state.counters["TotalOpCount"] = op_count;
56  state.counters["TotalCanvasCount"] = canvas_count;
57 }

◆ BM_Convex()

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

Definition at line 68 of file geometry_benchmarks.cc.

68  {
69  auto args_tuple = std::make_tuple(std::move(args)...);
70  auto path = std::get<Path>(args_tuple).Clone();
71 
72  size_t point_count = 0u;
73  size_t single_point_count = 0u;
74  auto points = std::make_unique<std::vector<Point>>();
75  points->reserve(2048);
76  while (state.KeepRunning()) {
77  auto points = tess.TessellateConvex(path, 1.0f);
78  single_point_count = points.size();
79  point_count += points.size();
80  }
81  state.counters["SinglePointCount"] = single_point_count;
82  state.counters["TotalPointCount"] = point_count;
83 }

References tess, and impeller::Tessellator::TessellateConvex().

◆ BM_Polyline()

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

Definition at line 26 of file geometry_benchmarks.cc.

26  {
27  auto args_tuple = std::make_tuple(std::move(args)...);
28  auto path = std::get<Path>(args_tuple).Clone();
29  bool tessellate = std::get<bool>(args_tuple);
30 
31  size_t point_count = 0u;
32  size_t single_point_count = 0u;
33  auto points = std::make_unique<std::vector<Point>>();
34  points->reserve(2048);
35  while (state.KeepRunning()) {
36  if (tessellate) {
37  tess.Tessellate(path, 1.0f,
38  [&point_count, &single_point_count](
39  const float* vertices, size_t vertices_count,
40  const uint16_t* indices, size_t indices_count) {
41  if (indices_count > 0) {
42  single_point_count = indices_count;
43  point_count += indices_count;
44  } else {
45  single_point_count = vertices_count;
46  point_count += vertices_count;
47  }
48  return true;
49  });
50  } else {
51  auto polyline = path.CreatePolyline(
52  // Clang-tidy doesn't know that the points get moved back before
53  // getting moved again in this loop.
54  // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
55  1.0f, std::move(points),
56  [&points](Path::Polyline::PointBufferPtr reclaimed) {
57  points = std::move(reclaimed);
58  });
59  single_point_count = polyline.points->size();
60  point_count += single_point_count;
61  }
62  }
63  state.counters["SinglePointCount"] = single_point_count;
64  state.counters["TotalPointCount"] = point_count;
65 }

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

◆ BytesPerPixelForPixelFormat()

constexpr size_t impeller::BytesPerPixelForPixelFormat ( PixelFormat  format)
constexpr

Definition at line 442 of file formats.h.

442  {
443  switch (format) {
444  case PixelFormat::kUnknown:
445  return 0u;
446  case PixelFormat::kA8UNormInt:
447  case PixelFormat::kR8UNormInt:
448  case PixelFormat::kS8UInt:
449  return 1u;
450  case PixelFormat::kR8G8UNormInt:
451  return 2u;
452  case PixelFormat::kR8G8B8A8UNormInt:
453  case PixelFormat::kR8G8B8A8UNormIntSRGB:
454  case PixelFormat::kB8G8R8A8UNormInt:
455  case PixelFormat::kB8G8R8A8UNormIntSRGB:
456  case PixelFormat::kB10G10R10XRSRGB:
457  case PixelFormat::kB10G10R10XR:
458  return 4u;
459  case PixelFormat::kD24UnormS8Uint:
460  return 4u;
461  case PixelFormat::kD32FloatS8UInt:
462  return 5u;
463  case PixelFormat::kR16G16B16A16Float:
464  case PixelFormat::kB10G10R10A10XR:
465  return 8u;
466  case PixelFormat::kR32G32B32A32Float:
467  return 16u;
468  }
469  return 0u;
470 }

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.GetSize() * 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::TRect< T >::GetSize(), impeller::FontGlyphPair::glyph, impeller::TSize< T >::IsEmpty(), kPadding, impeller::TRect< Scalar >::MakeXYWH(), impeller::ScaledFont::scale, impeller::FontGlyphPair::scaled_font, 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 234 of file formats.h.

234  {
235  switch (action) {
236  case LoadAction::kLoad:
237  return false;
238  case LoadAction::kDontCare:
239  case LoadAction::kClear:
240  return true;
241  }
242  FML_UNREACHABLE();
243 }

References kClear, kDontCare, and kLoad.

Referenced by EncodeCommandsInReactor().

◆ CanDiscardAttachmentWhenDone()

constexpr bool impeller::CanDiscardAttachmentWhenDone ( StoreAction  action)
constexpr

Definition at line 245 of file formats.h.

245  {
246  switch (action) {
247  case StoreAction::kStore:
248  case StoreAction::kStoreAndMultisampleResolve:
249  return false;
250  case StoreAction::kDontCare:
251  case StoreAction::kMultisampleResolve:
252  return true;
253  }
254  FML_UNREACHABLE();
255 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by EncodeCommandsInReactor().

◆ ChooseAlphaCompositionMode()

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

Definition at line 106 of file swapchain_impl_vk.cc.

107  {
108  if (flags & vk::CompositeAlphaFlagBitsKHR::eInherit) {
109  return vk::CompositeAlphaFlagBitsKHR::eInherit;
110  }
111  if (flags & vk::CompositeAlphaFlagBitsKHR::ePreMultiplied) {
112  return vk::CompositeAlphaFlagBitsKHR::ePreMultiplied;
113  }
114  if (flags & vk::CompositeAlphaFlagBitsKHR::ePostMultiplied) {
115  return vk::CompositeAlphaFlagBitsKHR::ePostMultiplied;
116  }
117  if (flags & vk::CompositeAlphaFlagBitsKHR::eOpaque) {
118  return vk::CompositeAlphaFlagBitsKHR::eOpaque;
119  }
120 
121  return std::nullopt;
122 }

◆ 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 124 of file swapchain_impl_vk.cc.

127  {
128  const auto families = physical_device.getQueueFamilyProperties();
129  for (size_t family_index = 0u; family_index < families.size();
130  family_index++) {
131  auto [result, supported] =
132  physical_device.getSurfaceSupportKHR(family_index, surface);
133  if (result == vk::Result::eSuccess && supported) {
134  return device.getQueue(family_index, 0u);
135  }
136  }
137  return std::nullopt;
138 }

◆ ChooseSurfaceFormat()

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

Definition at line 84 of file swapchain_impl_vk.cc.

86  {
87  const auto colorspace = vk::ColorSpaceKHR::eSrgbNonlinear;
88  const auto vk_preference =
89  vk::SurfaceFormatKHR{ToVKImageFormat(preference), colorspace};
90  if (ContainsFormat(formats, vk_preference)) {
91  return vk_preference;
92  }
93 
94  std::vector<vk::SurfaceFormatKHR> options = {
95  {vk::Format::eB8G8R8A8Unorm, colorspace},
96  {vk::Format::eR8G8B8A8Unorm, colorspace}};
97  for (const auto& format : options) {
98  if (ContainsFormat(formats, format)) {
99  return format;
100  }
101  }
102 
103  return std::nullopt;
104 }

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 108 of file reactor_gles.cc.

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

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 23 of file texture_descriptor.h.

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

References kLossless, and kLossy.

Referenced by TextureDescriptorToString().

◆ ComputeQuadrantDivisions()

static size_t impeller::ComputeQuadrantDivisions ( Scalar  pixel_radius)
static

Definition at line 297 of file tessellator.cc.

297  {
298  if (pixel_radius <= 0.0) {
299  return 1;
300  }
301  int radius_index = ceil(pixel_radius);
302  if (radius_index < kPrecomputedDivisionCount) {
303  return kPrecomputedDivisions[radius_index];
304  }
305 
306  // For a circle with N divisions per quadrant, the maximum deviation of
307  // the polgyon approximation from the true circle will be at the center
308  // of the base of each triangular pie slice. We can compute that distance
309  // by finding the midpoint of the line of the first slice and compare
310  // its distance from the center of the circle to the radius. We will aim
311  // to have the length of that bisector to be within |kCircleTolerance|
312  // from the radius in pixels.
313  //
314  // Each vertex will appear at an angle of:
315  // theta(i) = (kPi / 2) * (i / N) // for i in [0..N]
316  // with each point falling at:
317  // point(i) = r * (cos(theta), sin(theta))
318  // If we consider the unit circle to simplify the calculations below then
319  // we need to scale the tolerance from its absolute quantity into a unit
320  // circle fraction:
321  // k = tolerance / radius
322  // Using this scaled tolerance below to avoid multiplying by the radius
323  // throughout all of the math, we have:
324  // first point = (1, 0) // theta(0) == 0
325  // theta = kPi / 2 / N // theta(1)
326  // second point = (cos(theta), sin(theta)) = (c, s)
327  // midpoint = (first + second) * 0.5 = ((1 + c)/2, s/2)
328  // |midpoint| = sqrt((1 + c)*(1 + c)/4 + s*s/4)
329  // = sqrt((1 + c + c + c*c + s*s) / 4)
330  // = sqrt((1 + 2c + 1) / 4)
331  // = sqrt((2 + 2c) / 4)
332  // = sqrt((1 + c) / 2)
333  // = cos(theta / 2) // using half-angle cosine formula
334  // error = 1 - |midpoint| = 1 - cos(theta / 2)
335  // cos(theta/2) = 1 - error
336  // theta/2 = acos(1 - error)
337  // kPi / 2 / N / 2 = acos(1 - error)
338  // kPi / 4 / acos(1 - error) = N
339  // Since we need error <= k, we want divisions >= N, so we use:
340  // N = ceil(kPi / 4 / acos(1 - k))
341  //
342  // Math is confirmed in https://math.stackexchange.com/a/4132095
343  // (keeping in mind that we are computing quarter circle divisions here)
344  // which also points out a performance optimization that is accurate
345  // to within an over-estimation of 1 division would be:
346  // N = ceil(kPi / 4 / sqrt(2 * k))
347  // Since we have precomputed the divisions for radii up to 1024, we can
348  // afford to be more accurate using the acos formula here for larger radii.
349  double k = Tessellator::kCircleTolerance / pixel_radius;
350  return ceil(kPiOver4 / std::acos(1 - k));
351 }

References impeller::Tessellator::kCircleTolerance, kPiOver4, kPrecomputedDivisionCount, and kPrecomputedDivisions.

Referenced by impeller::Tessellator::FilledCircle(), impeller::Tessellator::FilledEllipse(), impeller::Tessellator::FilledRoundRect(), impeller::Tessellator::RoundCapLine(), and impeller::Tessellator::StrokedCircle().

◆ 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 91 of file geometry.cc.

95  {
96  VertexBufferBuilder<TextureFillVertexShader::PerVertexData> vertex_builder;
97  vertex_builder.Reserve(input.GetVertexCount());
98  input.IterateVertices(
99  [&vertex_builder, &texture_coverage, &effect_transform,
100  &texture_origin](SolidFillVertexShader::PerVertexData old_vtx) {
101  TextureFillVertexShader::PerVertexData data;
102  data.position = old_vtx.position;
103  data.texture_coords = effect_transform *
104  (old_vtx.position - texture_origin) /
105  texture_coverage;
106  vertex_builder.AppendVertex(data);
107  });
108  return vertex_builder;
109 }

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 111 of file geometry.cc.

116  {
117  auto& host_buffer = pass.GetTransientsBuffer();
118 
119  auto uv_transform =
120  texture_coverage.GetNormalizingTransform() * effect_transform;
121  std::vector<Point> data(8);
122  auto points = source_rect.GetPoints();
123  for (auto i = 0u, j = 0u; i < 8; i += 2, j++) {
124  data[i] = points[j];
125  data[i + 1] = uv_transform * points[j];
126  }
127 
128  return GeometryResult{
129  .type = PrimitiveType::kTriangleStrip,
130  .vertex_buffer =
131  {
132  .vertex_buffer = host_buffer.Emplace(
133  data.data(), 16 * sizeof(float), alignof(float)),
134  .vertex_count = 4,
135  .index_type = IndexType::kNone,
136  },
137  .transform = pass.GetOrthographicTransform() * entity.GetTransform(),
138  .prevent_overdraw = false,
139  };
140 }

References impeller::TRect< T >::GetNormalizingTransform(), impeller::RenderPass::GetOrthographicTransform(), impeller::TRect< T >::GetPoints(), impeller::Entity::GetTransform(), impeller::RenderPass::GetTransientsBuffer(), kNone, kTriangleStrip, and impeller::GeometryResult::type.

◆ ConfigureAttachment()

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

Definition at line 55 of file render_pass_mtl.mm.

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

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 43 of file render_pass_gles.cc.

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

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 72 of file render_pass_mtl.mm.

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

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 82 of file render_pass_mtl.mm.

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

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, 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 26 of file render_pass_mtl.mm.

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

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 96 of file render_pass_gles.cc.

98  {
99  if (!pipeline.HasStencilAttachmentDescriptors()) {
100  gl.Disable(GL_STENCIL_TEST);
101  return;
102  }
103 
104  gl.Enable(GL_STENCIL_TEST);
105  const auto& front = pipeline.GetFrontStencilAttachmentDescriptor();
106  const auto& back = pipeline.GetBackStencilAttachmentDescriptor();
107 
108  if (front.has_value() && back.has_value() && front == back) {
109  ConfigureStencil(GL_FRONT_AND_BACK, gl, *front, stencil_reference);
110  return;
111  }
112  if (front.has_value()) {
113  ConfigureStencil(GL_FRONT, gl, *front, stencil_reference);
114  }
115  if (back.has_value()) {
116  ConfigureStencil(GL_BACK, gl, *back, stencil_reference);
117  }
118 }

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 78 of file render_pass_gles.cc.

81  {
82  gl.StencilOpSeparate(
83  face, // face
84  ToStencilOp(stencil.stencil_failure), // stencil fail
85  ToStencilOp(stencil.depth_failure), // depth fail
86  ToStencilOp(stencil.depth_stencil_pass) // depth stencil pass
87  );
88  gl.StencilFuncSeparate(face, // face
89  ToCompareFunction(stencil.stencil_compare), // func
90  stencil_reference, // ref
91  stencil.read_mask // mask
92  );
93  gl.StencilMaskSeparate(face, stencil.write_mask);
94 }

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 92 of file render_pass_mtl.mm.

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

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 79 of file swapchain_impl_vk.cc.

80  {
81  return std::find(formats.begin(), formats.end(), format) != formats.end();
82 }

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 291 of file typographer_context_stb.cc.

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

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,
bool  supports_framebuffer_fetch 
)
static

Definition at line 31 of file render_pass_vk.cc.

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

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,
bool  supports_framebuffer_fetch 
)
constexpr

Definition at line 429 of file formats_vk.h.

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

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 48 of file allocator_vk.cc.

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

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,
bool  supports_framebuffer_fetch 
)
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 83 of file pipeline_library_vk.cc.

86  {
87  std::vector<vk::AttachmentDescription> attachments;
88 
89  std::vector<vk::AttachmentReference> color_refs;
90  std::vector<vk::AttachmentReference> subpass_color_ref;
91  vk::AttachmentReference depth_stencil_ref = kUnusedAttachmentReference;
92 
93  color_refs.resize(desc.GetMaxColorAttacmentBindIndex() + 1,
94  kUnusedAttachmentReference);
95 
96  const auto sample_count = desc.GetSampleCount();
97 
98  for (const auto& [bind_point, color] : desc.GetColorAttachmentDescriptors()) {
99  color_refs[bind_point] =
100  vk::AttachmentReference{static_cast<uint32_t>(attachments.size()),
101  vk::ImageLayout::eColorAttachmentOptimal};
102  attachments.emplace_back(
103  CreatePlaceholderAttachmentDescription(color.format, sample_count));
104  }
105  subpass_color_ref.push_back(vk::AttachmentReference{
106  static_cast<uint32_t>(0), vk::ImageLayout::eColorAttachmentOptimal});
107 
108  if (auto depth = desc.GetDepthStencilAttachmentDescriptor();
109  depth.has_value()) {
110  depth_stencil_ref = vk::AttachmentReference{
111  static_cast<uint32_t>(attachments.size()),
112  vk::ImageLayout::eDepthStencilAttachmentOptimal};
113  attachments.emplace_back(CreatePlaceholderAttachmentDescription(
114  desc.GetDepthPixelFormat(), sample_count));
115  }
116  if (desc.HasStencilAttachmentDescriptors()) {
117  depth_stencil_ref = vk::AttachmentReference{
118  static_cast<uint32_t>(attachments.size()),
119  vk::ImageLayout::eDepthStencilAttachmentOptimal};
120  attachments.emplace_back(CreatePlaceholderAttachmentDescription(
121  desc.GetStencilPixelFormat(), sample_count));
122  }
123 
124  vk::SubpassDescription subpass_desc;
125  subpass_desc.pipelineBindPoint = vk::PipelineBindPoint::eGraphics;
126 
127  // If the device supports framebuffer fetch, compatibility pipelines are
128  // always created with the self reference and rasterization order flag. This
129  // ensures that all compiled pipelines are compatible with a render pass that
130  // contains a framebuffer fetch shader (advanced blends).
131  std::vector<vk::SubpassDependency> subpass_dependencies;
132  if (supports_framebuffer_fetch) {
133  subpass_desc.setFlags(vk::SubpassDescriptionFlagBits::
134  eRasterizationOrderAttachmentColorAccessARM);
135  subpass_desc.setInputAttachments(subpass_color_ref);
136  }
137  subpass_desc.setColorAttachments(color_refs);
138  subpass_desc.setPDepthStencilAttachment(&depth_stencil_ref);
139 
140  vk::RenderPassCreateInfo render_pass_desc;
141  render_pass_desc.setAttachments(attachments);
142  render_pass_desc.setPSubpasses(&subpass_desc);
143  render_pass_desc.setSubpassCount(1u);
144  render_pass_desc.setDependencies(subpass_dependencies);
145 
146  auto [result, pass] = device.createRenderPassUnique(render_pass_desc);
147  if (result != vk::Result::eSuccess) {
148  VALIDATION_LOG << "Failed to create render pass for pipeline '"
149  << desc.GetLabel() << "'. Error: " << vk::to_string(result);
150  return {};
151  }
152 
153  // This pass is not used with the render pass. It is only necessary to tell
154  // Vulkan the expected render pass layout. The actual pass will be created
155  // later during render pass setup and will need to be compatible with this
156  // one.
157  ContextVK::SetDebugName(device, pass.get(),
158  "Compat Render Pass: " + desc.GetLabel());
159 
160  return std::move(pass);
161 }

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  .primitive_type = PrimitiveType::kTriangleStrip,
168  .color_attachment_pixel_format = default_color_format}
169  .ApplyToPipelineDescriptor(*desc);
170  return std::make_unique<PipelineT>(context, desc);
171 }

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

◆ CreateDepthStencilDescriptor()

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

Definition at line 94 of file pipeline_library_mtl.mm.

96  {
97  auto descriptor = ToMTLDepthStencilDescriptor(
98  desc.GetDepthStencilAttachmentDescriptor(), //
99  desc.GetFrontStencilAttachmentDescriptor(), //
100  desc.GetBackStencilAttachmentDescriptor() //
101  );
102  return [device newDepthStencilStateWithDescriptor:descriptor];
103 }

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 20 of file compute_tessellator.cc.

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

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 84 of file reactor_gles.cc.

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

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 99 of file allocation.cc.

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

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

◆ CreateMappingWithCopy()

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

Definition at line 83 of file allocation.cc.

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

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 111 of file allocation.cc.

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

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

◆ CreateMetalCommandQueue()

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

Definition at line 226 of file context_mtl.mm.

226  {
227  auto command_queue = device.newCommandQueue;
228  if (!command_queue) {
229  VALIDATION_LOG << "Could not set up the command queue.";
230  return nullptr;
231  }
232  command_queue.label = @"Impeller Command Queue";
233  return command_queue;
234 }

References VALIDATION_LOG.

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

◆ CreateMetalDevice()

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

Definition at line 222 of file context_mtl.mm.

222  {
223  return ::MTLCreateSystemDefaultDevice();
224 }

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 61 of file pipeline_library_vk.cc.

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

References CreateAttachmentDescription(), and kDontCare.

Referenced by CreateCompatRenderPassForPipeline().

◆ 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 250 of file entity_pass.cc.

253  {
254  auto context = renderer.GetContext();
255 
256  /// All of the load/store actions are managed by `InlinePassContext` when
257  /// `RenderPasses` are created, so we just set them to `kDontCare` here.
258  /// What's important is the `StorageMode` of the textures, which cannot be
259  /// changed for the lifetime of the textures.
260 
261  RenderTarget target;
262  if (context->GetCapabilities()->SupportsOffscreenMSAA()) {
263  target = RenderTarget::CreateOffscreenMSAA(
264  *context, // context
265  *renderer.GetRenderTargetCache(), // allocator
266  size, // size
267  "EntityPass", // label
268  RenderTarget::AttachmentConfigMSAA{
269  .storage_mode = StorageMode::kDeviceTransient,
270  .resolve_storage_mode = StorageMode::kDevicePrivate,
271  .load_action = LoadAction::kDontCare,
272  .store_action = StoreAction::kMultisampleResolve,
273  .clear_color = clear_color}, // color_attachment_config
274  GetDefaultStencilConfig(readable) // stencil_attachment_config
275  );
276  } else {
277  target = RenderTarget::CreateOffscreen(
278  *context, // context
279  *renderer.GetRenderTargetCache(), // allocator
280  size, // size
281  "EntityPass", // label
282  RenderTarget::AttachmentConfig{
283  .storage_mode = StorageMode::kDevicePrivate,
284  .load_action = LoadAction::kDontCare,
285  .store_action = StoreAction::kDontCare,
286  .clear_color = clear_color,
287  }, // color_attachment_config
288  GetDefaultStencilConfig(readable) // stencil_attachment_config
289  );
290  }
291 
292  return EntityPassTarget(
293  target, renderer.GetDeviceCapabilities().SupportsReadFromResolve(),
294  renderer.GetDeviceCapabilities().SupportsImplicitResolvingMSAA());
295 }

References impeller::RenderTarget::CreateOffscreen(), impeller::RenderTarget::CreateOffscreenMSAA(), impeller::ContentContext::GetContext(), GetDefaultStencilConfig(), impeller::ContentContext::GetDeviceCapabilities(), impeller::ContentContext::GetRenderTargetCache(), impeller::Capabilities::SupportsImplicitResolvingMSAA(), 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().

◆ CreateTextureFromDrawableFuture()

std::shared_ptr< TextureMTL > impeller::CreateTextureFromDrawableFuture ( TextureDescriptor  desc,
const std::shared_future< id< CAMetalDrawable >> &  drawble_future 
)

Create a TextureMTL from a deferred drawable. 

   This function is safe to call multiple times and will only call
   nextDrawable once.

Definition at line 41 of file lazy_drawable_holder.mm.

43  {
44  return std::make_shared<TextureMTL>(
45  desc, [drawble_future]() { return drawble_future.get().texture; },
46  /*wrapped=*/false, /*drawable=*/true);
47 }

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

◆ 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 62 of file buffer_bindings_gles.cc.

64  {
65  std::string result;
66  result.reserve(struct_name.length() + member.length() + (is_array ? 4 : 1));
67  result += struct_name;
68  if (!member.empty()) {
69  result += '.';
70  result += member;
71  }
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 253 of file path_component.cc.

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

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().

◆ DebugToFramebufferError()

std::string impeller::DebugToFramebufferError ( int  status)

Definition at line 9 of file formats_gles.cc.

9  {
10  switch (status) {
11  case GL_FRAMEBUFFER_UNDEFINED:
12  return "GL_FRAMEBUFFER_UNDEFINED";
13  case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
14  return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
15  case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
16  return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
17  case GL_FRAMEBUFFER_UNSUPPORTED:
18  return "GL_FRAMEBUFFER_UNSUPPORTED";
19  case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
20  return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
21  default:
22  return "Unknown error code: " + std::to_string(status);
23  }
24 }

Referenced by EncodeCommandsInReactor().

◆ 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 74 of file comparable.h.

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

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 57 of file comparable.h.

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

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

◆ DefaultUniformAlignment()

constexpr size_t impeller::DefaultUniformAlignment ( )
constexpr

Definition at line 15 of file platform.h.

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

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 233 of file proc_table_gles.cc.

234  {
235  GLint param = GL_NONE;
236  gl.GetFramebufferAttachmentParameteriv(
237  GL_FRAMEBUFFER, // target
238  attachment, // attachment
239  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, // parameter name
240  &param // parameter
241  );
242 
243  if (param != GL_NONE) {
244  param = GL_NONE;
245  gl.GetFramebufferAttachmentParameteriv(
246  GL_FRAMEBUFFER, // target
247  attachment, // attachment
248  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, // parameter name
249  &param // parameter
250  );
251  std::stringstream stream;
252  stream << AttachmentTypeString(param) << "(" << param << ")";
253  return stream.str();
254  }
255 
256  return "No Attachment";
257 }

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 221 of file tessellator.cc.

221  {
222  if (tessellator != nullptr) {
223  ::tessDeleteTess(tessellator);
224  }
225 }

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

◆ DestroyVertices()

IMPELLER_API void impeller::DestroyVertices ( Vertices *  vertices)

Definition at line 74 of file tessellator.cc.

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

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 43 of file context_mtl.mm.

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

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 23 of file context_mtl.mm.

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

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 = bitmap->GetPixelAddress({static_cast<size_t>(location.GetX()),
218  static_cast<size_t>(location.GetY())});
219  // For Alpha and Signed Distance field bitmaps we can use STB to draw the
220  // Glyph in place
221  if (!has_color || DISABLE_COLOR_FONT_SUPPORT) {
222  stbtt_MakeGlyphBitmap(typeface_stb->GetFontInfo(), output,
223  location.GetWidth() - kPadding,
224  location.GetHeight() - kPadding,
225  bitmap->GetRowBytes(), scale_x, scale_y, glyph.index);
226  } else {
227  // But for color bitmaps we need to get the glyph pixels and then carry all
228  // channels into the atlas bitmap. This may not be performant but I'm unsure
229  // of any other approach currently.
230  int glyph_bitmap_width = 0;
231  int glyph_bitmap_height = 0;
232  int glyph_bitmap_xoff = 0;
233  int glyph_bitmap_yoff = 0;
234  auto glyph_pixels = stbtt_GetGlyphBitmap(
235  typeface_stb->GetFontInfo(), scale_x, scale_y, glyph.index,
236  &glyph_bitmap_width, &glyph_bitmap_height, &glyph_bitmap_xoff,
237  &glyph_bitmap_yoff);
238 
239  uint8_t* write_pos = output;
240  for (auto y = 0; y < glyph_bitmap_height; ++y) {
241  for (auto x = 0; x < glyph_bitmap_width; ++x) {
242  // Color bitmaps write as White (i.e. what is 0 in an alpha bitmap is
243  // 255 in a color bitmap) But not alpha. Alpha still carries
244  // transparency info in the normal way.
245  // There's some issue with color fonts, in that if the pixel color is
246  // nonzero, the alpha is ignored during rendering. That is, partially
247  // (or fully) transparent pixels with nonzero color are rendered as
248  // fully opaque.
249  uint8_t a = glyph_pixels[x + y * glyph_bitmap_width];
250  uint8_t c = 255 - a;
251 
252  // Red channel
253  *write_pos = c;
254  write_pos++;
255  // Green channel
256  *write_pos = c;
257  write_pos++;
258  // Blue channel
259  *write_pos = c;
260  write_pos++;
261  // Alpha channel
262  *write_pos = a;
263  write_pos++;
264  }
265  // next row
266  write_pos = output + (y * bitmap->GetRowBytes());
267  }
268  stbtt_FreeBitmap(glyph_pixels, nullptr);
269  }
270 }

References DISABLE_COLOR_FONT_SUPPORT, impeller::ScaledFont::font, impeller::TRect< T >::GetHeight(), impeller::Font::GetMetrics(), impeller::BitmapSTB::GetPixelAddress(), impeller::BitmapSTB::GetRowBytes(), impeller::Font::GetTypeface(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::Glyph::index, kPadding, and impeller::TypefaceSTB::kPointsToPixels.

◆ 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.GetX() / scaled_font.scale,
162  location.GetY() / 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::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::Glyph::index, and impeller::ScaledFont::scale.

Referenced by CreateAtlasBitmap(), and UpdateAtlasBitmap().

◆ EmptyFeedback()

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

Definition at line 173 of file pipeline_library_vk.cc.

173  {
174  vk::PipelineCreationFeedbackEXT feedback;
175  // If the VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT is not set in flags, an
176  // implementation must not set any other bits in flags, and the values of all
177  // other VkPipelineCreationFeedback data members are undefined.
178  feedback.flags = vk::PipelineCreationFeedbackFlagBits::eValid;
179  return feedback;
180 }

◆ EncodeCommand()

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

Definition at line 367 of file render_pass_vk.cc.

372  {
373 #ifdef IMPELLER_DEBUG
374  fml::ScopedCleanupClosure pop_marker(
375  [&encoder]() { encoder.PopDebugGroup(); });
376  if (!command.label.empty()) {
377  encoder.PushDebugGroup(command.label.c_str());
378  } else {
379  pop_marker.Release();
380  }
381 #endif // IMPELLER_DEBUG
382 
383  const auto& cmd_buffer = encoder.GetCommandBuffer();
384  const auto& pipeline_vk = PipelineVK::Cast(*command.pipeline);
385 
386  encoder.GetCommandBuffer().bindDescriptorSets(
387  vk::PipelineBindPoint::eGraphics, // bind point
388  pipeline_vk.GetPipelineLayout(), // layout
389  0, // first set
390  {vk::DescriptorSet{vk_desc_set}}, // sets
391  nullptr // offsets
392  );
393 
394  command_buffer_cache.BindPipeline(
395  cmd_buffer, vk::PipelineBindPoint::eGraphics, pipeline_vk.GetPipeline());
396 
397  // Set the viewport and scissors.
398  SetViewportAndScissor(command, cmd_buffer, command_buffer_cache, target_size);
399 
400  // Set the stencil reference.
401  command_buffer_cache.SetStencilReference(
402  cmd_buffer, vk::StencilFaceFlagBits::eVkStencilFrontAndBack,
403  command.stencil_reference);
404 
405  // Configure vertex and index and buffers for binding.
406  auto& vertex_buffer_view = command.vertex_buffer.vertex_buffer;
407 
408  if (!vertex_buffer_view) {
409  return false;
410  }
411 
412  auto& allocator = *context.GetResourceAllocator();
413  auto vertex_buffer = vertex_buffer_view.buffer->GetDeviceBuffer(allocator);
414 
415  if (!vertex_buffer) {
416  VALIDATION_LOG << "Failed to acquire device buffer"
417  << " for vertex buffer view";
418  return false;
419  }
420 
421  if (!encoder.Track(vertex_buffer)) {
422  return false;
423  }
424 
425  // Bind the vertex buffer.
426  auto vertex_buffer_handle = DeviceBufferVK::Cast(*vertex_buffer).GetBuffer();
427  vk::Buffer vertex_buffers[] = {vertex_buffer_handle};
428  vk::DeviceSize vertex_buffer_offsets[] = {vertex_buffer_view.range.offset};
429  cmd_buffer.bindVertexBuffers(0u, 1u, vertex_buffers, vertex_buffer_offsets);
430 
431  if (command.vertex_buffer.index_type != IndexType::kNone) {
432  // Bind the index buffer.
433  auto index_buffer_view = command.vertex_buffer.index_buffer;
434  if (!index_buffer_view) {
435  return false;
436  }
437 
438  auto index_buffer = index_buffer_view.buffer->GetDeviceBuffer(allocator);
439  if (!index_buffer) {
440  VALIDATION_LOG << "Failed to acquire device buffer"
441  << " for index buffer view";
442  return false;
443  }
444 
445  if (!encoder.Track(index_buffer)) {
446  return false;
447  }
448 
449  auto index_buffer_handle = DeviceBufferVK::Cast(*index_buffer).GetBuffer();
450  cmd_buffer.bindIndexBuffer(index_buffer_handle,
451  index_buffer_view.range.offset,
452  ToVKIndexType(command.vertex_buffer.index_type));
453 
454  // Engage!
455  cmd_buffer.drawIndexed(command.vertex_buffer.vertex_count, // index count
456  command.instance_count, // instance count
457  0u, // first index
458  command.base_vertex, // vertex offset
459  0u // first instance
460  );
461  } else {
462  cmd_buffer.draw(command.vertex_buffer.vertex_count, // vertex count
463  command.instance_count, // instance count
464  command.base_vertex, // vertex offset
465  0u // first instance
466  );
467  }
468  return true;
469 }

References impeller::CommandEncoderVK::GetCommandBuffer(), impeller::Command::pipeline, impeller::CommandEncoderVK::PopDebugGroup(), and impeller::CommandEncoderVK::PushDebugGroup().

◆ 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,
const std::shared_ptr< GPUTracerGLES > &  tracer 
)

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 146 of file render_pass_gles.cc.

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

References impeller::Color::alpha, impeller::Color::blue, CanClearAttachment(), CanDiscardAttachmentWhenDone(), impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::BackendCast< DeviceBufferGLES, DeviceBuffer >::Cast(), impeller::BackendCast< PipelineGLES, Pipeline< PipelineDescriptor > >::Cast(), impeller::BackendCast< ContextGLES, Context >::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(), DebugToFramebufferError(), impeller::RenderPassData::depth_attachment, impeller::RenderPassData::discard_color_attachment, impeller::RenderPassData::discard_depth_attachment, impeller::RenderPassData::discard_stencil_attachment, impeller::Context::GetCapabilities(), impeller::ContextGLES::GetGPUTracer(), 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 34 of file blit_pass_gles.cc.

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

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 44 of file compute_playground_test.cc.

44  {
45  std::stringstream stream;
46  stream << "Impeller Playground for '" << test_name << "' (Press ESC to quit)";
47  return stream.str();
48 }

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 59 of file playground_test.cc.

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

◆ FramebufferStatusToString()

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

Definition at line 199 of file proc_table_gles.cc.

199  {
200  switch (status) {
201  case GL_FRAMEBUFFER_COMPLETE:
202  return "GL_FRAMEBUFFER_COMPLETE";
203  case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
204  return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
205 #if GL_ES_VERSION_2_0
206  case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
207  return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
208 #endif
209  case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
210  return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
211  case GL_FRAMEBUFFER_UNSUPPORTED:
212  return "GL_FRAMEBUFFER_UNSUPPORTED";
213  case GL_INVALID_ENUM:
214  return "GL_INVALID_ENUM";
215  }
216 
217  return "Unknown FBO Error Status";
218 }

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 292 of file formats_mtl.h.

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

References kClear, kDontCare, and kLoad.

◆ FromMTLPixelFormat()

constexpr PixelFormat impeller::FromMTLPixelFormat ( MTLPixelFormat  format)
constexpr

Definition at line 23 of file formats_mtl.h.

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

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 321 of file formats_mtl.h.

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

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().

◆ GenerateBlurInfo()

KernelPipeline::FragmentShader::KernelSamples impeller::GenerateBlurInfo ( BlurParameters  parameters)

Definition at line 435 of file gaussian_blur_filter_contents.cc.

436  {
437  KernelPipeline::FragmentShader::KernelSamples result;
438  result.sample_count =
439  ((2 * parameters.blur_radius) / parameters.step_size) + 1;
440  FML_CHECK(result.sample_count < 24);
441 
442  Scalar tally = 0.0f;
443  for (int i = 0; i < result.sample_count; ++i) {
444  int x = (i * parameters.step_size) - parameters.blur_radius;
445  result.samples[i] = KernelPipeline::FragmentShader::KernelSample{
446  .uv_offset = parameters.blur_uv_offset * x,
447  .coefficient = expf(-0.5f * (x * x) /
448  (parameters.blur_sigma * parameters.blur_sigma)) /
449  (sqrtf(2.0f * M_PI) * parameters.blur_sigma),
450  };
451  tally += result.samples[i].coefficient;
452  }
453 
454  // Make sure everything adds up to 1.
455  for (auto& sample : result.samples) {
456  sample.coefficient /= tally;
457  }
458 
459  return result;
460 }

References impeller::BlurParameters::blur_radius, impeller::BlurParameters::blur_sigma, impeller::BlurParameters::blur_uv_offset, and impeller::BlurParameters::step_size.

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

◆ 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 241 of file entity_pass.cc.

241  {
242  return RenderTarget::AttachmentConfig{
243  .storage_mode = readable ? StorageMode::kDevicePrivate
244  : StorageMode::kDeviceTransient,
245  .load_action = LoadAction::kDontCare,
246  .store_action = StoreAction::kDontCare,
247  };
248 }

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

156  {
157  switch (ext) {
158  case OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback:
159  return VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME;
160  case OptionalDeviceExtensionVK::kARMRasterizationOrderAttachmentAccess:
161  return VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME;
162  case OptionalDeviceExtensionVK::kEXTRasterizationOrderAttachmentAccess:
163  return VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME;
164  case OptionalDeviceExtensionVK::kLast:
165  return "Unknown";
166  }
167  return "Unknown";
168 }

References kARMRasterizationOrderAttachmentAccess, kEXTPipelineCreationFeedback, kEXTRasterizationOrderAttachmentAccess, and kLast.

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

◆ GetDrawableDeferred()

std::shared_future< id< CAMetalDrawable > > impeller::GetDrawableDeferred ( CAMetalLayer *  layer)

Create a deferred drawable from a CAMetalLayer.

Definition at line 23 of file lazy_drawable_holder.mm.

24  {
25  auto future =
26  std::async(std::launch::deferred, [layer]() -> id<CAMetalDrawable> {
27  id<CAMetalDrawable> current_drawable = nil;
28  {
29  TRACE_EVENT0("impeller", "WaitForNextDrawable");
30  current_drawable = [layer nextDrawable];
31  }
32  if (!current_drawable) {
33  VALIDATION_LOG << "Could not acquire current drawable.";
34  return nullptr;
35  }
36  return current_drawable;
37  });
38  return std::shared_future<id<CAMetalDrawable>>(std::move(future));
39 }

References VALIDATION_LOG.

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

◆ GetFencesForWaitSet()

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

Definition at line 82 of file fence_waiter_vk.cc.

82  {
83  std::vector<vk::Fence> fences;
84  for (const auto& entry : set) {
85  if (!entry->IsSignalled()) {
86  fences.emplace_back(entry->GetFence());
87  }
88  }
89  return fences;
90 }

◆ 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 84 of file pipeline_library_mtl.mm.

85  {
86  auto descriptor = [[MTLComputePipelineDescriptor alloc] init];
87  descriptor.label = @(desc.GetLabel().c_str());
88  descriptor.computeFunction =
89  ShaderFunctionMTL::Cast(*desc.GetStageEntrypoint()).GetMTLFunction();
90  return descriptor;
91 }

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

◆ GetMTLRenderPipelineDescriptor()

static void impeller::GetMTLRenderPipelineDescriptor ( const PipelineDescriptor &  desc,
const Callback &  callback 
)
static

Definition at line 28 of file pipeline_library_mtl.mm.

29  {
30  auto descriptor = [[MTLRenderPipelineDescriptor alloc] init];
31  descriptor.label = @(desc.GetLabel().c_str());
32  descriptor.rasterSampleCount = static_cast<NSUInteger>(desc.GetSampleCount());
33  bool created_specialized_function = false;
34 
35  if (const auto& vertex_descriptor = desc.GetVertexDescriptor()) {
36  VertexDescriptorMTL vertex_descriptor_mtl;
37  if (vertex_descriptor_mtl.SetStageInputsAndLayout(
38  vertex_descriptor->GetStageInputs(),
39  vertex_descriptor->GetStageLayouts())) {
40  descriptor.vertexDescriptor =
41  vertex_descriptor_mtl.GetMTLVertexDescriptor();
42  }
43  }
44 
45  for (const auto& item : desc.GetColorAttachmentDescriptors()) {
46  descriptor.colorAttachments[item.first] =
47  ToMTLRenderPipelineColorAttachmentDescriptor(item.second);
48  }
49 
50  descriptor.depthAttachmentPixelFormat =
51  ToMTLPixelFormat(desc.GetDepthPixelFormat());
52  descriptor.stencilAttachmentPixelFormat =
53  ToMTLPixelFormat(desc.GetStencilPixelFormat());
54 
55  const auto& constants = desc.GetSpecializationConstants();
56  for (const auto& entry : desc.GetStageEntrypoints()) {
57  if (entry.first == ShaderStage::kVertex) {
58  descriptor.vertexFunction =
59  ShaderFunctionMTL::Cast(*entry.second).GetMTLFunction();
60  }
61  if (entry.first == ShaderStage::kFragment) {
62  if (constants.empty()) {
63  descriptor.fragmentFunction =
64  ShaderFunctionMTL::Cast(*entry.second).GetMTLFunction();
65  } else {
66  // This code only expects a single specialized function per pipeline.
67  FML_CHECK(!created_specialized_function);
68  created_specialized_function = true;
69  ShaderFunctionMTL::Cast(*entry.second)
70  .GetMTLFunctionSpecialized(
71  constants, [callback, descriptor](id<MTLFunction> function) {
72  descriptor.fragmentFunction = function;
73  callback(descriptor);
74  });
75  }
76  }
77  }
78 
79  if (!created_specialized_function) {
80  callback(descriptor);
81  }
82 }

References impeller::BackendCast< ShaderFunctionMTL, ShaderFunction >::Cast(), impeller::PipelineDescriptor::GetColorAttachmentDescriptors(), impeller::PipelineDescriptor::GetDepthPixelFormat(), impeller::PipelineDescriptor::GetLabel(), impeller::ShaderFunctionMTL::GetMTLFunction(), impeller::ShaderFunctionMTL::GetMTLFunctionSpecialized(), impeller::VertexDescriptorMTL::GetMTLVertexDescriptor(), impeller::PipelineDescriptor::GetSampleCount(), impeller::PipelineDescriptor::GetSpecializationConstants(), 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 58 of file context_vk.cc.

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

◆ GetShaderInfoLog()

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

Definition at line 22 of file pipeline_library_gles.cc.

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

Referenced by LogShaderCompilationFailure().

◆ GetShaderSource()

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

Definition at line 36 of file pipeline_library_gles.cc.

36  {
37  // Arbitrarily chosen size that should be larger than most shaders.
38  // Since this only fires on compilation errors the performance shouldn't
39  // matter.
40  auto data = static_cast<char*>(malloc(10240));
41  GLsizei length;
42  gl.GetShaderSource(shader, 10240, &length, data);
43 
44  auto result = std::string{data, static_cast<size_t>(length)};
45  free(data);
46  return result;
47 }

Referenced by LogShaderCompilationFailure().

◆ GetShaderType()

static ShaderType impeller::GetShaderType ( RuntimeUniformType  type)
static

Definition at line 44 of file runtime_effect_contents.cc.

44  {
45  switch (type) {
46  case kSampledImage:
47  return ShaderType::kSampledImage;
48  case kFloat:
49  return ShaderType::kFloat;
50  case kBoolean:
51  case kSignedByte:
52  case kUnsignedByte:
53  case kSignedShort:
54  case kUnsignedShort:
55  case kSignedInt:
56  case kUnsignedInt:
57  case kSignedInt64:
58  case kUnsignedInt64:
59  case kHalfFloat:
60  case kDouble:
61  VALIDATION_LOG << "Unsupported uniform type.";
62  return ShaderType::kVoid;
63  }
64 }

References kBoolean, kDouble, kFloat, kHalfFloat, kSampledImage, kSignedByte, kSignedInt, kSignedInt64, kSignedShort, kUnsignedByte, kUnsignedInt, kUnsignedInt64, kUnsignedShort, kVoid, and VALIDATION_LOG.

Referenced by MakeShaderMetadata().

◆ GetSupportedDeviceExtensions()

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

Definition at line 181 of file capabilities_vk.cc.

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

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

◆ GetTextureTypeFromDescriptor()

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

Definition at line 20 of file texture_gles.cc.

21  {
22  const auto usage = static_cast<TextureUsageMask>(desc.usage);
23  const auto render_target =
24  static_cast<TextureUsageMask>(TextureUsage::kRenderTarget);
25  const auto is_msaa = desc.sample_count == SampleCount::kCount4;
26  if (usage == render_target && desc.format == PixelFormat::kS8UInt) {
27  return is_msaa ? TextureGLES::Type::kRenderBufferMultisampled
28  : TextureGLES::Type::kRenderBuffer;
29  }
30  return is_msaa ? TextureGLES::Type::kTextureMultisampled
31  : TextureGLES::Type::kTexture;
32 }

References impeller::TextureDescriptor::format, kCount4, impeller::TextureGLES::kRenderBuffer, impeller::TextureGLES::kRenderBufferMultisampled, kRenderTarget, kS8UInt, impeller::TextureGLES::kTexture, impeller::TextureGLES::kTextureMultisampled, impeller::TextureDescriptor::sample_count, and impeller::TextureDescriptor::usage.

◆ GetVKClearValues()

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

Definition at line 231 of file render_pass_vk.cc.

232  {
233  std::vector<vk::ClearValue> clears;
234 
235  for (const auto& [_, color] : target.GetColorAttachments()) {
236  clears.emplace_back(VKClearValueFromColor(color.clear_color));
237  if (color.resolve_texture) {
238  clears.emplace_back(VKClearValueFromColor(color.clear_color));
239  }
240  }
241 
242  const auto& depth = target.GetDepthAttachment();
243  const auto& stencil = target.GetStencilAttachment();
244 
245  if (depth.has_value()) {
246  clears.emplace_back(VKClearValueFromDepthStencil(
247  stencil ? stencil->clear_stencil : 0u, depth->clear_depth));
248  }
249 
250  if (stencil.has_value()) {
251  clears.emplace_back(VKClearValueFromDepthStencil(
252  stencil->clear_stencil, depth ? depth->clear_depth : 0.0f));
253  }
254 
255  return clears;
256 }

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

◆ GLErrorIsFatal()

bool impeller::GLErrorIsFatal ( GLenum  value)

Definition at line 38 of file proc_table_gles.cc.

38  {
39  switch (value) {
40  case GL_NO_ERROR:
41  return false;
42  case GL_INVALID_ENUM:
43  case GL_INVALID_VALUE:
44  case GL_INVALID_OPERATION:
45  case GL_INVALID_FRAMEBUFFER_OPERATION:
46  case GL_OUT_OF_MEMORY:
47  return true;
48  }
49  return false;
50 }

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

◆ GLErrorToString()

const char * impeller::GLErrorToString ( GLenum  value)

Definition at line 18 of file proc_table_gles.cc.

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

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

◆ GLESShaderNameToShaderKeyName()

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

Definition at line 30 of file shader_library_gles.cc.

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

References kCompute, kFragment, 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 267 of file capabilities_vk.cc.

267  {
268  auto properties = physical_device.getProperties();
269  if (!(properties.limits.framebufferColorSampleCounts &
270  (vk::SampleCountFlagBits::e1 | vk::SampleCountFlagBits::e4))) {
271  return false;
272  }
273  return true;
274 }

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

◆ HasRequiredQueues()

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

Definition at line 276 of file capabilities_vk.cc.

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

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

242  {
243  const auto props = device.getFormatProperties(format);
244  // This needs to be more comprehensive.
245  return !!(props.optimalTilingFeatures &
246  vk::FormatFeatureFlagBits::eColorAttachment);
247 }

Referenced by PhysicalDeviceSupportsRequiredFormats().

◆ HasSuitableDepthStencilFormat()

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

Definition at line 249 of file capabilities_vk.cc.

250  {
251  const auto props = device.getFormatProperties(format);
252  return !!(props.optimalTilingFeatures &
253  vk::FormatFeatureFlagBits::eDepthStencilAttachment);
254 }

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

◆ HasValidationLayers()

bool impeller::HasValidationLayers ( )

Definition at line 43 of file context_vk.cc.

43  {
44  return gHasValidationLayers;
45 }

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 30 of file config.h.

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

◆ 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_ENABLE_VALIDATION
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 54 of file context_mtl.mm.

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

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::SetSupportsReadFromResolve(), impeller::CapabilitiesBuilder::SetSupportsSSBO(), and impeller::CapabilitiesBuilder::SetSupportsTextureToTextureBlits().

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

◆ InferShaderTypefromFileExtension()

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

Definition at line 19 of file shader_archive_writer.cc.

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

References kCompute, kFragment, and kVertex.

Referenced by impeller::ShaderArchiveWriter::AddShaderAtPath().

◆ 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 217 of file blit_command_vk.cc.

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

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

◆ InvertPorterDuffBlend()

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

Definition at line 26 of file blend_filter_contents.cc.

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

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 24 of file thread.h.

24  {
25  public:
26  Mutex() = default;
27 
28  ~Mutex() = default;
29 
30  void Lock() IPLR_ACQUIRE() { mutex_.lock(); }
31 
32  void Unlock() IPLR_RELEASE() { mutex_.unlock(); }
33 
34  private:
35  friend class ConditionVariable;
36 
37  std::mutex mutex_;
38 
39  Mutex(const Mutex&) = delete;
40 
41  Mutex(Mutex&&) = delete;
42 
43  Mutex& operator=(const Mutex&) = delete;
44 
45  Mutex& operator=(Mutex&&) = delete;
46 };

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

◆ IsDepthWritable()

constexpr bool impeller::IsDepthWritable ( PixelFormat  format)
constexpr

Definition at line 114 of file formats.h.

114  {
115  switch (format) {
116  case PixelFormat::kD24UnormS8Uint:
117  case PixelFormat::kD32FloatS8UInt:
118  return true;
119  default:
120  return false;
121  }
122 }

References kD24UnormS8Uint, and kD32FloatS8UInt.

◆ IsMappingSPIRV()

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

Definition at line 116 of file shader_library_vk.cc.

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

◆ IsMultisampleCapable()

constexpr bool impeller::IsMultisampleCapable ( TextureType  type)
constexpr

Definition at line 278 of file formats.h.

278  {
279  switch (type) {
280  case TextureType::kTexture2D:
281  case TextureType::kTextureCube:
282  case TextureType::kTextureExternalOES:
283  return false;
284  case TextureType::kTexture2DMultisample:
285  return true;
286  }
287  return false;
288 }

References kTexture2D, kTexture2DMultisample, kTextureCube, and kTextureExternalOES.

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

◆ IsStencilWritable()

constexpr bool impeller::IsStencilWritable ( PixelFormat  format)
constexpr

Definition at line 124 of file formats.h.

124  {
125  switch (format) {
126  case PixelFormat::kS8UInt:
127  case PixelFormat::kD24UnormS8Uint:
128  case PixelFormat::kD32FloatS8UInt:
129  return true;
130  default:
131  return false;
132  }
133 }

References kD24UnormS8Uint, kD32FloatS8UInt, and kS8UInt.

◆ IterateOptionalDeviceExtensions()

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

Definition at line 170 of file capabilities_vk.cc.

171  {
172  if (!it) {
173  return;
174  }
175  for (size_t i = 0;
176  i < static_cast<uint32_t>(OptionalDeviceExtensionVK::kLast); i++) {
177  it(static_cast<OptionalDeviceExtensionVK>(i));
178  }
179 }

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 77 of file pipeline_library_gles.cc.

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

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 210 of file formats.h.

210  {
211  switch (action) {
212  case LoadAction::kDontCare:
213  return "DontCare";
214  case LoadAction::kLoad:
215  return "Load";
216  case LoadAction::kClear:
217  return "Clear";
218  }
219 }

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 49 of file pipeline_library_gles.cc.

53  {
54  std::stringstream stream;
55  stream << "Failed to compile ";
56  switch (stage) {
57  case ShaderStage::kUnknown:
58  stream << "unknown";
59  break;
60  case ShaderStage::kVertex:
61  stream << "vertex";
62  break;
63  case ShaderStage::kFragment:
64  stream << "fragment";
65  break;
66  case ShaderStage::kCompute:
67  stream << "compute";
68  break;
69  }
70  stream << " shader for '" << name << "' with error:" << std::endl;
71  stream << GetShaderInfoLog(gl, shader) << std::endl;
72  stream << "Shader source was: " << std::endl;
73  stream << GetShaderSource(gl, shader) << std::endl;
74  VALIDATION_LOG << stream.str();
75 }

References GetShaderInfoLog(), GetShaderSource(), kCompute, kFragment, 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 shader_archive_main.cc.

13  {
14  ShaderArchiveWriter 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.AddShaderAtPath(std::string{input})) {
24  std::cerr << "Could not add shader at path: " << input << std::endl;
25  return false;
26  }
27  }
28 
29  auto archive = writer.CreateMapping();
30  if (!archive) {
31  std::cerr << "Could not create shader archive." << 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  *archive)) {
42  std::cerr << "Could not write shader archive to path " << output
43  << std::endl;
44  return false;
45  }
46 
47  return true;
48 }

References impeller::ShaderArchiveWriter::AddShaderAtPath(), and impeller::ShaderArchiveWriter::CreateMapping().

Referenced by main().

◆ MakeShaderMetadata()

static std::shared_ptr<ShaderMetadata> impeller::MakeShaderMetadata ( const RuntimeUniformDescription &  uniform)
static

Definition at line 66 of file runtime_effect_contents.cc.

67  {
68  auto metadata = std::make_shared<ShaderMetadata>();
69  metadata->name = uniform.name;
70  metadata->members.emplace_back(ShaderStructMemberMetadata{
71  .type = GetShaderType(uniform.type),
72  .size = uniform.GetSize(),
73  .byte_length = uniform.bit_width / 8,
74  });
75 
76  return metadata;
77 }

References impeller::RuntimeUniformDescription::bit_width, GetShaderType(), impeller::RuntimeUniformDescription::GetSize(), impeller::RuntimeUniformDescription::name, impeller::RuntimeUniformDescription::type, and impeller::ShaderStructMemberMetadata::type.

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

◆ MakeSharedVK()

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

Definition at line 43 of file shared_object_vk.h.

44  {
45  if (!handle) {
46  return std::shared_ptr<SharedObjectVKT<T>>{nullptr};
47  }
48  return std::make_shared<SharedObjectVKT<T>>(std::move(handle));
49 }

◆ 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 = Rect::MakeOriginSize(
59  glyph_position.position + glyph_position.glyph.bounds.GetOrigin(),
60  glyph_position.glyph.bounds.GetSize());
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 >::MakeOriginSize(), 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 179 of file context_mtl.mm.

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

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 156 of file context_mtl.mm.

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

References VALIDATION_LOG.

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

◆ NearEqual()

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

Definition at line 245 of file path_component.cc.

245  {
246  return (a > (b - epsilon)) && (a < (b + epsilon));
247 }

Referenced by NearZero().

◆ NearZero()

static bool impeller::NearZero ( Scalar  a)
inlinestatic

Definition at line 249 of file path_component.cc.

249  {
250  return NearEqual(a, 0.0, 1e-12);
251 }

References NearEqual().

Referenced by CubicPathBoundingPopulateValues().

◆ NormalizeUniformKey()

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

Definition at line 51 of file buffer_bindings_gles.cc.

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

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().

◆ 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 255 of file point.h.

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

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 260 of file point.h.

260  {
261  return p2 * p1;
262 }

◆ 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 299 of file point.h.

299  {
300  return p * s;
301 }

◆ 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 901 of file color.h.

901  {
902  return c * static_cast<Scalar>(value);
903 }

◆ 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 277 of file point.h.

277  {
278  return p * s;
279 }

◆ 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 128 of file size.h.

128  {
129  return p * s;
130 }

◆ 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 209 of file vector.h.

209  {
210  return p * s;
211 }

◆ 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 235 of file point.h.

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

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 240 of file point.h.

240  {
241  return p2 + p1;
242 }

◆ 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 289 of file point.h.

289  {
290  return p + s;
291 }

◆ 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 890 of file color.h.

890  {
891  return c + static_cast<Scalar>(value);
892 }

◆ 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 214 of file vector.h.

214  {
215  return p + s;
216 }

◆ 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 245 of file point.h.

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

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 250 of file point.h.

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

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 294 of file point.h.

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

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 895 of file color.h.

895  {
896  auto v = static_cast<Scalar>(value);
897  return {v - c.red, v - c.green, v - c.blue, v - c.alpha};
898 }

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 219 of file vector.h.

219  {
220  return -p + s;
221 }

◆ 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 265 of file point.h.

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

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 270 of file point.h.

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

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 304 of file point.h.

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

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 906 of file color.h.

906  {
907  auto v = static_cast<Scalar>(value);
908  return {v / c.red, v / c.green, v / c.blue, v / c.alpha};
909 }

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 282 of file point.h.

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

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 133 of file size.h.

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

◆ 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 224 of file vector.h.

224  {
225  return {
226  static_cast<Scalar>(s) / p.x,
227  static_cast<Scalar>(s) / p.y,
228  static_cast<Scalar>(s) / p.z,
229  };
230 }

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.GetSampleCount();
23  opts.color_attachment_pixel_format = pass.GetRenderTargetPixelFormat();
24  opts.has_stencil_attachment = pass.HasStencilAttachment();
25  return opts;
26 }

References impeller::ContentContextOptions::color_attachment_pixel_format, impeller::RenderPass::GetRenderTargetPixelFormat(), impeller::RenderPass::GetSampleCount(), impeller::ContentContextOptions::has_stencil_attachment, impeller::RenderPass::HasStencilAttachment(), 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 28 of file contents.cc.

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

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.GetSize() * 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 256 of file capabilities_vk.cc.

257  {
258  const auto has_color_format =
259  HasSuitableColorFormat(device, vk::Format::eB8G8R8A8Unorm);
260  const auto has_stencil_format =
261  HasSuitableDepthStencilFormat(device, vk::Format::eS8Uint) ||
262  HasSuitableDepthStencilFormat(device, vk::Format::eD32SfloatS8Uint) ||
263  HasSuitableDepthStencilFormat(device, vk::Format::eD24UnormS8Uint);
264  return has_color_format && has_stencil_format;
265 }

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 47 of file context_vk.cc.

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

References impeller::CapabilitiesVK::GetEnabledDeviceFeatures().

◆ PickQueue()

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

Definition at line 81 of file context_vk.cc.

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

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 518 of file blend_filter_contents.cc.

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

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::GetClipDepth(), impeller::Entity::GetContents(), impeller::ContentContext::GetContext(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::Intersection(), kSource, kTriangleStrip, impeller::ColorFilterContents::kYes, impeller::Geometry::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::ContentContext::MakeSubpass(), impeller::Matrix::MakeTranslation(), OptionsFromPass(), impeller::Command::pipeline, impeller::Entity::Render(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), SPrintF(), and impeller::Snapshot::texture.

◆ PixelFormatIsDepthStencil()

constexpr bool impeller::PixelFormatIsDepthStencil ( PixelFormat  format)
constexpr

Definition at line 373 of file formats_vk.h.

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

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 135 of file formats.h.

135  {
136  switch (format) {
137  case PixelFormat::kUnknown:
138  return "Unknown";
139  case PixelFormat::kA8UNormInt:
140  return "A8UNormInt";
141  case PixelFormat::kR8UNormInt:
142  return "R8UNormInt";
143  case PixelFormat::kR8G8UNormInt:
144  return "R8G8UNormInt";
145  case PixelFormat::kR8G8B8A8UNormInt:
146  return "R8G8B8A8UNormInt";
147  case PixelFormat::kR8G8B8A8UNormIntSRGB:
148  return "R8G8B8A8UNormIntSRGB";
149  case PixelFormat::kB8G8R8A8UNormInt:
150  return "B8G8R8A8UNormInt";
151  case PixelFormat::kB8G8R8A8UNormIntSRGB:
152  return "B8G8R8A8UNormIntSRGB";
153  case PixelFormat::kR32G32B32A32Float:
154  return "R32G32B32A32Float";
155  case PixelFormat::kR16G16B16A16Float:
156  return "R16G16B16A16Float";
157  case PixelFormat::kB10G10R10XR:
158  return "B10G10R10XR";
159  case PixelFormat::kB10G10R10XRSRGB:
160  return "B10G10R10XRSRGB";
161  case PixelFormat::kB10G10R10A10XR:
162  return "B10G10R10A10XR";
163  case PixelFormat::kS8UInt:
164  return "S8UInt";
165  case PixelFormat::kD24UnormS8Uint:
166  return "D24UnormS8Uint";
167  case PixelFormat::kD32FloatS8UInt:
168  return "D32FloatS8UInt";
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::BlitPass::AddCopy(), and TextureDescriptorToString().

◆ PlaygroundBackendToRuntimeStageBackend()

constexpr RuntimeStageBackend impeller::PlaygroundBackendToRuntimeStageBackend ( PlaygroundBackend  backend)
inlineconstexpr

Definition at line 35 of file playground.h.

36  {
37  switch (backend) {
38  case PlaygroundBackend::kMetal:
39  return RuntimeStageBackend::kMetal;
40  case PlaygroundBackend::kOpenGLES:
41  return RuntimeStageBackend::kOpenGLES;
42  case PlaygroundBackend::kVulkan:
43  return RuntimeStageBackend::kVulkan;
44  }
45  FML_UNREACHABLE();
46 }

References kMetal, kOpenGLES, and kVulkan.

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

◆ 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 13 of file promise.h.

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

◆ RegistrationIfReady()

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

Definition at line 97 of file archive_database.cc.

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

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 247 of file pipeline_library_vk.cc.

249  {
250  constexpr bool kReportPipelineCreationFeedbackToLogs = false;
251  constexpr bool kReportPipelineCreationFeedbackToTraces = true;
252  if (kReportPipelineCreationFeedbackToLogs) {
253  ReportPipelineCreationFeedbackToLog(desc, feedback);
254  }
255  if (kReportPipelineCreationFeedbackToTraces) {
256  ReportPipelineCreationFeedbackToTrace(desc, feedback);
257  }
258 }

References ReportPipelineCreationFeedbackToLog(), and ReportPipelineCreationFeedbackToTrace().

◆ ReportPipelineCreationFeedbackToLog() [1/2]

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

Definition at line 199 of file pipeline_library_vk.cc.

201  {
202  std::stringstream stream;
203  stream << std::fixed << std::showpoint << std::setprecision(2);
204  stream << std::endl << ">>>>>>" << std::endl;
205  stream << "Pipeline '" << desc.GetLabel() << "' ";
206  ReportPipelineCreationFeedbackToLog(stream,
207  *feedback.pPipelineCreationFeedback);
208  if (feedback.pipelineStageCreationFeedbackCount != 0) {
209  stream << std::endl;
210  }
211  for (size_t i = 0, count = feedback.pipelineStageCreationFeedbackCount;
212  i < count; i++) {
213  stream << "\tStage " << i + 1 << ": ";
214  ReportPipelineCreationFeedbackToLog(
215  stream, feedback.pPipelineStageCreationFeedbacks[i]);
216  if (i != count - 1) {
217  stream << std::endl;
218  }
219  }
220  stream << std::endl << "<<<<<<" << std::endl;
221  FML_LOG(ERROR) << stream.str();
222 }

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

◆ ReportPipelineCreationFeedbackToLog() [2/2]

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

Definition at line 182 of file pipeline_library_vk.cc.

184  {
185  const auto pipeline_cache_hit =
186  feedback.flags &
187  vk::PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit;
188  const auto base_pipeline_accl =
189  feedback.flags &
190  vk::PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration;
191  auto duration = std::chrono::duration_cast<MillisecondsF>(
192  std::chrono::nanoseconds{feedback.duration});
193  stream << "Time: " << duration.count() << "ms"
194  << " Cache Hit: " << static_cast<bool>(pipeline_cache_hit)
195  << " Base Accel: " << static_cast<bool>(base_pipeline_accl)
196  << " Thread: " << std::this_thread::get_id();
197 }

Referenced by ReportPipelineCreationFeedback(), and ReportPipelineCreationFeedbackToLog().

◆ ReportPipelineCreationFeedbackToTrace()

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

Definition at line 224 of file pipeline_library_vk.cc.

226  {
227  static int64_t gPipelineCacheHits = 0;
228  static int64_t gPipelineCacheMisses = 0;
229  static int64_t gPipelines = 0;
230  if (feedback.pPipelineCreationFeedback->flags &
231  vk::PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit) {
232  gPipelineCacheHits++;
233  } else {
234  gPipelineCacheMisses++;
235  }
236  gPipelines++;
237  static constexpr int64_t kImpellerPipelineTraceID = 1988;
238  FML_TRACE_COUNTER("impeller", //
239  "PipelineCache", // series name
240  kImpellerPipelineTraceID, // series ID
241  "PipelineCacheHits", gPipelineCacheHits, //
242  "PipelineCacheMisses", gPipelineCacheMisses, //
243  "TotalPipelines", gPipelines //
244  );
245 }

Referenced by ReportPipelineCreationFeedback().

◆ ResourceIsLive()

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

Definition at line 319 of file proc_table_gles.cc.

321  {
322  switch (type) {
323  case DebugResourceType::kTexture:
324  return gl.IsTexture(name);
325  case DebugResourceType::kBuffer:
326  return gl.IsBuffer(name);
327  case DebugResourceType::kProgram:
328  return gl.IsProgram(name);
329  case DebugResourceType::kShader:
330  return gl.IsShader(name);
331  case DebugResourceType::kRenderBuffer:
332  return gl.IsRenderbuffer(name);
333  case DebugResourceType::kFrameBuffer:
334  return gl.IsFramebuffer(name);
335  }
336  FML_UNREACHABLE();
337 }

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 30 of file scalar.h.

32  {
33  return ScalarNearlyZero(x - y, tolerance);
34 }

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 25 of file scalar.h.

26  {
27  return Absolute(x) <= tolerance;
28 }

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 31 of file half.h.

31  {
32 #ifdef FML_OS_WIN
33  return static_cast<InternalHalf>(0);
34 #else
35  return static_cast<InternalHalf>(f);
36 #endif
37 }

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

◆ ScaleSigma()

Sigma impeller::ScaleSigma ( Sigma  sigma)

Definition at line 27 of file directional_gaussian_blur_filter_contents.cc.

27  {
28  // Limit the kernel size to 1000x1000 pixels, like Skia does.
29  Scalar clamped = std::min(sigma.sigma, 500.0f);
30  Scalar scalar = 1.0 - 3.4e-3 * clamped + 3.4e-06 * clamped * clamped;
31  return Sigma(clamped * scalar);
32 }

References impeller::Sigma::sigma.

Referenced by impeller::DirectionalGaussianBlurFilterContents::GetFilterCoverage().

◆ 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 72 of file render_pass_vk.cc.

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

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 343 of file render_pass_vk.cc.

346  {
347  // Set the viewport.
348  const auto& vp = command.viewport.value_or<Viewport>(
349  {.rect = Rect::MakeSize(target_size)});
350  vk::Viewport viewport = vk::Viewport()
351  .setWidth(vp.rect.GetWidth())
352  .setHeight(-vp.rect.GetHeight())
353  .setY(vp.rect.GetHeight())
354  .setMinDepth(0.0f)
355  .setMaxDepth(1.0f);
356  cmd_buffer_cache.SetViewport(cmd_buffer, 0, 1, &viewport);
357 
358  // Set the scissor rect.
359  const auto& sc = command.scissor.value_or(IRect::MakeSize(target_size));
360  vk::Rect2D scissor =
361  vk::Rect2D()
362  .setOffset(vk::Offset2D(sc.GetX(), sc.GetY()))
363  .setExtent(vk::Extent2D(sc.GetWidth(), sc.GetHeight()));
364  cmd_buffer_cache.SetScissor(cmd_buffer, 0, 1, &scissor);
365 }

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

◆ ShaderLibraryMappingsForPlayground() [1/3]

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

Definition at line 31 of file playground_impl_vk.cc.

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

◆ 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 91 of file playground_impl_gles.cc.

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

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 11 of file uniform_sorter.cc.

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

◆ 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 221 of file formats.h.

221  {
222  switch (action) {
223  case StoreAction::kDontCare:
224  return "DontCare";
225  case StoreAction::kStore:
226  return "Store";
227  case StoreAction::kMultisampleResolve:
228  return "MultisampleResolve";
229  case StoreAction::kStoreAndMultisampleResolve:
230  return "StoreAndMultisampleResolve";
231  }
232 }

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  std::vector<float> points;
45  if (Tessellator{}.Tessellate(
46  path, tolerance,
47  [&points](const float* vertices, size_t vertices_count,
48  const uint16_t* indices, size_t indices_count) {
49  // Results are expected to be re-duplicated.
50  std::vector<Point> raw_points;
51  for (auto i = 0u; i < vertices_count * 2; i += 2) {
52  raw_points.emplace_back(Point{vertices[i], vertices[i + 1]});
53  }
54  for (auto i = 0u; i < indices_count; i++) {
55  auto point = raw_points[indices[i]];
56  points.push_back(point.x);
57  points.push_back(point.y);
58  }
59  return true;
60  }) != Tessellator::Result::kSuccess) {
61  return nullptr;
62  }
63 
64  Vertices* vertices = new Vertices();
65  vertices->points = new float[points.size()];
66  if (!vertices->points) {
67  return nullptr;
68  }
69  vertices->length = points.size();
70  std::copy(points.begin(), points.end(), vertices->points);
71  return vertices;
72 }

References impeller::PathBuilder::CopyPath(), impeller::Tessellator::kSuccess, impeller::Vertices::length, impeller::Vertices::points, and impeller::Tessellator::Tessellate().

◆ 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 264 of file formats.h.

264  {
265  switch (type) {
266  case TextureType::kTexture2D:
267  return "Texture2D";
268  case TextureType::kTexture2DMultisample:
269  return "Texture2DMultisample";
270  case TextureType::kTextureCube:
271  return "TextureCube";
272  case TextureType::kTextureExternalOES:
273  return "TextureExternalOES";
274  }
275  FML_UNREACHABLE();
276 }

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 304 of file formats.h.

304  {
305  return static_cast<TextureUsageMask>(TextureUsage::kRenderTarget) & mask;
306 }

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 308 of file formats.h.

308  {
309  switch (usage) {
310  case TextureUsage::kUnknown:
311  return "Unknown";
312  case TextureUsage::kShaderRead:
313  return "ShaderRead";
314  case TextureUsage::kShaderWrite:
315  return "ShaderWrite";
316  case TextureUsage::kRenderTarget:
317  return "RenderTarget";
318  }
319  FML_UNREACHABLE();
320 }

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 18 of file tiled_texture_contents.cc.

20  {
21  switch (tile_mode) {
22  case Entity::TileMode::kClamp:
23  return SamplerAddressMode::kClampToEdge;
24  break;
25  case Entity::TileMode::kMirror:
26  return SamplerAddressMode::kMirror;
27  break;
28  case Entity::TileMode::kRepeat:
29  return SamplerAddressMode::kRepeat;
30  break;
31  case Entity::TileMode::kDecal:
32  if (capabilities.SupportsDecalSamplerAddressMode()) {
33  return SamplerAddressMode::kDecal;
34  }
35  return std::nullopt;
36  }
37 }

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,
bool  supports_decal_sampler_address_mode 
)
static

Definition at line 56 of file sampler_gles.cc.

57  {
58  switch (mode) {
59  case SamplerAddressMode::kClampToEdge:
60  return GL_CLAMP_TO_EDGE;
61  case SamplerAddressMode::kRepeat:
62  return GL_REPEAT;
63  case SamplerAddressMode::kMirror:
64  return GL_MIRRORED_REPEAT;
65  case SamplerAddressMode::kDecal:
66  if (supports_decal_sampler_address_mode) {
67  return IMPELLER_GL_CLAMP_TO_BORDER;
68  } else {
69  return GL_CLAMP_TO_EDGE;
70  }
71  }
72  FML_UNREACHABLE();
73 }

References IMPELLER_GL_CLAMP_TO_BORDER, kClampToEdge, kDecal, kMirror, and kRepeat.

Referenced by impeller::SamplerGLES::ConfigureBoundTexture().

◆ ToArchiveRenderingBackend()

constexpr ArchiveRenderingBackend impeller::ToArchiveRenderingBackend ( fb::RenderingBackend  backend)
constexpr

Definition at line 11 of file multi_arch_shader_archive.cc.

12  {
13  switch (backend) {
14  case fb::RenderingBackend::kOpenGLES:
15  return ArchiveRenderingBackend::kOpenGLES;
16  case fb::RenderingBackend::kVulkan:
17  return ArchiveRenderingBackend::kVulkan;
18  case fb::RenderingBackend::kMetal:
19  return ArchiveRenderingBackend::kMetal;
20  }
21  FML_UNREACHABLE();
22 }

References kMetal, kOpenGLES, and kVulkan.

Referenced by impeller::MultiArchShaderArchive::MultiArchShaderArchive().

◆ ToArrayLayerCount()

constexpr uint32_t impeller::ToArrayLayerCount ( TextureType  type)
constexpr

Definition at line 594 of file formats_vk.h.

594  {
595  switch (type) {
596  case TextureType::kTexture2D:
597  case TextureType::kTexture2DMultisample:
598  return 1u;
599  case TextureType::kTextureCube:
600  return 6u;
601  case TextureType::kTextureExternalOES:
602  VALIDATION_LOG
603  << "kTextureExternalOES can not be used with the Vulkan backend.";
604  }
605  FML_UNREACHABLE();
606 }

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 460 of file texture_gles.cc.

460  {
461  switch (point) {
462  case TextureGLES::AttachmentPoint::kColor0:
463  return GL_COLOR_ATTACHMENT0;
464  case TextureGLES::AttachmentPoint::kDepth:
465  return GL_DEPTH_ATTACHMENT;
466  case TextureGLES::AttachmentPoint::kStencil:
467  return GL_STENCIL_ATTACHMENT;
468  }
469 }

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 91 of file formats_gles.h.

91  {
92  switch (factor) {
93  case BlendFactor::kZero:
94  return GL_ZERO;
95  case BlendFactor::kOne:
96  return GL_ONE;
97  case BlendFactor::kSourceColor:
98  return GL_SRC_COLOR;
99  case BlendFactor::kOneMinusSourceColor:
100  return GL_ONE_MINUS_SRC_COLOR;
101  case BlendFactor::kSourceAlpha:
102  return GL_SRC_ALPHA;
103  case BlendFactor::kOneMinusSourceAlpha:
104  return GL_ONE_MINUS_SRC_ALPHA;
105  case BlendFactor::kDestinationColor:
106  return GL_DST_COLOR;
107  case BlendFactor::kOneMinusDestinationColor:
108  return GL_ONE_MINUS_DST_COLOR;
109  case BlendFactor::kDestinationAlpha:
110  return GL_DST_ALPHA;
111  case BlendFactor::kOneMinusDestinationAlpha:
112  return GL_ONE_MINUS_DST_ALPHA;
113  case BlendFactor::kSourceAlphaSaturated:
114  return GL_SRC_ALPHA_SATURATE;
115  case BlendFactor::kBlendColor:
116  return GL_CONSTANT_COLOR;
117  case BlendFactor::kOneMinusBlendColor:
118  return GL_ONE_MINUS_CONSTANT_COLOR;
119  case BlendFactor::kBlendAlpha:
120  return GL_CONSTANT_ALPHA;
121  case BlendFactor::kOneMinusBlendAlpha:
122  return GL_ONE_MINUS_CONSTANT_ALPHA;
123  }
124  FML_UNREACHABLE();
125 }

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 47 of file dl_dispatcher.cc.

47  {
48  switch (mode) {
49  case flutter::DlBlendMode::kClear:
50  return BlendMode::kClear;
51  case flutter::DlBlendMode::kSrc:
52  return BlendMode::kSource;
53  case flutter::DlBlendMode::kDst:
54  return BlendMode::kDestination;
55  case flutter::DlBlendMode::kSrcOver:
56  return BlendMode::kSourceOver;
57  case flutter::DlBlendMode::kDstOver:
58  return BlendMode::kDestinationOver;
59  case flutter::DlBlendMode::kSrcIn:
60  return BlendMode::kSourceIn;
61  case flutter::DlBlendMode::kDstIn:
62  return BlendMode::kDestinationIn;
63  case flutter::DlBlendMode::kSrcOut:
64  return BlendMode::kSourceOut;
65  case flutter::DlBlendMode::kDstOut:
66  return BlendMode::kDestinationOut;
67  case flutter::DlBlendMode::kSrcATop:
68  return BlendMode::kSourceATop;
69  case flutter::DlBlendMode::kDstATop:
70  return BlendMode::kDestinationATop;
71  case flutter::DlBlendMode::kXor:
72  return BlendMode::kXor;
73  case flutter::DlBlendMode::kPlus:
74  return BlendMode::kPlus;
75  case flutter::DlBlendMode::kModulate:
76  return BlendMode::kModulate;
77  case flutter::DlBlendMode::kScreen:
78  return BlendMode::kScreen;
79  case flutter::DlBlendMode::kOverlay:
80  return BlendMode::kOverlay;
81  case flutter::DlBlendMode::kDarken:
82  return BlendMode::kDarken;
83  case flutter::DlBlendMode::kLighten:
84  return BlendMode::kLighten;
85  case flutter::DlBlendMode::kColorDodge:
86  return BlendMode::kColorDodge;
87  case flutter::DlBlendMode::kColorBurn:
88  return BlendMode::kColorBurn;
89  case flutter::DlBlendMode::kHardLight:
90  return BlendMode::kHardLight;
91  case flutter::DlBlendMode::kSoftLight:
92  return BlendMode::kSoftLight;
93  case flutter::DlBlendMode::kDifference:
94  return BlendMode::kDifference;
95  case flutter::DlBlendMode::kExclusion:
96  return BlendMode::kExclusion;
97  case flutter::DlBlendMode::kMultiply:
98  return BlendMode::kMultiply;
99  case flutter::DlBlendMode::kHue:
100  return BlendMode::kHue;
101  case flutter::DlBlendMode::kSaturation:
102  return BlendMode::kSaturation;
103  case flutter::DlBlendMode::kColor:
104  return BlendMode::kColor;
105  case flutter::DlBlendMode::kLuminosity:
106  return BlendMode::kLuminosity;
107  }
108  FML_UNREACHABLE();
109 }

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 127 of file formats_gles.h.

127  {
128  switch (op) {
129  case BlendOperation::kAdd:
130  return GL_FUNC_ADD;
131  case BlendOperation::kSubtract:
132  return GL_FUNC_SUBTRACT;
133  case BlendOperation::kReverseSubtract:
134  return GL_FUNC_REVERSE_SUBTRACT;
135  }
136  FML_UNREACHABLE();
137 }

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ConfigureBlending().

◆ ToBlurStyle()

static FilterContents::BlurStyle impeller::ToBlurStyle ( flutter::DlBlurStyle  blur_style)
static

Definition at line 492 of file dl_dispatcher.cc.

492  {
493  switch (blur_style) {
494  case flutter::DlBlurStyle::kNormal:
495  return FilterContents::BlurStyle::kNormal;
496  case flutter::DlBlurStyle::kSolid:
497  return FilterContents::BlurStyle::kSolid;
498  case flutter::DlBlurStyle::kOuter:
499  return FilterContents::BlurStyle::kOuter;
500  case flutter::DlBlurStyle::kInner:
501  return FilterContents::BlurStyle::kInner;
502  }
503 }

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 712 of file dl_dispatcher.cc.

713  {
714  switch (clip_op) {
715  case flutter::DlCanvas::ClipOp::kDifference:
716  return Entity::ClipOperation::kDifference;
717  case flutter::DlCanvas::ClipOp::kIntersect:
718  return Entity::ClipOperation::kIntersect;
719  }
720 }

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 445 of file dl_dispatcher.cc.

446  {
447  if (filter == nullptr) {
448  return nullptr;
449  }
450  switch (filter->type()) {
451  case flutter::DlColorFilterType::kBlend: {
452  auto dl_blend = filter->asBlend();
453  auto blend_mode = ToBlendMode(dl_blend->mode());
454  auto color = skia_conversions::ToColor(dl_blend->color());
455  return ColorFilter::MakeBlend(blend_mode, color);
456  }
457  case flutter::DlColorFilterType::kMatrix: {
458  const flutter::DlMatrixColorFilter* dl_matrix = filter->asMatrix();
459  impeller::ColorMatrix color_matrix;
460  dl_matrix->get_matrix(color_matrix.array);
461  return ColorFilter::MakeMatrix(color_matrix);
462  }
463  case flutter::DlColorFilterType::kSrgbToLinearGamma:
464  return ColorFilter::MakeSrgbToLinear();
465  case flutter::DlColorFilterType::kLinearToSrgbGamma:
466  return ColorFilter::MakeLinearToSrgb();
467  }
468  return nullptr;
469 }

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 250 of file dl_dispatcher.cc.

250  {
251  auto result = std::vector<Color>();
252  if (colors == nullptr) {
253  return result;
254  }
255  for (int i = 0; i < count; i++) {
256  result.push_back(skia_conversions::ToColor(colors[i]));
257  }
258  return result;
259 }

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 261 of file dl_dispatcher.cc.

262  {
263  switch (type) {
264  case flutter::DlColorSourceType::kColor:
265  return ColorSource::Type::kColor;
266  case flutter::DlColorSourceType::kImage:
267  return ColorSource::Type::kImage;
268  case flutter::DlColorSourceType::kLinearGradient:
269  return ColorSource::Type::kLinearGradient;
270  case flutter::DlColorSourceType::kRadialGradient:
271  return ColorSource::Type::kRadialGradient;
272  case flutter::DlColorSourceType::kConicalGradient:
273  return ColorSource::Type::kConicalGradient;
274  case flutter::DlColorSourceType::kSweepGradient:
275  return ColorSource::Type::kSweepGradient;
276  case flutter::DlColorSourceType::kRuntimeEffect:
277  return ColorSource::Type::kRuntimeEffect;
278 #ifdef IMPELLER_ENABLE_3D
279  case flutter::DlColorSourceType::kScene:
280  return ColorSource::Type::kScene;
281 #endif // IMPELLER_ENABLE_3D
282  }
283 }

References impeller::ColorSource::kColor, 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 84 of file archive_statement.cc.

84  {
85  /*
86  * sqlite columns begin from 0
87  */
88  return static_cast<int>(index);
89 }

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 69 of file formats_gles.h.

69  {
70  switch (func) {
71  case CompareFunction::kNever:
72  return GL_NEVER;
73  case CompareFunction::kAlways:
74  return GL_ALWAYS;
75  case CompareFunction::kLess:
76  return GL_LESS;
77  case CompareFunction::kEqual:
78  return GL_EQUAL;
79  case CompareFunction::kLessEqual:
80  return GL_LEQUAL;
81  case CompareFunction::kGreater:
82  return GL_GREATER;
83  case CompareFunction::kNotEqual:
84  return GL_NOTEQUAL;
85  case CompareFunction::kGreaterEqual:
86  return GL_GEQUAL;
87  }
88  FML_UNREACHABLE();
89 }

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 301 of file proc_table_gles.cc.

301  {
302  switch (type) {
303  case DebugResourceType::kTexture:
304  return GL_TEXTURE;
305  case DebugResourceType::kBuffer:
306  return GL_BUFFER_KHR;
307  case DebugResourceType::kProgram:
308  return GL_PROGRAM_KHR;
309  case DebugResourceType::kShader:
310  return GL_SHADER_KHR;
311  case DebugResourceType::kRenderBuffer:
312  return GL_RENDERBUFFER;
313  case DebugResourceType::kFrameBuffer:
314  return GL_FRAMEBUFFER;
315  }
316  FML_UNREACHABLE();
317 }

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

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

◆ ToDebugResourceType()

static DebugResourceType impeller::ToDebugResourceType ( HandleType  type)
static

Definition at line 173 of file reactor_gles.cc.

173  {
174  switch (type) {
175  case HandleType::kUnknown:
176  FML_UNREACHABLE();
177  case HandleType::kTexture:
178  return DebugResourceType::kTexture;
179  case HandleType::kBuffer:
180  return DebugResourceType::kBuffer;
181  case HandleType::kProgram:
182  return DebugResourceType::kProgram;
183  case HandleType::kRenderBuffer:
184  return DebugResourceType::kRenderBuffer;
185  case HandleType::kFrameBuffer:
186  return DebugResourceType::kFrameBuffer;
187  }
188  FML_UNREACHABLE();
189 }

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.refTypeface());
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 34 of file texture_gles.cc.

34  {
35  switch (type) {
36  case TextureGLES::Type::kTexture:
37  case TextureGLES::Type::kTextureMultisampled:
38  return HandleType::kTexture;
39  case TextureGLES::Type::kRenderBuffer:
40  case TextureGLES::Type::kRenderBufferMultisampled:
41  return HandleType::kRenderBuffer;
42  }
43  FML_UNREACHABLE();
44 }

References impeller::TextureGLES::kRenderBuffer, kRenderBuffer, impeller::TextureGLES::kRenderBufferMultisampled, impeller::TextureGLES::kTexture, kTexture, and impeller::TextureGLES::kTextureMultisampled.

◆ ToImageAspectFlags()

constexpr vk::ImageAspectFlags impeller::ToImageAspectFlags ( PixelFormat  format)
constexpr

Definition at line 641 of file formats_vk.h.

641  {
642  switch (format) {
643  case PixelFormat::kUnknown:
644  return {};
645  case PixelFormat::kA8UNormInt:
646  case PixelFormat::kR8UNormInt:
647  case PixelFormat::kR8G8UNormInt:
648  case PixelFormat::kR8G8B8A8UNormInt:
649  case PixelFormat::kR8G8B8A8UNormIntSRGB:
650  case PixelFormat::kB8G8R8A8UNormInt:
651  case PixelFormat::kB8G8R8A8UNormIntSRGB:
652  case PixelFormat::kR32G32B32A32Float:
653  case PixelFormat::kR16G16B16A16Float:
654  case PixelFormat::kB10G10R10XR:
655  case PixelFormat::kB10G10R10XRSRGB:
656  case PixelFormat::kB10G10R10A10XR:
657  return vk::ImageAspectFlagBits::eColor;
658  case PixelFormat::kS8UInt:
659  return vk::ImageAspectFlagBits::eStencil;
660  case PixelFormat::kD24UnormS8Uint:
661  case PixelFormat::kD32FloatS8UInt:
662  return vk::ImageAspectFlagBits::eDepth |
663  vk::ImageAspectFlagBits::eStencil;
664  }
665  FML_UNREACHABLE();
666 }

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 525 of file dl_dispatcher.cc.

526  {
527  if (filter == nullptr) {
528  return nullptr;
529  }
530 
531  switch (filter->type()) {
532  case flutter::DlImageFilterType::kBlur: {
533  auto blur = filter->asBlur();
534  auto sigma_x = Sigma(blur->sigma_x());
535  auto sigma_y = Sigma(blur->sigma_y());
536  auto tile_mode = ToTileMode(blur->tile_mode());
537  return ImageFilter::MakeBlur(
538  sigma_x, sigma_y, FilterContents::BlurStyle::kNormal, tile_mode);
539  }
540  case flutter::DlImageFilterType::kDilate: {
541  auto dilate = filter->asDilate();
542  FML_DCHECK(dilate);
543  if (dilate->radius_x() < 0 || dilate->radius_y() < 0) {
544  return nullptr;
545  }
546  auto radius_x = Radius(dilate->radius_x());
547  auto radius_y = Radius(dilate->radius_y());
548  return ImageFilter::MakeDilate(radius_x, radius_y);
549  }
550  case flutter::DlImageFilterType::kErode: {
551  auto erode = filter->asErode();
552  FML_DCHECK(erode);
553  if (erode->radius_x() < 0 || erode->radius_y() < 0) {
554  return nullptr;
555  }
556  auto radius_x = Radius(erode->radius_x());
557  auto radius_y = Radius(erode->radius_y());
558  return ImageFilter::MakeErode(radius_x, radius_y);
559  }
560  case flutter::DlImageFilterType::kMatrix: {
561  auto matrix_filter = filter->asMatrix();
562  FML_DCHECK(matrix_filter);
563  auto matrix = ToMatrix(matrix_filter->matrix());
564  auto desc = ToSamplerDescriptor(matrix_filter->sampling());
565  return ImageFilter::MakeMatrix(matrix, desc);
566  }
567  case flutter::DlImageFilterType::kCompose: {
568  auto compose = filter->asCompose();
569  FML_DCHECK(compose);
570  auto outer_dl_filter = compose->outer();
571  auto inner_dl_filter = compose->inner();
572  auto outer_filter = ToImageFilter(outer_dl_filter.get());
573  auto inner_filter = ToImageFilter(inner_dl_filter.get());
574  if (!outer_filter) {
575  return inner_filter;
576  }
577  if (!inner_filter) {
578  return outer_filter;
579  }
580  FML_DCHECK(outer_filter && inner_filter);
581 
582  return ImageFilter::MakeCompose(*inner_filter, *outer_filter);
583  }
584  case flutter::DlImageFilterType::kColorFilter: {
585  auto color_filter_image_filter = filter->asColorFilter();
586  FML_DCHECK(color_filter_image_filter);
587  auto color_filter =
588  ToColorFilter(color_filter_image_filter->color_filter().get());
589  if (!color_filter) {
590  return nullptr;
591  }
592  // When color filters are used as image filters, set the color filter's
593  // "absorb opacity" flag to false. For image filters, the snapshot
594  // opacity needs to be deferred until the result of the filter chain is
595  // being blended with the layer.
596  return ImageFilter::MakeFromColorFilter(*color_filter);
597  }
598  case flutter::DlImageFilterType::kLocalMatrix: {
599  auto local_matrix_filter = filter->asLocalMatrix();
600  FML_DCHECK(local_matrix_filter);
601  auto internal_filter = local_matrix_filter->image_filter();
602  FML_DCHECK(internal_filter);
603 
604  auto image_filter = ToImageFilter(internal_filter.get());
605  if (!image_filter) {
606  return nullptr;
607  }
608 
609  auto matrix = ToMatrix(local_matrix_filter->matrix());
610  return ImageFilter::MakeLocalMatrix(matrix, *image_filter);
611  }
612  }
613 }

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 34 of file formats_gles.h.

34  {
35  switch (type) {
36  case IndexType::kUnknown:
37  case IndexType::kNone:
38  FML_UNREACHABLE();
39  case IndexType::k16bit:
40  return GL_UNSIGNED_SHORT;
41  case IndexType::k32bit:
42  return GL_UNSIGNED_INT;
43  }
44  FML_UNREACHABLE();
45 }

References k16bit, k32bit, kNone, and kUnknown.

Referenced by EncodeCommandsInReactor().

◆ ToMatrix()

static Matrix impeller::ToMatrix ( const SkMatrix &  m)
static

Definition at line 166 of file dl_dispatcher.cc.

166  {
167  return Matrix{
168  // clang-format off
169  m[0], m[3], 0, m[6],
170  m[1], m[4], 0, m[7],
171  0, 0, 1, 0,
172  m[2], m[5], 0, m[8],
173  // clang-format on
174  };
175 }

Referenced by impeller::DlDispatcher::setColorSource(), and ToImageFilter().

◆ ToMode()

constexpr GLenum impeller::ToMode ( PrimitiveType  primitive_type)
constexpr

Definition at line 18 of file formats_gles.h.

18  {
19  switch (primitive_type) {
20  case PrimitiveType::kTriangle:
21  return GL_TRIANGLES;
22  case PrimitiveType::kTriangleStrip:
23  return GL_TRIANGLE_STRIP;
24  case PrimitiveType::kLine:
25  return GL_LINES;
26  case PrimitiveType::kLineStrip:
27  return GL_LINE_STRIP;
28  case PrimitiveType::kPoint:
29  return GL_POINTS;
30  }
31  FML_UNREACHABLE();
32 }

References kLine, kLineStrip, kPoint, kTriangle, and kTriangleStrip.

Referenced by EncodeCommandsInReactor().

◆ ToMTLBlendFactor()

constexpr MTLBlendFactor impeller::ToMTLBlendFactor ( BlendFactor  type)
constexpr

Definition at line 115 of file formats_mtl.h.

115  {
116  switch (type) {
117  case BlendFactor::kZero:
118  return MTLBlendFactorZero;
119  case BlendFactor::kOne:
120  return MTLBlendFactorOne;
121  case BlendFactor::kSourceColor:
122  return MTLBlendFactorSourceColor;
123  case BlendFactor::kOneMinusSourceColor:
124  return MTLBlendFactorOneMinusSourceColor;
125  case BlendFactor::kSourceAlpha:
126  return MTLBlendFactorSourceAlpha;
127  case BlendFactor::kOneMinusSourceAlpha:
128  return MTLBlendFactorOneMinusSourceAlpha;
129  case BlendFactor::kDestinationColor:
130  return MTLBlendFactorDestinationColor;
131  case BlendFactor::kOneMinusDestinationColor:
132  return MTLBlendFactorOneMinusDestinationColor;
133  case BlendFactor::kDestinationAlpha:
134  return MTLBlendFactorDestinationAlpha;
135  case BlendFactor::kOneMinusDestinationAlpha:
136  return MTLBlendFactorOneMinusDestinationAlpha;
137  case BlendFactor::kSourceAlphaSaturated:
138  return MTLBlendFactorSourceAlphaSaturated;
139  case BlendFactor::kBlendColor:
140  return MTLBlendFactorBlendColor;
141  case BlendFactor::kOneMinusBlendColor:
142  return MTLBlendFactorOneMinusBlendColor;
143  case BlendFactor::kBlendAlpha:
144  return MTLBlendFactorBlendAlpha;
145  case BlendFactor::kOneMinusBlendAlpha:
146  return MTLBlendFactorOneMinusBlendAlpha;
147  }
148  return MTLBlendFactorZero;
149 };

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 198 of file formats_mtl.h.

198  {
199  switch (type) {
200  case BlendOperation::kAdd:
201  return MTLBlendOperationAdd;
202  case BlendOperation::kSubtract:
203  return MTLBlendOperationSubtract;
204  case BlendOperation::kReverseSubtract:
205  return MTLBlendOperationReverseSubtract;
206  }
207  return MTLBlendOperationAdd;
208 };

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

◆ ToMTLClearColor()

MTLClearColor impeller::ToMTLClearColor ( const Color &  color)
inline

Definition at line 372 of file formats_mtl.h.

372  {
373  return MTLClearColorMake(color.red, color.green, color.blue, color.alpha);
374 }

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 210 of file formats_mtl.h.

211  {
212  using UnderlyingType = decltype(type);
213 
214  MTLColorWriteMask mask = MTLColorWriteMaskNone;
215 
216  if (type & static_cast<UnderlyingType>(ColorWriteMask::kRed)) {
217  mask |= MTLColorWriteMaskRed;
218  }
219 
220  if (type & static_cast<UnderlyingType>(ColorWriteMask::kGreen)) {
221  mask |= MTLColorWriteMaskGreen;
222  }
223 
224  if (type & static_cast<UnderlyingType>(ColorWriteMask::kBlue)) {
225  mask |= MTLColorWriteMaskBlue;
226  }
227 
228  if (type & static_cast<UnderlyingType>(ColorWriteMask::kAlpha)) {
229  mask |= MTLColorWriteMaskAlpha;
230  }
231 
232  return mask;
233 };

References kAlpha, kBlue, kGreen, and kRed.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

◆ ToMTLCompareFunction()

constexpr MTLCompareFunction impeller::ToMTLCompareFunction ( CompareFunction  func)
constexpr

Definition at line 235 of file formats_mtl.h.

235  {
236  switch (func) {
237  case CompareFunction::kNever:
238  return MTLCompareFunctionNever;
239  case CompareFunction::kLess:
240  return MTLCompareFunctionLess;
241  case CompareFunction::kEqual:
242  return MTLCompareFunctionEqual;
243  case CompareFunction::kLessEqual:
244  return MTLCompareFunctionLessEqual;
245  case CompareFunction::kGreater:
246  return MTLCompareFunctionGreater;
247  case CompareFunction::kNotEqual:
248  return MTLCompareFunctionNotEqual;
249  case CompareFunction::kGreaterEqual:
250  return MTLCompareFunctionGreaterEqual;
251  case CompareFunction::kAlways:
252  return MTLCompareFunctionAlways;
253  }
254  return MTLCompareFunctionAlways;
255 };

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 186 of file formats_mtl.h.

186  {
187  switch (mode) {
188  case CullMode::kNone:
189  return MTLCullModeNone;
190  case CullMode::kBackFace:
191  return MTLCullModeBack;
192  case CullMode::kFrontFace:
193  return MTLCullModeFront;
194  }
195  return MTLCullModeNone;
196 }

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::kCompute:
36  return MTLFunctionTypeKernel;
37  }
38  FML_UNREACHABLE();
39 }

References kCompute, kFragment, kUnknown, and kVertex.

◆ ToMTLIndexType()

constexpr MTLIndexType impeller::ToMTLIndexType ( IndexType  type)
constexpr

Definition at line 177 of file formats_mtl.h.

177  {
178  switch (type) {
179  case IndexType::k16bit:
180  return MTLIndexTypeUInt16;
181  default:
182  return MTLIndexTypeUInt32;
183  }
184 }

References k16bit.

◆ ToMTLLoadAction()

constexpr MTLLoadAction impeller::ToMTLLoadAction ( LoadAction  action)
constexpr

Definition at line 279 of file formats_mtl.h.

279  {
280  switch (action) {
281  case LoadAction::kDontCare:
282  return MTLLoadActionDontCare;
283  case LoadAction::kLoad:
284  return MTLLoadActionLoad;
285  case LoadAction::kClear:
286  return MTLLoadActionClear;
287  }
288 
289  return MTLLoadActionDontCare;
290 }

References kClear, kDontCare, and kLoad.

Referenced by ConfigureAttachment().

◆ ToMTLPixelFormat()

constexpr MTLPixelFormat impeller::ToMTLPixelFormat ( PixelFormat  format)
constexpr

Definition at line 77 of file formats_mtl.h.

77  {
78  switch (format) {
79  case PixelFormat::kUnknown:
80  return MTLPixelFormatInvalid;
81  case PixelFormat::kA8UNormInt:
82  return MTLPixelFormatA8Unorm;
83  case PixelFormat::kR8UNormInt:
84  return MTLPixelFormatR8Unorm;
85  case PixelFormat::kR8G8UNormInt:
86  return MTLPixelFormatRG8Unorm;
87  case PixelFormat::kB8G8R8A8UNormInt:
88  return MTLPixelFormatBGRA8Unorm;
89  case PixelFormat::kB8G8R8A8UNormIntSRGB:
90  return MTLPixelFormatBGRA8Unorm_sRGB;
91  case PixelFormat::kR8G8B8A8UNormInt:
92  return MTLPixelFormatRGBA8Unorm;
93  case PixelFormat::kR8G8B8A8UNormIntSRGB:
94  return MTLPixelFormatRGBA8Unorm_sRGB;
95  case PixelFormat::kR32G32B32A32Float:
96  return MTLPixelFormatRGBA32Float;
97  case PixelFormat::kR16G16B16A16Float:
98  return MTLPixelFormatRGBA16Float;
99  case PixelFormat::kS8UInt:
100  return MTLPixelFormatStencil8;
101  case PixelFormat::kD24UnormS8Uint:
102  return SafeMTLPixelFormatDepth24Unorm_Stencil8();
103  case PixelFormat::kD32FloatS8UInt:
104  return MTLPixelFormatDepth32Float_Stencil8;
105  case PixelFormat::kB10G10R10XRSRGB:
106  return SafeMTLPixelFormatBGR10_XR_sRGB();
107  case PixelFormat::kB10G10R10XR:
108  return SafeMTLPixelFormatBGR10_XR();
109  case PixelFormat::kB10G10R10A10XR:
110  return SafeMTLPixelFormatBGRA10_XR();
111  }
112  return MTLPixelFormatInvalid;
113 };

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(), impeller::testing::TEST(), ToMTLRenderPipelineColorAttachmentDescriptor(), and ToMTLTextureDescriptor().

◆ ToMTLPrimitiveType()

constexpr MTLPrimitiveType impeller::ToMTLPrimitiveType ( PrimitiveType  type)
constexpr

Definition at line 151 of file formats_mtl.h.

151  {
152  switch (type) {
153  case PrimitiveType::kTriangle:
154  return MTLPrimitiveTypeTriangle;
155  case PrimitiveType::kTriangleStrip:
156  return MTLPrimitiveTypeTriangleStrip;
157  case PrimitiveType::kLine:
158  return MTLPrimitiveTypeLine;
159  case PrimitiveType::kLineStrip:
160  return MTLPrimitiveTypeLineStrip;
161  case PrimitiveType::kPoint:
162  return MTLPrimitiveTypePoint;
163  }
164  return MTLPrimitiveTypePoint;
165 }

References kLine, kLineStrip, kPoint, kTriangle, and kTriangleStrip.

◆ ToMTLRenderPassDescriptor()

static MTLRenderPassDescriptor* impeller::ToMTLRenderPassDescriptor ( const RenderTarget &  desc)
static

Definition at line 103 of file render_pass_mtl.mm.

104  {
105  auto result = [MTLRenderPassDescriptor renderPassDescriptor];
106 
107  const auto& colors = desc.GetColorAttachments();
108 
109  for (const auto& color : colors) {
110  if (!ConfigureColorAttachment(color.second,
111  result.colorAttachments[color.first])) {
112  VALIDATION_LOG << "Could not configure color attachment at index "
113  << color.first;
114  return nil;
115  }
116  }
117 
118  const auto& depth = desc.GetDepthAttachment();
119 
120  if (depth.has_value() &&
121  !ConfigureDepthAttachment(depth.value(), result.depthAttachment)) {
122  VALIDATION_LOG << "Could not configure depth attachment.";
123  return nil;
124  }
125 
126  const auto& stencil = desc.GetStencilAttachment();
127 
128  if (stencil.has_value() &&
129  !ConfigureStencilAttachment(stencil.value(), result.stencilAttachment)) {
130  VALIDATION_LOG << "Could not configure stencil attachment.";
131  return nil;
132  }
133 
134  return result;
135 }

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 357 of file formats_mtl.h.

358  {
359  switch (mode) {
360  case SamplerAddressMode::kClampToEdge:
361  return MTLSamplerAddressModeClampToEdge;
362  case SamplerAddressMode::kRepeat:
363  return MTLSamplerAddressModeRepeat;
364  case SamplerAddressMode::kMirror:
365  return MTLSamplerAddressModeMirrorRepeat;
366  case SamplerAddressMode::kDecal:
367  return MTLSamplerAddressModeClampToZero;
368  }
369  return MTLSamplerAddressModeClampToEdge;
370 }

References kClampToEdge, kDecal, kMirror, and kRepeat.

◆ ToMTLSamplerMinMagFilter()

constexpr MTLSamplerMinMagFilter impeller::ToMTLSamplerMinMagFilter ( MinMagFilter  filter)
constexpr

Definition at line 337 of file formats_mtl.h.

337  {
338  switch (filter) {
339  case MinMagFilter::kNearest:
340  return MTLSamplerMinMagFilterNearest;
341  case MinMagFilter::kLinear:
342  return MTLSamplerMinMagFilterLinear;
343  }
344  return MTLSamplerMinMagFilterNearest;
345 }

References kLinear, and kNearest.

◆ ToMTLSamplerMipFilter()

constexpr MTLSamplerMipFilter impeller::ToMTLSamplerMipFilter ( MipFilter  filter)
constexpr

Definition at line 347 of file formats_mtl.h.

347  {
348  switch (filter) {
349  case MipFilter::kNearest:
350  return MTLSamplerMipFilterNearest;
351  case MipFilter::kLinear:
352  return MTLSamplerMipFilterLinear;
353  }
354  return MTLSamplerMipFilterNotMipmapped;
355 }

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 257 of file formats_mtl.h.

257  {
258  switch (op) {
259  case StencilOperation::kKeep:
260  return MTLStencilOperationKeep;
261  case StencilOperation::kZero:
262  return MTLStencilOperationZero;
263  case StencilOperation::kSetToReferenceValue:
264  return MTLStencilOperationReplace;
265  case StencilOperation::kIncrementClamp:
266  return MTLStencilOperationIncrementClamp;
267  case StencilOperation::kDecrementClamp:
268  return MTLStencilOperationDecrementClamp;
269  case StencilOperation::kInvert:
270  return MTLStencilOperationInvert;
271  case StencilOperation::kIncrementWrap:
272  return MTLStencilOperationIncrementWrap;
273  case StencilOperation::kDecrementWrap:
274  return MTLStencilOperationDecrementWrap;
275  }
276  return MTLStencilOperationKeep;
277 };

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 307 of file formats_mtl.h.

307  {
308  switch (action) {
309  case StoreAction::kDontCare:
310  return MTLStoreActionDontCare;
311  case StoreAction::kStore:
312  return MTLStoreActionStore;
313  case StoreAction::kMultisampleResolve:
314  return MTLStoreActionMultisampleResolve;
315  case StoreAction::kStoreAndMultisampleResolve:
316  return MTLStoreActionStoreAndMultisampleResolve;
317  }
318  return MTLStoreActionDontCare;
319 }

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 376 of file formats_mtl.h.

376  {
377  switch (type) {
378  case TextureType::kTexture2D:
379  return MTLTextureType2D;
380  case TextureType::kTexture2DMultisample:
381  return MTLTextureType2DMultisample;
382  case TextureType::kTextureCube:
383  return MTLTextureTypeCube;
384  case TextureType::kTextureExternalOES:
385  VALIDATION_LOG
386  << "kTextureExternalOES can not be used with the Metal backend.";
387  }
388  return MTLTextureType2D;
389 }

References kTexture2D, kTexture2DMultisample, kTextureCube, kTextureExternalOES, and VALIDATION_LOG.

Referenced by ToMTLTextureDescriptor().

◆ ToMTLTriangleFillMode()

constexpr MTLTriangleFillMode impeller::ToMTLTriangleFillMode ( PolygonMode  mode)
constexpr

Definition at line 167 of file formats_mtl.h.

167  {
168  switch (mode) {
169  case PolygonMode::kFill:
170  return MTLTriangleFillModeFill;
171  case PolygonMode::kLine:
172  return MTLTriangleFillModeLines;
173  }
174  return MTLTriangleFillModeFill;
175 }

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 77 of file archive_statement.cc.

77  {
78  /*
79  * sqlite parameters begin from 1
80  */
81  return static_cast<int>(index + 1);
82 }

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 280 of file texture_gles.cc.

280  {
281  switch (format) {
282  case PixelFormat::kB8G8R8A8UNormInt:
283  case PixelFormat::kR8G8B8A8UNormInt:
284  return GL_RGBA4;
285  case PixelFormat::kR32G32B32A32Float:
286  return GL_RGBA32F;
287  case PixelFormat::kR16G16B16A16Float:
288  return GL_RGBA16F;
289  case PixelFormat::kS8UInt:
290  return GL_STENCIL_INDEX8;
291  case PixelFormat::kD24UnormS8Uint:
292  return GL_DEPTH24_STENCIL8;
293  case PixelFormat::kD32FloatS8UInt:
294  return GL_DEPTH32F_STENCIL8;
295  case PixelFormat::kUnknown:
296  case PixelFormat::kA8UNormInt:
297  case PixelFormat::kR8UNormInt:
298  case PixelFormat::kR8G8UNormInt:
299  case PixelFormat::kR8G8B8A8UNormIntSRGB:
300  case PixelFormat::kB8G8R8A8UNormIntSRGB:
301  case PixelFormat::kB10G10R10XRSRGB:
302  case PixelFormat::kB10G10R10XR:
303  case PixelFormat::kB10G10R10A10XR:
304  return std::nullopt;
305  }
306  FML_UNREACHABLE();
307 }

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

◆ ToRenderingBackend()

constexpr fb::RenderingBackend impeller::ToRenderingBackend ( ArchiveRenderingBackend  backend)
constexpr

Definition at line 31 of file multi_arch_shader_archive_writer.cc.

32  {
33  switch (backend) {
34  case ArchiveRenderingBackend::kMetal:
35  return fb::RenderingBackend::kMetal;
36  case ArchiveRenderingBackend::kVulkan:
37  return fb::RenderingBackend::kVulkan;
38  case ArchiveRenderingBackend::kOpenGLES:
39  return fb::RenderingBackend::kOpenGLES;
40  }
41  FML_UNREACHABLE();
42 }

References kMetal, kOpenGLES, and kVulkan.

Referenced by impeller::MultiArchShaderArchiveWriter::CreateMapping().

◆ 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 148 of file dl_dispatcher.cc.

149  {
150  impeller::SamplerDescriptor desc;
151  switch (options) {
152  case flutter::DlFilterMode::kNearest:
153  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kNearest;
154  desc.label = "Nearest Sampler";
155  break;
156  case flutter::DlFilterMode::kLinear:
157  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
158  desc.label = "Linear Sampler";
159  break;
160  default:
161  break;
162  }
163  return desc;
164 }

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 124 of file dl_dispatcher.cc.

125  {
126  impeller::SamplerDescriptor desc;
127  switch (options) {
128  case flutter::DlImageSampling::kNearestNeighbor:
129  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kNearest;
130  desc.label = "Nearest Sampler";
131  break;
132  case flutter::DlImageSampling::kLinear:
133  // Impeller doesn't support cubic sampling, but linear is closer to correct
134  // than nearest for this case.
135  case flutter::DlImageSampling::kCubic:
136  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
137  desc.label = "Linear Sampler";
138  break;
139  case flutter::DlImageSampling::kMipmapLinear:
140  desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
141  desc.mip_filter = impeller::MipFilter::kLinear;
142  desc.label = "Mipmap Linear Sampler";
143  break;
144  }
145  return desc;
146 }

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 ( ArchiveShaderType  type)
static

Definition at line 18 of file shader_library_gles.cc.

18  {
19  switch (type) {
20  case ArchiveShaderType::kVertex:
21  return ShaderStage::kVertex;
22  case ArchiveShaderType::kFragment:
23  return ShaderStage::kFragment;
24  case ArchiveShaderType::kCompute:
25  return ShaderStage::kCompute;
26  }
27  FML_UNREACHABLE();
28 }

References kCompute, kFragment, and kVertex.

◆ ToShaderStage() [2/4]

static ShaderStage impeller::ToShaderStage ( ArchiveShaderType  type)
static

Definition at line 18 of file shader_library_vk.cc.

18  {
19  switch (type) {
20  case ArchiveShaderType::kVertex:
21  return ShaderStage::kVertex;
22  case ArchiveShaderType::kFragment:
23  return ShaderStage::kFragment;
24  case ArchiveShaderType::kCompute:
25  return ShaderStage::kCompute;
26  }
27  FML_UNREACHABLE();
28 }

References kCompute, kFragment, and kVertex.

◆ ToShaderStage() [3/4]

static RuntimeShaderStage impeller::ToShaderStage ( fb::Stage  stage)
static

Definition at line 49 of file runtime_stage.cc.

49  {
50  switch (stage) {
51  case fb::Stage::kVertex:
52  return RuntimeShaderStage::kVertex;
53  case fb::Stage::kFragment:
54  return RuntimeShaderStage::kFragment;
55  case fb::Stage::kCompute:
56  return RuntimeShaderStage::kCompute;
57  }
58  FML_UNREACHABLE();
59 }

References kCompute, kFragment, 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  }
38  FML_UNREACHABLE();
39 }

References kCompute, kFragment, and kVertex.

Referenced by impeller::RuntimeStagePlayground::RegisterStage(), impeller::RuntimeEffectContents::Render(), impeller::RuntimeStage::RuntimeStage(), and impeller::testing::TEST_P().

◆ ToShaderType()

constexpr ArchiveShaderType impeller::ToShaderType ( fb::Stage  stage)
constexpr

Definition at line 16 of file shader_archive.cc.

16  {
17  switch (stage) {
18  case fb::Stage::kVertex:
19  return ArchiveShaderType::kVertex;
20  case fb::Stage::kFragment:
21  return ArchiveShaderType::kFragment;
22  case fb::Stage::kCompute:
23  return ArchiveShaderType::kCompute;
24  }
25  FML_UNREACHABLE();
26 }

References kCompute, kFragment, and kVertex.

◆ ToStage()

constexpr fb::Stage impeller::ToStage ( ArchiveShaderType  type)
constexpr

Definition at line 86 of file shader_archive_writer.cc.

86  {
87  switch (type) {
88  case ArchiveShaderType::kVertex:
89  return fb::Stage::kVertex;
90  case ArchiveShaderType::kFragment:
91  return fb::Stage::kFragment;
92  case ArchiveShaderType::kCompute:
93  return fb::Stage::kCompute;
94  }
95  FML_UNREACHABLE();
96 }

References kCompute, kFragment, and kVertex.

Referenced by impeller::ShaderArchiveWriter::CreateMapping().

◆ ToStencilOp()

constexpr GLenum impeller::ToStencilOp ( StencilOperation  op)
constexpr

Definition at line 47 of file formats_gles.h.

47  {
48  switch (op) {
49  case StencilOperation::kKeep:
50  return GL_KEEP;
51  case StencilOperation::kZero:
52  return GL_ZERO;
53  case StencilOperation::kSetToReferenceValue:
54  return GL_REPLACE;
55  case StencilOperation::kIncrementClamp:
56  return GL_INCR;
57  case StencilOperation::kDecrementClamp:
58  return GL_DECR;
59  case StencilOperation::kInvert:
60  return GL_INVERT;
61  case StencilOperation::kIncrementWrap:
62  return GL_INCR_WRAP;
63  case StencilOperation::kDecrementWrap:
64  return GL_DECR_WRAP;
65  }
66  FML_UNREACHABLE();
67 }

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 182 of file dl_dispatcher.cc.

182  {
183  switch (style) {
184  case flutter::DlDrawStyle::kFill:
185  return Paint::Style::kFill;
186  case flutter::DlDrawStyle::kStroke:
187  return Paint::Style::kStroke;
188  case flutter::DlDrawStyle::kStrokeAndFill:
189  UNIMPLEMENTED;
190  break;
191  }
192  return Paint::Style::kFill;
193 }

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 48 of file tessellator.cc.

48  {
49  switch (fill_type) {
50  case FillType::kOdd:
51  return TESS_WINDING_ODD;
52  case FillType::kNonZero:
53  return TESS_WINDING_NONZERO;
54  case FillType::kPositive:
55  return TESS_WINDING_POSITIVE;
56  case FillType::kNegative:
57  return TESS_WINDING_NEGATIVE;
58  case FillType::kAbsGeqTwo:
59  return TESS_WINDING_ABS_GEQ_TWO;
60  }
61  return TESS_WINDING_ODD;
62 }

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 184 of file formats_gles.h.

184  {
185  switch (type) {
186  case TextureType::kTexture2D:
187  return GL_TEXTURE_2D;
188  case TextureType::kTexture2DMultisample:
189  return GL_TEXTURE_2D;
190  case TextureType::kTextureCube:
191  return GL_TEXTURE_CUBE_MAP;
192  case TextureType::kTextureExternalOES:
193  return GL_TEXTURE_EXTERNAL_OES;
194  }
195  FML_UNREACHABLE();
196 }

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 170 of file formats_gles.h.

170  {
171  switch (type) {
172  case TextureType::kTexture2D:
173  return GL_TEXTURE_2D;
174  case TextureType::kTexture2DMultisample:
175  return GL_TEXTURE_2D_MULTISAMPLE;
176  case TextureType::kTextureCube:
177  return GL_TEXTURE_CUBE_MAP;
178  case TextureType::kTextureExternalOES:
179  return GL_TEXTURE_EXTERNAL_OES;
180  }
181  FML_UNREACHABLE();
182 }

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 111 of file dl_dispatcher.cc.

111  {
112  switch (tile_mode) {
113  case flutter::DlTileMode::kClamp:
114  return Entity::TileMode::kClamp;
115  case flutter::DlTileMode::kRepeat:
116  return Entity::TileMode::kRepeat;
117  case flutter::DlTileMode::kMirror:
118  return Entity::TileMode::kMirror;
119  case flutter::DlTileMode::kDecal:
120  return Entity::TileMode::kDecal;
121  }
122 }

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 17 of file runtime_stage.cc.

17  {
18  switch (type) {
19  case fb::UniformDataType::kBoolean:
20  return RuntimeUniformType::kBoolean;
21  case fb::UniformDataType::kSignedByte:
22  return RuntimeUniformType::kSignedByte;
23  case fb::UniformDataType::kUnsignedByte:
24  return RuntimeUniformType::kUnsignedByte;
25  case fb::UniformDataType::kSignedShort:
26  return RuntimeUniformType::kSignedShort;
27  case fb::UniformDataType::kUnsignedShort:
28  return RuntimeUniformType::kUnsignedShort;
29  case fb::UniformDataType::kSignedInt:
30  return RuntimeUniformType::kSignedInt;
31  case fb::UniformDataType::kUnsignedInt:
32  return RuntimeUniformType::kUnsignedInt;
33  case fb::UniformDataType::kSignedInt64:
34  return RuntimeUniformType::kSignedInt64;
35  case fb::UniformDataType::kUnsignedInt64:
36  return RuntimeUniformType::kUnsignedInt64;
37  case fb::UniformDataType::kHalfFloat:
38  return RuntimeUniformType::kHalfFloat;
39  case fb::UniformDataType::kFloat:
40  return RuntimeUniformType::kFloat;
41  case fb::UniformDataType::kDouble:
42  return RuntimeUniformType::kDouble;
43  case fb::UniformDataType::kSampledImage:
44  return RuntimeUniformType::kSampledImage;
45  }
46  FML_UNREACHABLE();
47 }

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 185 of file shader_types.h.

185  {
186  return {color.red, color.green, color.blue, color.alpha};
187 }

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 139 of file formats_gles.h.

139  {
140  switch (type) {
141  case ShaderType::kSignedByte:
142  return GL_BYTE;
143  case ShaderType::kUnsignedByte:
144  return GL_UNSIGNED_BYTE;
145  case ShaderType::kSignedShort:
146  return GL_SHORT;
147  case ShaderType::kUnsignedShort:
148  return GL_UNSIGNED_SHORT;
149  case ShaderType::kFloat:
150  return GL_FLOAT;
151  case ShaderType::kUnknown:
152  case ShaderType::kVoid:
153  case ShaderType::kBoolean:
154  case ShaderType::kSignedInt:
155  case ShaderType::kUnsignedInt:
156  case ShaderType::kSignedInt64:
157  case ShaderType::kUnsignedInt64:
158  case ShaderType::kAtomicCounter:
159  case ShaderType::kHalfFloat:
160  case ShaderType::kDouble:
161  case ShaderType::kStruct:
162  case ShaderType::kImage:
163  case ShaderType::kSampledImage:
164  case ShaderType::kSampler:
165  return std::nullopt;
166  }
167  FML_UNREACHABLE();
168 }

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 11 of file vertex_descriptor_vk.cc.

11  {
12  if (input.columns != 1) {
13  // All matrix types are unsupported as vertex inputs.
14  return vk::Format::eUndefined;
15  }
16 
17  switch (input.type) {
18  case ShaderType::kFloat: {
19  if (input.bit_width == 8 * sizeof(float)) {
20  switch (input.vec_size) {
21  case 1:
22  return vk::Format::eR32Sfloat;
23  case 2:
24  return vk::Format::eR32G32Sfloat;
25  case 3:
26  return vk::Format::eR32G32B32Sfloat;
27  case 4:
28  return vk::Format::eR32G32B32A32Sfloat;
29  }
30  }
31  return vk::Format::eUndefined;
32  }
33  case ShaderType::kHalfFloat: {
34  if (input.bit_width == 8 * sizeof(float) / 2) {
35  switch (input.vec_size) {
36  case 1:
37  return vk::Format::eR16Sfloat;
38  case 2:
39  return vk::Format::eR16G16Sfloat;
40  case 3:
41  return vk::Format::eR16G16B16Sfloat;
42  case 4:
43  return vk::Format::eR16G16B16A16Sfloat;
44  }
45  }
46  return vk::Format::eUndefined;
47  }
48  case ShaderType::kDouble: {
49  // Unsupported.
50  return vk::Format::eUndefined;
51  }
52  case ShaderType::kBoolean: {
53  if (input.bit_width == 8 * sizeof(bool) && input.vec_size == 1) {
54  return vk::Format::eR8Uint;
55  }
56  return vk::Format::eUndefined;
57  }
58  case ShaderType::kSignedByte: {
59  if (input.bit_width == 8 * sizeof(char)) {
60  switch (input.vec_size) {
61  case 1:
62  return vk::Format::eR8Sint;
63  case 2:
64  return vk::Format::eR8G8Sint;
65  case 3:
66  return vk::Format::eR8G8B8Sint;
67  case 4:
68  return vk::Format::eR8G8B8A8Sint;
69  }
70  }
71  return vk::Format::eUndefined;
72  }
73  case ShaderType::kUnsignedByte: {
74  if (input.bit_width == 8 * sizeof(char)) {
75  switch (input.vec_size) {
76  case 1:
77  return vk::Format::eR8Uint;
78  case 2:
79  return vk::Format::eR8G8Uint;
80  case 3:
81  return vk::Format::eR8G8B8Uint;
82  case 4:
83  return vk::Format::eR8G8B8A8Uint;
84  }
85  }
86  return vk::Format::eUndefined;
87  }
88  case ShaderType::kSignedShort: {
89  if (input.bit_width == 8 * sizeof(int16_t)) {
90  switch (input.vec_size) {
91  case 1:
92  return vk::Format::eR16Sint;
93  case 2:
94  return vk::Format::eR16G16Sint;
95  case 3:
96  return vk::Format::eR16G16B16Sint;
97  case 4:
98  return vk::Format::eR16G16B16A16Sint;
99  }
100  }
101  return vk::Format::eUndefined;
102  }
103  case ShaderType::kUnsignedShort: {
104  if (input.bit_width == 8 * sizeof(uint16_t)) {
105  switch (input.vec_size) {
106  case 1:
107  return vk::Format::eR16Uint;
108  case 2:
109  return vk::Format::eR16G16Uint;
110  case 3:
111  return vk::Format::eR16G16B16Uint;
112  case 4:
113  return vk::Format::eR16G16B16A16Uint;
114  }
115  }
116  return vk::Format::eUndefined;
117  }
118  case ShaderType::kSignedInt: {
119  if (input.bit_width == 8 * sizeof(int32_t)) {
120  switch (input.vec_size) {
121  case 1:
122  return vk::Format::eR32Sint;
123  case 2:
124  return vk::Format::eR32G32Sint;
125  case 3:
126  return vk::Format::eR32G32B32Sint;
127  case 4:
128  return vk::Format::eR32G32B32A32Sint;
129  }
130  }
131  return vk::Format::eUndefined;
132  }
133  case ShaderType::kUnsignedInt: {
134  if (input.bit_width == 8 * sizeof(uint32_t)) {
135  switch (input.vec_size) {
136  case 1:
137  return vk::Format::eR32Uint;
138  case 2:
139  return vk::Format::eR32G32Uint;
140  case 3:
141  return vk::Format::eR32G32B32Uint;
142  case 4:
143  return vk::Format::eR32G32B32A32Uint;
144  }
145  }
146  return vk::Format::eUndefined;
147  }
148  case ShaderType::kSignedInt64: {
149  // Unsupported.
150  return vk::Format::eUndefined;
151  }
152  case ShaderType::kUnsignedInt64: {
153  // Unsupported.
154  return vk::Format::eUndefined;
155  }
156  case ShaderType::kAtomicCounter:
157  case ShaderType::kStruct:
158  case ShaderType::kImage:
159  case ShaderType::kSampledImage:
160  case ShaderType::kUnknown:
161  case ShaderType::kVoid:
162  case ShaderType::kSampler:
163  return vk::Format::eUndefined;
164  }
165 }

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 303 of file formats_vk.h.

303  {
304  switch (load_action) {
305  case LoadAction::kLoad:
306  return vk::AttachmentLoadOp::eLoad;
307  case LoadAction::kClear:
308  return vk::AttachmentLoadOp::eClear;
309  case LoadAction::kDontCare:
310  return vk::AttachmentLoadOp::eDontCare;
311  }
312 
313  FML_UNREACHABLE();
314 }

References kClear, kDontCare, and kLoad.

Referenced by CreateAttachmentDescription().

◆ ToVKAttachmentStoreOp()

constexpr vk::AttachmentStoreOp impeller::ToVKAttachmentStoreOp ( StoreAction  store_action)
constexpr

Definition at line 316 of file formats_vk.h.

317  {
318  switch (store_action) {
319  case StoreAction::kStore:
320  return vk::AttachmentStoreOp::eStore;
321  case StoreAction::kDontCare:
322  return vk::AttachmentStoreOp::eDontCare;
323  case StoreAction::kMultisampleResolve:
324  case StoreAction::kStoreAndMultisampleResolve:
325  return vk::AttachmentStoreOp::eDontCare;
326  }
327 
328  FML_UNREACHABLE();
329 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by CreateAttachmentDescription().

◆ ToVKBlendFactor()

constexpr vk::BlendFactor impeller::ToVKBlendFactor ( BlendFactor  factor)
constexpr

Definition at line 29 of file formats_vk.h.

29  {
30  switch (factor) {
31  case BlendFactor::kZero:
32  return vk::BlendFactor::eZero;
33  case BlendFactor::kOne:
34  return vk::BlendFactor::eOne;
35  case BlendFactor::kSourceColor:
36  return vk::BlendFactor::eSrcColor;
37  case BlendFactor::kOneMinusSourceColor:
38  return vk::BlendFactor::eOneMinusSrcColor;
39  case BlendFactor::kSourceAlpha:
40  return vk::BlendFactor::eSrcAlpha;
41  case BlendFactor::kOneMinusSourceAlpha:
42  return vk::BlendFactor::eOneMinusSrcAlpha;
43  case BlendFactor::kDestinationColor:
44  return vk::BlendFactor::eDstColor;
45  case BlendFactor::kOneMinusDestinationColor:
46  return vk::BlendFactor::eOneMinusDstColor;
47  case BlendFactor::kDestinationAlpha:
48  return vk::BlendFactor::eDstAlpha;
49  case BlendFactor::kOneMinusDestinationAlpha:
50  return vk::BlendFactor::eOneMinusDstAlpha;
51  case BlendFactor::kSourceAlphaSaturated:
52  return vk::BlendFactor::eSrcAlphaSaturate;
53  case BlendFactor::kBlendColor:
54  return vk::BlendFactor::eConstantColor;
55  case BlendFactor::kOneMinusBlendColor:
56  return vk::BlendFactor::eOneMinusConstantColor;
57  case BlendFactor::kBlendAlpha:
58  return vk::BlendFactor::eConstantAlpha;
59  case BlendFactor::kOneMinusBlendAlpha:
60  return vk::BlendFactor::eOneMinusConstantAlpha;
61  }
62  FML_UNREACHABLE();
63 }

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 65 of file formats_vk.h.

65  {
66  switch (op) {
67  case BlendOperation::kAdd:
68  return vk::BlendOp::eAdd;
69  case BlendOperation::kSubtract:
70  return vk::BlendOp::eSubtract;
71  case BlendOperation::kReverseSubtract:
72  return vk::BlendOp::eReverseSubtract;
73  }
74  FML_UNREACHABLE();
75 }

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ToVKPipelineColorBlendAttachmentState().

◆ ToVKBufferMemoryPropertyFlags()

static constexpr vk::Flags<vk::MemoryPropertyFlagBits> impeller::ToVKBufferMemoryPropertyFlags ( StorageMode  mode)
staticconstexpr

Definition at line 20 of file allocator_vk.cc.

20  {
21  switch (mode) {
22  case StorageMode::kHostVisible:
23  return vk::MemoryPropertyFlagBits::eHostVisible;
24  case StorageMode::kDevicePrivate:
25  return vk::MemoryPropertyFlagBits::eDeviceLocal;
26  case StorageMode::kDeviceTransient:
27  return vk::MemoryPropertyFlagBits::eLazilyAllocated;
28  }
29  FML_UNREACHABLE();
30 }

References kDevicePrivate, kDeviceTransient, and kHostVisible.

Referenced by CreateBufferPool().

◆ ToVKColorComponentFlags()

constexpr vk::ColorComponentFlags impeller::ToVKColorComponentFlags ( std::underlying_type_t< ColorWriteMask >  type)
constexpr

Definition at line 77 of file formats_vk.h.

78  {
79  using UnderlyingType = decltype(type);
80 
81  vk::ColorComponentFlags mask;
82 
83  if (type & static_cast<UnderlyingType>(ColorWriteMask::kRed)) {
84  mask |= vk::ColorComponentFlagBits::eR;
85  }
86 
87  if (type & static_cast<UnderlyingType>(ColorWriteMask::kGreen)) {
88  mask |= vk::ColorComponentFlagBits::eG;
89  }
90 
91  if (type & static_cast<UnderlyingType>(ColorWriteMask::kBlue)) {
92  mask |= vk::ColorComponentFlagBits::eB;
93  }
94 
95  if (type & static_cast<UnderlyingType>(ColorWriteMask::kAlpha)) {
96  mask |= vk::ColorComponentFlagBits::eA;
97  }
98 
99  return mask;
100 }

References kAlpha, kBlue, kGreen, and kRed.

Referenced by ToVKPipelineColorBlendAttachmentState().

◆ ToVKCompareOp()

constexpr vk::CompareOp impeller::ToVKCompareOp ( CompareFunction  op)
constexpr

Definition at line 508 of file formats_vk.h.

508  {
509  switch (op) {
510  case CompareFunction::kNever:
511  return vk::CompareOp::eNever;
512  case CompareFunction::kAlways:
513  return vk::CompareOp::eAlways;
514  case CompareFunction::kLess:
515  return vk::CompareOp::eLess;
516  case CompareFunction::kEqual:
517  return vk::CompareOp::eEqual;
518  case CompareFunction::kLessEqual:
519  return vk::CompareOp::eLessOrEqual;
520  case CompareFunction::kGreater:
521  return vk::CompareOp::eGreater;
522  case CompareFunction::kNotEqual:
523  return vk::CompareOp::eNotEqual;
524  case CompareFunction::kGreaterEqual:
525  return vk::CompareOp::eGreaterOrEqual;
526  }
527  FML_UNREACHABLE();
528 }

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 496 of file formats_vk.h.

496  {
497  switch (mode) {
498  case CullMode::kNone:
499  return vk::CullModeFlagBits::eNone;
500  case CullMode::kFrontFace:
501  return vk::CullModeFlagBits::eFront;
502  case CullMode::kBackFace:
503  return vk::CullModeFlagBits::eBack;
504  }
505  FML_UNREACHABLE();
506 }

References kBackFace, kFrontFace, and kNone.

◆ ToVKDescriptorSetLayoutBinding()

constexpr vk::DescriptorSetLayoutBinding impeller::ToVKDescriptorSetLayoutBinding ( const DescriptorSetLayout &  layout)
constexpr

Definition at line 293 of file formats_vk.h.

294  {
295  vk::DescriptorSetLayoutBinding binding;
296  binding.binding = layout.binding;
297  binding.descriptorCount = 1u;
298  binding.descriptorType = ToVKDescriptorType(layout.descriptor_type);
299  binding.stageFlags = ToVkShaderStage(layout.shader_stage);
300  return binding;
301 }

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 269 of file formats_vk.h.

269  {
270  switch (type) {
271  case DescriptorType::kSampledImage:
272  return vk::DescriptorType::eCombinedImageSampler;
273  break;
274  case DescriptorType::kUniformBuffer:
275  return vk::DescriptorType::eUniformBuffer;
276  break;
277  case DescriptorType::kStorageBuffer:
278  return vk::DescriptorType::eStorageBuffer;
279  break;
280  case DescriptorType::kImage:
281  return vk::DescriptorType::eSampledImage;
282  break;
283  case DescriptorType::kSampler:
284  return vk::DescriptorType::eSampler;
285  break;
286  case DescriptorType::kInputAttachment:
287  return vk::DescriptorType::eInputAttachment;
288  }
289 
290  FML_UNREACHABLE();
291 }

References kImage, kInputAttachment, kSampledImage, kSampler, kStorageBuffer, and kUniformBuffer.

Referenced by BindBuffers(), and ToVKDescriptorSetLayoutBinding().

◆ ToVKFrontFace()

constexpr vk::FrontFace impeller::ToVKFrontFace ( WindingOrder  order)
constexpr

Definition at line 163 of file pipeline_library_vk.cc.

163  {
164  switch (order) {
165  case WindingOrder::kClockwise:
166  return vk::FrontFace::eClockwise;
167  case WindingOrder::kCounterClockwise:
168  return vk::FrontFace::eCounterClockwise;
169  }
170  FML_UNREACHABLE();
171 }

References kClockwise, and kCounterClockwise.

◆ ToVKImageAspectFlags()

constexpr vk::ImageAspectFlags impeller::ToVKImageAspectFlags ( PixelFormat  format)
constexpr

Definition at line 568 of file formats_vk.h.

568  {
569  switch (format) {
570  case PixelFormat::kUnknown:
571  case PixelFormat::kA8UNormInt:
572  case PixelFormat::kR8UNormInt:
573  case PixelFormat::kR8G8UNormInt:
574  case PixelFormat::kR8G8B8A8UNormInt:
575  case PixelFormat::kR8G8B8A8UNormIntSRGB:
576  case PixelFormat::kB8G8R8A8UNormInt:
577  case PixelFormat::kB8G8R8A8UNormIntSRGB:
578  case PixelFormat::kR32G32B32A32Float:
579  case PixelFormat::kR16G16B16A16Float:
580  case PixelFormat::kB10G10R10XR:
581  case PixelFormat::kB10G10R10XRSRGB:
582  case PixelFormat::kB10G10R10A10XR:
583  return vk::ImageAspectFlagBits::eColor;
584  case PixelFormat::kS8UInt:
585  return vk::ImageAspectFlagBits::eStencil;
586  case PixelFormat::kD24UnormS8Uint:
587  case PixelFormat::kD32FloatS8UInt:
588  return vk::ImageAspectFlagBits::eDepth |
589  vk::ImageAspectFlagBits::eStencil;
590  }
591  FML_UNREACHABLE();
592 }

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 622 of file formats_vk.h.

622  {
623  switch (type) {
624  case TextureType::kTexture2D:
625  case TextureType::kTexture2DMultisample:
626  return {};
627  case TextureType::kTextureCube:
628  return vk::ImageCreateFlagBits::eCubeCompatible;
629  case TextureType::kTextureExternalOES:
630  VALIDATION_LOG
631  << "kTextureExternalOES can not be used with the Vulkan backend.";
632  }
633  FML_UNREACHABLE();
634 }

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,
bool  supports_framebuffer_fetch 
)
staticconstexpr

Definition at line 166 of file allocator_vk.cc.

171  {
172  vk::ImageUsageFlags vk_usage;
173 
174  switch (mode) {
175  case StorageMode::kHostVisible:
176  case StorageMode::kDevicePrivate:
177  break;
178  case StorageMode::kDeviceTransient:
179  if (supports_memoryless_textures) {
180  vk_usage |= vk::ImageUsageFlagBits::eTransientAttachment;
181  }
182  break;
183  }
184 
185  if (usage & static_cast<TextureUsageMask>(TextureUsage::kRenderTarget)) {
186  if (PixelFormatIsDepthStencil(format)) {
187  vk_usage |= vk::ImageUsageFlagBits::eDepthStencilAttachment;
188  } else {
189  vk_usage |= vk::ImageUsageFlagBits::eColorAttachment;
190  }
191  if (supports_framebuffer_fetch) {
192  vk_usage |= vk::ImageUsageFlagBits::eInputAttachment;
193  }
194  }
195 
196  if (usage & static_cast<TextureUsageMask>(TextureUsage::kShaderRead)) {
197  vk_usage |= vk::ImageUsageFlagBits::eSampled;
198  // Device transient images can only be used as attachments. The caller
199  // specified incorrect usage flags and is attempting to read a device
200  // transient image in a shader. Unset the transient attachment flag. See:
201  // https://github.com/flutter/flutter/issues/121633
202  if (mode == StorageMode::kDeviceTransient) {
203  vk_usage &= ~vk::ImageUsageFlagBits::eTransientAttachment;
204  }
205  }
206 
207  if (usage & static_cast<TextureUsageMask>(TextureUsage::kShaderWrite)) {
208  vk_usage |= vk::ImageUsageFlagBits::eStorage;
209  // Device transient images can only be used as attachments. The caller
210  // specified incorrect usage flags and is attempting to read a device
211  // transient image in a shader. Unset the transient attachment flag. See:
212  // https://github.com/flutter/flutter/issues/121633
213  if (mode == StorageMode::kDeviceTransient) {
214  vk_usage &= ~vk::ImageUsageFlagBits::eTransientAttachment;
215  }
216  }
217 
218  if (mode != StorageMode::kDeviceTransient) {
219  // Add transfer usage flags to support blit passes only if image isn't
220  // device transient.
221  vk_usage |= vk::ImageUsageFlagBits::eTransferSrc |
222  vk::ImageUsageFlagBits::eTransferDst;
223  }
224 
225  return vk_usage;
226 }

References PixelFormatIsDepthStencil().

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVKImageViewType()

constexpr vk::ImageViewType impeller::ToVKImageViewType ( TextureType  type)
constexpr

Definition at line 608 of file formats_vk.h.

608  {
609  switch (type) {
610  case TextureType::kTexture2D:
611  case TextureType::kTexture2DMultisample:
612  return vk::ImageViewType::e2D;
613  case TextureType::kTextureCube:
614  return vk::ImageViewType::eCube;
615  case TextureType::kTextureExternalOES:
616  VALIDATION_LOG
617  << "kTextureExternalOES can not be used with the Vulkan backend.";
618  }
619  FML_UNREACHABLE();
620 }

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 331 of file formats_vk.h.

331  {
332  switch (index_type) {
333  case IndexType::k16bit:
334  return vk::IndexType::eUint16;
335  case IndexType::k32bit:
336  return vk::IndexType::eUint32;
337  case IndexType::kUnknown:
338  return vk::IndexType::eUint32;
339  case IndexType::kNone:
340  FML_UNREACHABLE();
341  }
342 
343  FML_UNREACHABLE();
344 }

References k16bit, k32bit, kNone, and kUnknown.

◆ ToVKPipelineColorBlendAttachmentState()

constexpr vk::PipelineColorBlendAttachmentState impeller::ToVKPipelineColorBlendAttachmentState ( const ColorAttachmentDescriptor &  desc)
constexpr

Definition at line 103 of file formats_vk.h.

103  {
104  vk::PipelineColorBlendAttachmentState res;
105 
106  res.setBlendEnable(desc.blending_enabled);
107 
108  res.setSrcColorBlendFactor(ToVKBlendFactor(desc.src_color_blend_factor));
109  res.setColorBlendOp(ToVKBlendOp(desc.color_blend_op));
110  res.setDstColorBlendFactor(ToVKBlendFactor(desc.dst_color_blend_factor));
111 
112  res.setSrcAlphaBlendFactor(ToVKBlendFactor(desc.src_alpha_blend_factor));
113  res.setAlphaBlendOp(ToVKBlendOp(desc.alpha_blend_op));
114  res.setDstAlphaBlendFactor(ToVKBlendFactor(desc.dst_alpha_blend_factor));
115 
116  res.setColorWriteMask(ToVKColorComponentFlags(desc.write_mask));
117 
118  return res;
119 }

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 346 of file formats_vk.h.

346  {
347  switch (mode) {
348  case PolygonMode::kFill:
349  return vk::PolygonMode::eFill;
350  case PolygonMode::kLine:
351  return vk::PolygonMode::eLine;
352  }
353  FML_UNREACHABLE();
354 }

References kFill, and kLine.

◆ ToVKPrimitiveTopology()

constexpr vk::PrimitiveTopology impeller::ToVKPrimitiveTopology ( PrimitiveType  primitive)
constexpr

Definition at line 356 of file formats_vk.h.

356  {
357  switch (primitive) {
358  case PrimitiveType::kTriangle:
359  return vk::PrimitiveTopology::eTriangleList;
360  case PrimitiveType::kTriangleStrip:
361  return vk::PrimitiveTopology::eTriangleStrip;
362  case PrimitiveType::kLine:
363  return vk::PrimitiveTopology::eLineList;
364  case PrimitiveType::kLineStrip:
365  return vk::PrimitiveTopology::eLineStrip;
366  case PrimitiveType::kPoint:
367  return vk::PrimitiveTopology::ePointList;
368  }
369 
370  FML_UNREACHABLE();
371 }

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 19 of file formats_vk.h.

19  {
20  switch (count) {
21  case SampleCount::kCount1:
22  return vk::SampleCountFlagBits::e1;
23  case SampleCount::kCount4:
24  return vk::SampleCountFlagBits::e4;
25  }
26  FML_UNREACHABLE();
27 }

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::kCompute:
261  return vk::ShaderStageFlagBits::eCompute;
262  case ShaderStage::kVertex:
263  return vk::ShaderStageFlagBits::eVertex;
264  }
265 
266  FML_UNREACHABLE();
267 }

References kCompute, kFragment, kUnknown, and kVertex.

Referenced by ToVKDescriptorSetLayoutBinding().

◆ ToVKShaderStageFlagBits()

constexpr std::optional<vk::ShaderStageFlagBits> impeller::ToVKShaderStageFlagBits ( ShaderStage  stage)
constexpr

Definition at line 121 of file formats_vk.h.

122  {
123  switch (stage) {
124  case ShaderStage::kUnknown:
125  return std::nullopt;
126  case ShaderStage::kVertex:
127  return vk::ShaderStageFlagBits::eVertex;
128  case ShaderStage::kFragment:
129  return vk::ShaderStageFlagBits::eFragment;
130  case ShaderStage::kCompute:
131  return vk::ShaderStageFlagBits::eCompute;
132  }
133  FML_UNREACHABLE();
134 }

References kCompute, kFragment, kUnknown, and kVertex.

◆ ToVKStencilOp()

constexpr vk::StencilOp impeller::ToVKStencilOp ( StencilOperation  op)
constexpr

Definition at line 530 of file formats_vk.h.

530  {
531  switch (op) {
532  case StencilOperation::kKeep:
533  return vk::StencilOp::eKeep;
534  case StencilOperation::kZero:
535  return vk::StencilOp::eZero;
536  case StencilOperation::kSetToReferenceValue:
537  return vk::StencilOp::eReplace;
538  case StencilOperation::kIncrementClamp:
539  return vk::StencilOp::eIncrementAndClamp;
540  case StencilOperation::kDecrementClamp:
541  return vk::StencilOp::eDecrementAndClamp;
542  case StencilOperation::kInvert:
543  return vk::StencilOp::eInvert;
544  case StencilOperation::kIncrementWrap:
545  return vk::StencilOp::eIncrementAndWrap;
546  case StencilOperation::kDecrementWrap:
547  return vk::StencilOp::eDecrementAndWrap;
548  break;
549  }
550  FML_UNREACHABLE();
551 }

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 553 of file formats_vk.h.

554  {
555  vk::StencilOpState state;
556  state.failOp = ToVKStencilOp(desc.stencil_failure);
557  state.passOp = ToVKStencilOp(desc.depth_stencil_pass);
558  state.depthFailOp = ToVKStencilOp(desc.depth_failure);
559  state.compareOp = ToVKCompareOp(desc.stencil_compare);
560  state.compareMask = desc.read_mask;
561  state.writeMask = desc.write_mask;
562  // This is irrelevant as the stencil references are always dynamic state and
563  // will be set in the render pass.
564  state.reference = 1988;
565  return state;
566 }

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 233 of file allocator_vk.cc.

234  {
235  switch (mode) {
236  case StorageMode::kHostVisible:
237  return vk::MemoryPropertyFlagBits::eHostVisible |
238  vk::MemoryPropertyFlagBits::eDeviceLocal;
239  case StorageMode::kDevicePrivate:
240  return vk::MemoryPropertyFlagBits::eDeviceLocal;
241  case StorageMode::kDeviceTransient:
242  if (supports_memoryless_textures) {
243  return vk::MemoryPropertyFlagBits::eLazilyAllocated |
244  vk::MemoryPropertyFlagBits::eDeviceLocal;
245  }
246  return vk::MemoryPropertyFlagBits::eDeviceLocal;
247  }
248  FML_UNREACHABLE();
249 }

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVmaAllocationBufferCreateFlags()

static VmaAllocationCreateFlags impeller::ToVmaAllocationBufferCreateFlags ( StorageMode  mode)
static

Definition at line 32 of file allocator_vk.cc.

33  {
34  VmaAllocationCreateFlags flags = 0;
35  switch (mode) {
36  case StorageMode::kHostVisible:
37  flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
38  flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
39  return flags;
40  case StorageMode::kDevicePrivate:
41  return flags;
42  case StorageMode::kDeviceTransient:
43  return flags;
44  }
45  FML_UNREACHABLE();
46 }

References kDevicePrivate, kDeviceTransient, and kHostVisible.

Referenced by CreateBufferPool().

◆ ToVmaAllocationCreateFlags()

static VmaAllocationCreateFlags impeller::ToVmaAllocationCreateFlags ( StorageMode  mode)
static

Definition at line 251 of file allocator_vk.cc.

251  {
252  VmaAllocationCreateFlags flags = 0;
253  switch (mode) {
254  case StorageMode::kHostVisible:
255  return flags;
256  case StorageMode::kDevicePrivate:
257  return flags;
258  case StorageMode::kDeviceTransient:
259  return flags;
260  }
261  FML_UNREACHABLE();
262 }

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK().

◆ ToVMAMemoryUsage()

static constexpr VmaMemoryUsage impeller::ToVMAMemoryUsage ( )
staticconstexpr

Definition at line 228 of file allocator_vk.cc.

228  {
229  return VMA_MEMORY_USAGE_AUTO;
230 }

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 272 of file typographer_context_stb.cc.

274  {
275  TRACE_EVENT0("impeller", __FUNCTION__);
276  FML_DCHECK(bitmap != nullptr);
277 
278  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
279 
280  for (const FontGlyphPair& pair : new_pairs) {
281  auto pos = atlas.FindFontGlyphBounds(pair);
282  if (!pos.has_value()) {
283  continue;
284  }
285  DrawGlyph(bitmap.get(), pair.scaled_font, pair.glyph, pos.value(),
286  has_color);
287  }
288  return true;
289 }

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 36 of file compute_pass_vk.cc.

37  {
38  BarrierVK barrier;
39  barrier.cmd_buffer = buffer;
40  barrier.src_access = vk::AccessFlagBits::eTransferWrite;
41  barrier.src_stage = vk::PipelineStageFlagBits::eTransfer;
42  barrier.dst_access = vk::AccessFlagBits::eShaderRead;
43  barrier.dst_stage = vk::PipelineStageFlagBits::eComputeShader;
44 
45  barrier.new_layout = vk::ImageLayout::eShaderReadOnlyOptimal;
46 
47  for (const TextureAndSampler& data : bindings.sampled_images) {
48  if (!TextureVK::Cast(*data.texture.resource).SetLayout(barrier)) {
49  return false;
50  }
51  }
52  return true;
53 }

References impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::BarrierVK::cmd_buffer, impeller::BarrierVK::dst_access, impeller::BarrierVK::dst_stage, impeller::BarrierVK::new_layout, impeller::Resource< T >::resource, impeller::Bindings::sampled_images, impeller::TextureVK::SetLayout(), impeller::BarrierVK::src_access, impeller::BarrierVK::src_stage, and impeller::TextureAndSampler::texture.

Referenced by UpdateBindingLayouts().

◆ UpdateBindingLayouts() [2/6]

static bool impeller::UpdateBindingLayouts ( const Bindings &  bindings,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 304 of file render_pass_vk.cc.

305  {
306  // All previous writes via a render or blit pass must be done before another
307  // shader attempts to read the resource.
308  BarrierVK barrier;
309  barrier.cmd_buffer = buffer;
310  barrier.src_access = vk::AccessFlagBits::eColorAttachmentWrite |
311  vk::AccessFlagBits::eTransferWrite;
312  barrier.src_stage = vk::PipelineStageFlagBits::eColorAttachmentOutput |
313  vk::PipelineStageFlagBits::eTransfer;
314  barrier.dst_access = vk::AccessFlagBits::eShaderRead;
315  barrier.dst_stage = vk::PipelineStageFlagBits::eFragmentShader;
316 
317  barrier.new_layout = vk::ImageLayout::eShaderReadOnlyOptimal;
318 
319  for (const TextureAndSampler& data : bindings.sampled_images) {
320  if (!TextureVK::Cast(*data.texture.resource).SetLayout(barrier)) {
321  return false;
322  }
323  }
324  return true;
325 }

References impeller::BarrierVK::cmd_buffer, impeller::BarrierVK::dst_access, impeller::BarrierVK::dst_stage, impeller::BarrierVK::new_layout, impeller::Resource< T >::resource, impeller::Bindings::sampled_images, impeller::BarrierVK::src_access, impeller::BarrierVK::src_stage, and impeller::TextureAndSampler::texture.

◆ UpdateBindingLayouts() [3/6]

static bool impeller::UpdateBindingLayouts ( const Command &  command,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 327 of file render_pass_vk.cc.

328  {
329  return UpdateBindingLayouts(command.vertex_bindings, buffer) &&
330  UpdateBindingLayouts(command.fragment_bindings, buffer);
331 }

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 55 of file compute_pass_vk.cc.

56  {
57  return UpdateBindingLayouts(command.bindings, buffer);
58 }

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 333 of file render_pass_vk.cc.

334  {
335  for (const Command& command : commands) {
336  if (!UpdateBindingLayouts(command, buffer)) {
337  return false;
338  }
339  }
340  return true;
341 }

Referenced by UpdateBindingLayouts().

◆ UpdateBindingLayouts() [6/6]

static bool impeller::UpdateBindingLayouts ( const std::vector< ComputeCommand > &  commands,
const vk::CommandBuffer &  buffer 
)
static

Definition at line 60 of file compute_pass_vk.cc.

61  {
62  for (const ComputeCommand& command : commands) {
63  if (!UpdateBindingLayouts(command, buffer)) {
64  return false;
65  }
66  }
67  return true;
68 }

References UpdateBindingLayouts().

◆ UpdateGlyphTextureAtlas() [1/2]

static bool impeller::UpdateGlyphTextureAtlas ( std::shared_ptr< BitmapSTB > &  bitmap,
const std::shared_ptr< Texture > &  texture 
)
static

Definition at line 316 of file typographer_context_stb.cc.

317  {
318  TRACE_EVENT0("impeller", __FUNCTION__);
319 
320  FML_DCHECK(bitmap != nullptr);
321 
322  auto texture_descriptor = texture->GetTextureDescriptor();
323 
324  auto mapping = std::make_shared<fml::NonOwnedMapping>(
325  reinterpret_cast<const uint8_t*>(bitmap->GetPixels()), // data
326  texture_descriptor.GetByteSizeOfBaseMipLevel() // size
327  // As the bitmap is static in this module I believe we don't need to
328  // specify a release proc.
329  );
330 
331  return texture->SetContents(mapping);
332 }

◆ 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 334 of file typographer_context_stb.cc.

338  {
339  TRACE_EVENT0("impeller", __FUNCTION__);
340  if (!allocator) {
341  return nullptr;
342  }
343 
344  FML_DCHECK(bitmap != nullptr);
345 
346  TextureDescriptor texture_descriptor;
347  texture_descriptor.storage_mode = StorageMode::kHostVisible;
348  texture_descriptor.format = format;
349  texture_descriptor.size = atlas_size;
350 
351  if (bitmap->GetRowBytes() * bitmap->GetHeight() !=
352  texture_descriptor.GetByteSizeOfBaseMipLevel()) {
353  return nullptr;
354  }
355 
356  auto texture = allocator->CreateTexture(texture_descriptor);
357  if (!texture || !texture->IsValid()) {
358  return nullptr;
359  }
360  texture->SetLabel("GlyphAtlas");
361 
362  auto mapping = std::make_shared<fml::NonOwnedMapping>(
363  reinterpret_cast<const uint8_t*>(bitmap->GetPixels()), // data
364  texture_descriptor.GetByteSizeOfBaseMipLevel() // size
365  // As the bitmap is static in this module I believe we don't need to
366  // specify a release proc.
367  );
368 
369  if (!texture->SetContents(mapping)) {
370  return nullptr;
371  }
372  return texture;
373 }

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 729 of file canvas.cc.

731  {
732  // If there are no vertex color or texture coordinates. Or if there
733  // are vertex coordinates then only if the contents are an image or
734  // a solid color.
735  if (vertices->HasVertexColors()) {
736  return false;
737  }
738  if (vertices->HasTextureCoordinates() &&
739  (paint.color_source.GetType() == ColorSource::Type::kImage ||
740  paint.color_source.GetType() == ColorSource::Type::kColor)) {
741  return true;
742  }
743  return !vertices->HasTextureCoordinates();
744 }

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 216 of file render_pass_vk.cc.

216  {
217  vk::ClearColorValue value;
218  value.setFloat32(
219  std::array<float, 4>{color.red, color.green, color.blue, color.alpha});
220  return value;
221 }

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 223 of file render_pass_vk.cc.

224  {
225  vk::ClearDepthStencilValue value;
226  value.depth = depth;
227  value.stencil = stencil;
228  return value;
229 }

Referenced by GetVKClearValues().

◆ VKShaderNameToShaderKeyName()

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

Definition at line 30 of file shader_library_vk.cc.

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

References kCompute, kFragment, kUnknown, and kVertex.

◆ WrappedResolver()

ProcTableGLES::Resolver impeller::WrappedResolver ( const ProcTableGLES::Resolver &  resolver)

Definition at line 52 of file proc_table_gles.cc.

53  {
54  return [resolver](const char* function_name) -> void* {
55  auto resolved = resolver(function_name);
56  if (resolved) {
57  return resolved;
58  }
59  // If there are certain known suffixes (usually for extensions), strip them
60  // out and try to resolve the same proc addresses again.
61  auto function = std::string{function_name};
62  if (function.find("KHR", function.size() - 3) != std::string::npos) {
63  auto truncated = function.substr(0u, function.size() - 3);
64  return resolver(truncated.c_str());
65  }
66  if (function.find("EXT", function.size() - 3) != std::string::npos) {
67  auto truncated = function.substr(0u, function.size() - 3);
68  return resolver(truncated.c_str());
69  }
70  return nullptr;
71  };
72 }

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 13 of file texture_mtl.mm.

15  {
16  return TextureMTL::Wrapper(desc, (__bridge id<MTLTexture>)mtl_texture,
17  std::move(deletion_proc));
18 }

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->GetWidth(), clip_rect->GetHeight());
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 = TextureMTL::Create(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::TextureMTL::Create(), 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 136 of file command_pool_vk.cc.

Referenced by impeller::CommandPoolRecyclerVK::DestroyThreadLocalPools(), and impeller::CommandPoolRecyclerVK::Get().

◆ gHasValidationLayers

bool impeller::gHasValidationLayers = false
static

Definition at line 41 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 38 of file constants.h.

◆ k1OverSqrt2

constexpr float impeller::k1OverSqrt2 = 0.70710678118654752440f
constexpr

Definition at line 50 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 41 of file constants.h.

◆ k2OverSqrtPi

constexpr float impeller::k2OverSqrtPi = 1.12837916709551257390f
constexpr

Definition at line 44 of file constants.h.

◆ k2Pi

constexpr float impeller::k2Pi = 6.28318530717958647693f
constexpr

Definition at line 29 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 19 of file paint.cc.

Referenced by impeller::Paint::GetColorFilter().

◆ kDefaultCurveTolerance

constexpr Scalar impeller::kDefaultCurveTolerance = .1f
staticconstexpr

Definition at line 26 of file path_component.h.

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

◆ kE

constexpr float impeller::kE = 2.7182818284590452354f
constexpr

Definition at line 11 of file constants.h.

◆ kEhCloseEnough

constexpr float impeller::kEhCloseEnough = 1e-3f
constexpr

Definition at line 56 of file constants.h.

Referenced by impeller::Color::Blend(), ClipColor(), impeller::VerticesGeometry::GetPositionUVBuffer(), impeller::SolidRRectBlurContents::Render(), impeller::TextureContents::RenderToSnapshot(), impeller::Tessellator::RoundCapLine(), and impeller::testing::TEST().

◆ kElementsWindowName

const char* impeller::kElementsWindowName = "Elements"
static

Definition at line 17 of file aiks_playground_inspector.cc.

◆ kEmptyResult

const GeometryResult impeller::kEmptyResult
static
Initial value:
= {
.vertex_buffer =
{
.index_type = IndexType::kNone,
},
}

Definition at line 27 of file geometry.h.

◆ kFramebufferFetchExt

const constexpr char* impeller::kFramebufferFetchExt
staticconstexpr
Initial value:
=
"GL_EXT_shader_framebuffer_fetch"

Definition at line 12 of file capabilities_gles.cc.

Referenced by impeller::CapabilitiesGLES::CapabilitiesGLES().

◆ kImageSizeThresholdForDedicatedMemoryAllocation

constexpr size_t impeller::kImageSizeThresholdForDedicatedMemoryAllocation
constexpr
Initial value:
=
4 * 1024 * 1024

Definition at line 12 of file limits_vk.h.

◆ kInstanceLayer

constexpr const char* impeller::kInstanceLayer = "ImpellerInstance"
staticconstexpr

Definition at line 16 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 24 of file sigma.h.

Referenced by impeller::Sigma::operator Radius(), and impeller::Radius::operator Sigma().

◆ kLog10E

constexpr float impeller::kLog10E = 0.43429448190325182765f
constexpr

Definition at line 17 of file constants.h.

◆ kLog2E

constexpr float impeller::kLog2E = 1.4426950408889634074f
constexpr

Definition at line 14 of file constants.h.

◆ kLogE10

constexpr float impeller::kLogE10 = 2.30258509299404568402f
constexpr

Definition at line 23 of file constants.h.

◆ kLogE2

constexpr float impeller::kLogE2 = 0.69314718055994530942f
constexpr

Definition at line 20 of file constants.h.

◆ kMagicSubpassInputBinding

constexpr size_t impeller::kMagicSubpassInputBinding = 64
staticconstexpr

Definition at line 24 of file binding_helpers_vk.cc.

Referenced by AllocateAndBindDescriptorSets().

◆ 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 21 of file swapchain_impl_vk.cc.

◆ kMultisampledRenderToTextureExt

const constexpr char* impeller::kMultisampledRenderToTextureExt
staticconstexpr
Initial value:
=
"GL_EXT_multisampled_render_to_texture"

Definition at line 21 of file capabilities_gles.cc.

Referenced by impeller::CapabilitiesGLES::CapabilitiesGLES().

◆ kNvidiaTextureBorderClampExt

const constexpr char* impeller::kNvidiaTextureBorderClampExt
staticconstexpr
Initial value:
=
"GL_NV_texture_border_clamp"

Definition at line 17 of file capabilities_gles.cc.

Referenced by impeller::CapabilitiesGLES::CapabilitiesGLES().

◆ 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 53 of file constants.h.

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

◆ kPi

constexpr float impeller::kPi = 3.14159265358979323846f
constexpr

Definition at line 26 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 32 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 35 of file constants.h.

Referenced by ComputeQuadrantDivisions(), 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 26 of file swapchain_impl_vk.cc.

Referenced by impeller::SwapchainImplVK::AcquireNextDrawable().

◆ kPoolSize

constexpr uint32_t impeller::kPoolSize = 1024u
staticconstexpr

Definition at line 19 of file gpu_tracer_vk.cc.

◆ 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 15 of file blend_filter_contents.h.

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

◆ kPrecomputedDivisionCount

constexpr int impeller::kPrecomputedDivisionCount = 1024
staticconstexpr

Definition at line 227 of file tessellator.cc.

Referenced by ComputeQuadrantDivisions().

◆ kPrecomputedDivisions

int impeller::kPrecomputedDivisions[kPrecomputedDivisionCount]
static

Definition at line 228 of file tessellator.cc.

Referenced by ComputeQuadrantDivisions().

◆ 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.

◆ 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 47 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().

◆ kTextureBorderClampExt

const constexpr char* impeller::kTextureBorderClampExt
staticconstexpr
Initial value:
=
"GL_EXT_texture_border_clamp"

Definition at line 15 of file capabilities_gles.cc.

Referenced by impeller::CapabilitiesGLES::CapabilitiesGLES().

◆ kUnusedAttachmentReference

constexpr vk::AttachmentReference impeller::kUnusedAttachmentReference
staticconstexpr
Initial value:
= {
VK_ATTACHMENT_UNUSED, vk::ImageLayout::eUndefined}

Definition at line 493 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 23 of file geometry_benchmarks.cc.

Referenced by BM_Convex(), and BM_Polyline().

◆ tls_command_pool_map

FML_THREAD_LOCAL fml::ThreadLocalUniquePtr<CommandPoolMap> impeller::tls_command_pool_map

Definition at line 132 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:22
impeller::StoreAction::kMultisampleResolve
@ kMultisampleResolve
impeller::PixelFormat::kS8UInt
@ kS8UInt
impeller::TextureType::kTextureExternalOES
@ kTextureExternalOES
impeller::BlendSelectValues::kSaturation
@ kSaturation
impeller::kBoolean
@ kBoolean
Definition: runtime_types.h:22
impeller::kFloat
@ kFloat
Definition: runtime_types.h:32
impeller::kResetTransform
@ kResetTransform
Definition: canvas_recorder.h:25
impeller::DeepComparePointer
bool DeepComparePointer(const std::shared_ptr< ComparableType > &lhs, const std::shared_ptr< ComparableType > &rhs)
Definition: comparable.h:57
impeller::OptionsFromPass
ContentContextOptions OptionsFromPass(const RenderPass &pass)
Definition: contents.cc:20
DEBUG_COMMAND_INFO
#define DEBUG_COMMAND_INFO(obj, arg)
Definition: command.h:28
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:343
impeller::GetShaderType
static ShaderType GetShaderType(RuntimeUniformType type)
Definition: runtime_effect_contents.cc:44
impeller::kPreConcat
@ kPreConcat
Definition: canvas_recorder.h:28
impeller::kDrawImage
@ kDrawImage
Definition: canvas_recorder.h:40
impeller::CompareFunction::kGreater
@ kGreater
Comparison test passes if new_value > current_value.
impeller::PrimitiveType::kLineStrip
@ kLineStrip
impeller::LoadAction::kLoad
@ kLoad
impeller::ToMTLColorWriteMask
constexpr MTLColorWriteMask ToMTLColorWriteMask(std::underlying_type_t< ColorWriteMask > type)
Definition: formats_mtl.h:210
impeller::VKClearValueFromDepthStencil
static vk::ClearDepthStencilValue VKClearValueFromDepthStencil(uint32_t stencil, Scalar depth)
Definition: render_pass_vk.cc:223
impeller::HandleType::kRenderBuffer
@ kRenderBuffer
impeller::ConfigureStencil
void ConfigureStencil(const ProcTableGLES &gl, const PipelineDescriptor &pipeline, uint32_t stencil_reference)
Definition: render_pass_gles.cc:96
impeller::BlendModeToString
const char * BlendModeToString(BlendMode blend_mode)
Definition: color.cc:47
impeller::kClipPath
@ kClipPath
Definition: canvas_recorder.h:42
impeller::BlendMode::kDestinationATop
@ kDestinationATop
impeller::PixelFormatIsDepthStencil
constexpr bool PixelFormatIsDepthStencil(PixelFormat format)
Definition: formats_vk.h:373
impeller::StencilOperation::kDecrementClamp
@ kDecrementClamp
Decrement the current stencil value by 1. Clamp it to zero.
impeller::ColorWriteMask
ColorWriteMask
Definition: formats.h:433
impeller::gHasValidationLayers
static bool gHasValidationLayers
Definition: context_vk.cc:41
impeller::StoreAction::kStoreAndMultisampleResolve
@ kStoreAndMultisampleResolve
impeller::ColorToString
std::string ColorToString(const Color &color)
Definition: color.cc:398
impeller::TextureUsageMask
uint64_t TextureUsageMask
Definition: formats.h:295
impeller::ShaderType::kAtomicCounter
@ kAtomicCounter
impeller::ConfigureColorAttachment
static bool ConfigureColorAttachment(const ColorAttachment &desc, MTLRenderPassColorAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:72
impeller::ToVmaAllocationBufferCreateFlags
static VmaAllocationCreateFlags ToVmaAllocationBufferCreateFlags(StorageMode mode)
Definition: allocator_vk.cc:32
impeller::IndexType::k16bit
@ k16bit
impeller::PixelFormatToString
constexpr const char * PixelFormatToString(PixelFormat format)
Definition: formats.h:135
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::BlendSelectValues::kColorBurn
@ kColorBurn
impeller::Font
Describes a typeface along with any modifications to its intrinsic properties.
Definition: font.h:22
impeller::BlendSelectValues::kMultiply
@ kMultiply
impeller::kUnsignedShort
@ kUnsignedShort
Definition: runtime_types.h:26
impeller::DeviceSupportsComputeSubgroups
static bool DeviceSupportsComputeSubgroups(id< MTLDevice > device)
Definition: context_mtl.mm:43
impeller::PixelFormat::kB10G10R10A10XR
@ kB10G10R10A10XR
impeller::PixelFormat::kB8G8R8A8UNormIntSRGB
@ kB8G8R8A8UNormIntSRGB
impeller::ConfigureStencilAttachment
static bool ConfigureStencilAttachment(const StencilAttachment &desc, MTLRenderPassStencilAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:92
impeller::kConcat
@ kConcat
Definition: canvas_recorder.h:27
impeller::SafeMTLPixelFormatBGRA10_XR
MTLPixelFormat SafeMTLPixelFormatBGRA10_XR()
Definition: formats_mtl.mm:138
impeller::PixelFormat::kA8UNormInt
@ kA8UNormInt
impeller::ToVKBlendFactor
constexpr vk::BlendFactor ToVKBlendFactor(BlendFactor factor)
Definition: formats_vk.h:29
impeller::kDrawPicture
@ kDrawPicture
Definition: canvas_recorder.h:45
impeller::DeleteFBO
static void DeleteFBO(const ProcTableGLES &gl, GLuint fbo, GLenum type)
Definition: blit_command_gles.cc:16
impeller::BlendFactor::kSourceAlphaSaturated
@ kSourceAlphaSaturated
impeller::ReportPipelineCreationFeedbackToTrace
static void ReportPipelineCreationFeedbackToTrace(const PipelineDescriptor &desc, const vk::PipelineCreationFeedbackCreateInfoEXT &feedback)
Definition: pipeline_library_vk.cc:224
impeller::FillType::kOdd
@ kOdd
impeller::NearZero
static bool NearZero(Scalar a)
Definition: path_component.cc:249
impeller::compiler::SourceType::kUnknown
@ kUnknown
impeller::PixelFormat::kR8UNormInt
@ kR8UNormInt
impeller::HeapRealloc
static void * HeapRealloc(void *userData, void *ptr, unsigned int size)
Definition: tessellator.cc:15
impeller::ReportPipelineCreationFeedbackToLog
static void ReportPipelineCreationFeedbackToLog(const PipelineDescriptor &desc, const vk::PipelineCreationFeedbackCreateInfoEXT &feedback)
Definition: pipeline_library_vk.cc:199
impeller::ToImageFilter
static std::shared_ptr< ImageFilter > ToImageFilter(const flutter::DlImageFilter *filter)
Definition: dl_dispatcher.cc:525
impeller::CompareFunction::kEqual
@ kEqual
Comparison test passes if new_value == current_value.
impeller::ToVKDescriptorType
constexpr vk::DescriptorType ToVKDescriptorType(DescriptorType type)
Definition: formats_vk.h:269
impeller::BlendFactor::kOneMinusSourceAlpha
@ kOneMinusSourceAlpha
impeller::kEhCloseEnough
constexpr float kEhCloseEnough
Definition: constants.h:56
impeller::CompareFunction::kGreaterEqual
@ kGreaterEqual
Comparison test passes if new_value >= current_value.
impeller::ToBlendFactor
constexpr GLenum ToBlendFactor(BlendFactor factor)
Definition: formats_gles.h:91
impeller::ToMTLStencilOperation
constexpr MTLStencilOperation ToMTLStencilOperation(StencilOperation op)
Definition: formats_mtl.h:257
impeller::StencilOperation::kKeep
@ kKeep
Don't modify the current stencil value.
impeller::TextureDescriptor::format
PixelFormat format
Definition: texture_descriptor.h:40
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:210
impeller::BlendMode::kSource
@ kSource
impeller::PixelFormat::kR8G8B8A8UNormInt
@ kR8G8B8A8UNormInt
impeller::BlendMode::kDestination
@ kDestination
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:61
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:55
impeller::FillType::kAbsGeqTwo
@ kAbsGeqTwo
impeller::HasSuitableDepthStencilFormat
static bool HasSuitableDepthStencilFormat(const vk::PhysicalDevice &device, vk::Format format)
Definition: capabilities_vk.cc:249
impeller::kRotate
@ kRotate
Definition: canvas_recorder.h:33
impeller::PointStyle::kRound
@ kRound
Points are drawn as squares.
impeller::kSignedByte
@ kSignedByte
Definition: runtime_types.h:23
impeller::TextureDescriptor::mip_count
size_t mip_count
Definition: texture_descriptor.h:42
impeller::StencilOperation::kIncrementClamp
@ kIncrementClamp
Increment the current stencil value by 1. Clamp it to the maximum.
impeller::ShaderType::kImage
@ kImage
impeller::ColorWriteMask::kRed
@ kRed
impeller::tess
static Tessellator tess
Definition: geometry_benchmarks.cc:23
impeller::MTLCommandBufferErrorToString
static NSString * MTLCommandBufferErrorToString(MTLCommandBufferError code)
Definition: command_buffer_mtl.mm:36
impeller::Color::alpha
Scalar alpha
Definition: color.h:143
impeller::TextureUsage::kRenderTarget
@ kRenderTarget
impeller::BlendMode::kDestinationOver
@ kDestinationOver
impeller::BlendMode::kPlus
@ kPlus
impeller::BlendSelectValues::kSoftLight
@ kSoftLight
impeller::kSampledImage
@ kSampledImage
Definition: runtime_types.h:34
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:148
impeller::TextureDescriptorToString
std::string TextureDescriptorToString(const TextureDescriptor &desc)
Definition: texture_descriptor.cc:11
impeller::StencilOperation::kInvert
@ kInvert
Perform a logical bitwise invert on the current stencil value.
impeller::ShaderType::kVoid
@ kVoid
impeller::WindingOrder::kClockwise
@ kClockwise
impeller::SamplerAddressMode::kClampToEdge
@ kClampToEdge
impeller::BlendFactor::kDestinationAlpha
@ kDestinationAlpha
impeller::ToMTLStoreAction
constexpr MTLStoreAction ToMTLStoreAction(StoreAction action)
Definition: formats_mtl.h:307
impeller::BlendSelectValues::kDifference
@ kDifference
impeller::IndexType::k32bit
@ k32bit
impeller::StorageMode::kHostVisible
@ kHostVisible
impeller::OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback
@ kEXTPipelineCreationFeedback
impeller::ToMTLCompareFunction
constexpr MTLCompareFunction ToMTLCompareFunction(CompareFunction func)
Definition: formats_mtl.h:235
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:49
impeller::GetShaderSource
static std::string GetShaderSource(const ProcTableGLES &gl, GLuint shader)
Definition: pipeline_library_gles.cc:36
impeller::Cap::kButt
@ kButt
impeller::OptionalDeviceExtensionVK::kARMRasterizationOrderAttachmentAccess
@ kARMRasterizationOrderAttachmentAccess
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:99
impeller::kSave
@ kSave
Definition: canvas_recorder.h:21
impeller::ToVKStencilOpState
constexpr vk::StencilOpState ToVKStencilOpState(const StencilAttachmentDescriptor &desc)
Definition: formats_vk.h:553
impeller::NormalizeUniformKey
static std::string NormalizeUniformKey(const std::string &key)
Definition: buffer_bindings_gles.cc:51
impeller::AttachmentKind::kDepthStencil
@ kDepthStencil
impeller::ToMTLClearColor
MTLClearColor ToMTLClearColor(const Color &color)
Definition: formats_mtl.h:372
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: dl_dispatcher.cc:36
impeller::ToTileMode
static Entity::TileMode ToTileMode(flutter::DlTileMode tile_mode)
Definition: dl_dispatcher.cc:111
impeller::BlendMode::kModulate
@ kModulate
impeller::PolygonMode::kFill
@ kFill
impeller::StencilOperation::kSetToReferenceValue
@ kSetToReferenceValue
Reset the stencil value to the reference value.
impeller::FillType::kPositive
@ kPositive
impeller::ToVKCompareOp
constexpr vk::CompareOp ToVKCompareOp(CompareFunction op)
Definition: formats_vk.h:508
impeller::Join::kMiter
@ kMiter
impeller::BlendFactor::kSourceColor
@ kSourceColor
impeller::PixelFormat::kD32FloatS8UInt
@ kD32FloatS8UInt
impeller::BlendMode::kSourceOut
@ kSourceOut
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::RuntimeShaderStage::kVertex
@ kVertex
impeller::PrimitiveType::kLine
@ kLine
impeller::BlendFactor::kDestinationColor
@ kDestinationColor
impeller::kDrawCircle
@ kDrawCircle
Definition: canvas_recorder.h:38
impeller::CreateAttachmentDescription
constexpr vk::AttachmentDescription CreateAttachmentDescription(PixelFormat format, SampleCount sample_count, LoadAction load_action, StoreAction store_action, vk::ImageLayout current_layout, bool supports_framebuffer_fetch)
Definition: formats_vk.h:429
IPLR_ACQUIRE
#define IPLR_ACQUIRE(...)
Definition: thread_safety.h:36
impeller::ToMatrix
static Matrix ToMatrix(const SkMatrix &m)
Definition: dl_dispatcher.cc:166
impeller::BlendSelectValues::kDarken
@ kDarken
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:530
impeller::SamplerDescriptor::mag_filter
MinMagFilter mag_filter
Definition: sampler_descriptor.h:17
impeller::TextureCoordinateSystem::kUploadFromHost
@ kUploadFromHost
impeller::SamplerDescriptor
Definition: sampler_descriptor.h:15
impeller::kColor
@ kColor
Definition: geometry.h:36
impeller::PrimitiveType::kTriangle
@ kTriangle
impeller::UpdateBindingLayouts
static bool UpdateBindingLayouts(const std::vector< ComputeCommand > &commands, const vk::CommandBuffer &buffer)
Definition: compute_pass_vk.cc:60
impeller::BlendSelectValues::kExclusion
@ kExclusion
impeller::BlendFactor::kZero
@ kZero
impeller::TextureType::kTexture2DMultisample
@ kTexture2DMultisample
impeller::ConfigureDepthAttachment
static bool ConfigureDepthAttachment(const DepthAttachment &desc, MTLRenderPassDepthAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:82
impeller::TextureCoordinateSystem::kRenderToTexture
@ kRenderToTexture
impeller::ToSamplerDescriptor
static impeller::SamplerDescriptor ToSamplerDescriptor(const flutter::DlFilterMode options)
Definition: dl_dispatcher.cc:148
impeller::kDrawTextFrame
@ kDrawTextFrame
Definition: canvas_recorder.h:46
impeller::kSignedInt
@ kSignedInt
Definition: runtime_types.h:27
impeller::ToIndexType
constexpr GLenum ToIndexType(IndexType type)
Definition: formats_gles.h:34
impeller::LoadAction::kClear
@ kClear
impeller::StencilOperation::kDecrementWrap
@ kDecrementWrap
Decrement the current stencil value by 1. If at zero, set to maximum.
impeller::BlendFactor::kOneMinusDestinationColor
@ kOneMinusDestinationColor
impeller::kPrecomputedDivisions
static int kPrecomputedDivisions[kPrecomputedDivisionCount]
Definition: tessellator.cc:228
impeller::PointStyle::kSquare
@ kSquare
Points are drawn as circles.
impeller::PrimitiveType::kTriangleStrip
@ kTriangleStrip
impeller::RuntimeShaderStage::kFragment
@ kFragment
impeller::SamplerDescriptor::min_filter
MinMagFilter min_filter
Definition: sampler_descriptor.h:16
impeller::ToCompareFunction
constexpr GLenum ToCompareFunction(CompareFunction func)
Definition: formats_gles.h:69
impeller::kScale2
@ kScale2
Definition: canvas_recorder.h:30
impeller::StorageMode::kDeviceTransient
@ kDeviceTransient
impeller::Point
TPoint< Scalar > Point
Definition: point.h:308
impeller::CullMode::kBackFace
@ kBackFace
impeller::ToMTLLoadAction
constexpr MTLLoadAction ToMTLLoadAction(LoadAction action)
Definition: formats_mtl.h:279
impeller::TRect::Intersection
constexpr std::optional< TRect< T > > Intersection(const TRect &o) const
Definition: rect.h:312
impeller::CullMode::kNone
@ kNone
impeller::ToMTLBlendOperation
constexpr MTLBlendOperation ToMTLBlendOperation(BlendOperation type)
Definition: formats_mtl.h:198
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::OptionalDeviceExtensionVK::kEXTRasterizationOrderAttachmentAccess
@ kEXTRasterizationOrderAttachmentAccess
impeller::BlendOperation::kReverseSubtract
@ kReverseSubtract
impeller::ToVKIndexType
constexpr vk::IndexType ToVKIndexType(IndexType index_type)
Definition: formats_vk.h:331
IPLR_RELEASE
#define IPLR_RELEASE(...)
Definition: thread_safety.h:42
impeller::Tessellator::TessellateConvex
std::vector< Point > TessellateConvex(const Path &path, Scalar tolerance)
Given a convex path, create a triangle fan structure.
Definition: tessellator.cc:173
impeller::BlendFactor::kBlendAlpha
@ kBlendAlpha
impeller::UpdateBindingLayouts
static bool UpdateBindingLayouts(const std::vector< Command > &commands, const vk::CommandBuffer &buffer)
Definition: render_pass_vk.cc:333
impeller::compiler::TargetPlatform::kVulkan
@ kVulkan
impeller::SPrintF
std::string SPrintF(const char *format,...)
Definition: strings.cc:12
impeller::AttachmentKind::kStencil
@ kStencil
impeller::PrimitiveType::kPoint
@ kPoint
Draws a point at each input vertex.
impeller::ToVertexMode
static VerticesGeometry::VertexMode ToVertexMode(flutter::DlVertexMode mode)
Definition: dl_vertices_geometry.cc:20
impeller::PixelFormat::kR8G8UNormInt
@ kR8G8UNormInt
impeller::AttachmentKindFromFormat
constexpr AttachmentKind AttachmentKindFromFormat(PixelFormat format)
Definition: formats_vk.h:404
impeller::ContainsFormat
static bool ContainsFormat(const std::vector< vk::SurfaceFormatKHR > &formats, vk::SurfaceFormatKHR format)
Definition: swapchain_impl_vk.cc:79
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:23
impeller::YUVColorSpace::kBT601FullRange
@ kBT601FullRange
impeller::ToMode
constexpr GLenum ToMode(PrimitiveType primitive_type)
Definition: formats_gles.h:18
impeller::BlendOperation::kAdd
@ kAdd
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::kDrawRect
@ kDrawRect
Definition: canvas_recorder.h:36
impeller::CreateAttachmentDescription
static vk::AttachmentDescription CreateAttachmentDescription(const Attachment &attachment, const std::shared_ptr< Texture > Attachment::*texture_ptr, bool supports_framebuffer_fetch)
Definition: render_pass_vk.cc:31
impeller::ColorMatrix::array
Scalar array[20]
Definition: color.h:118
impeller::PixelFormat::kB10G10R10XR
@ kB10G10R10XR
impeller::CompressionType::kLossless
@ kLossless
impeller::AttachmentToString
std::string AttachmentToString(const Attachment &attachment)
Definition: formats.cc:104
impeller::TextureUsage::kShaderRead
@ kShaderRead
impeller::PixelFormat::kD24UnormS8Uint
@ kD24UnormS8Uint
impeller::kSkew
@ kSkew
Definition: canvas_recorder.h:32
impeller::kClipRRect
@ kClipRRect
Definition: canvas_recorder.h:44
impeller::WindingOrder::kCounterClockwise
@ kCounterClockwise
impeller::GetDefaultStencilConfig
static RenderTarget::AttachmentConfig GetDefaultStencilConfig(bool readable)
Definition: entity_pass.cc:241
impeller::BlendFactor::kOneMinusBlendColor
@ kOneMinusBlendColor
InternalHalf
_Float16 InternalHalf
Definition: half.h:22
impeller::TRect::Scale
constexpr TRect Scale(Type scale) const
Definition: rect.h:108
impeller::StencilOperation::kIncrementWrap
@ kIncrementWrap
Increment the current stencil value by 1. If at maximum, set to zero.
impeller::TextureType::kTextureCube
@ kTextureCube
impeller::FillType
FillType
Definition: path.h:30
impeller::kDrawImageRect
@ kDrawImageRect
Definition: canvas_recorder.h:41
impeller::kUnsignedByte
@ kUnsignedByte
Definition: runtime_types.h:24
impeller::kUnsignedInt64
@ kUnsignedInt64
Definition: runtime_types.h:30
impeller::PixelFormat::kR16G16B16A16Float
@ kR16G16B16A16Float
impeller::ScalarNearlyZero
constexpr bool ScalarNearlyZero(Scalar x, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:25
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:23
impeller::Absolute
constexpr T Absolute(const T &val)
Definition: scalar.h:21
impeller::Rect
TRect< Scalar > Rect
Definition: rect.h:488
impeller::kHalfFloat
@ kHalfFloat
Definition: runtime_types.h:31
impeller::CompareFunction::kLessEqual
@ kLessEqual
Comparison test passes if new_value <= current_value.
impeller::BlendFactor::kOne
@ kOne
impeller::Luminosity
static constexpr Scalar Luminosity(Vector3 color)
Definition: color.cc:140
impeller::BindBuffers
static bool BindBuffers(const Bindings &bindings, Allocator &allocator, const std::shared_ptr< CommandEncoderVK > &encoder, vk::DescriptorSet &vk_desc_set, const std::vector< DescriptorSetLayout > &desc_set, std::vector< vk::DescriptorBufferInfo > &buffers, std::vector< vk::WriteDescriptorSet > &writes)
Definition: binding_helpers_vk.cc:63
impeller::BlendFactor::kOneMinusBlendAlpha
@ kOneMinusBlendAlpha
impeller::CompressionType::kLossy
@ kLossy
impeller::kUnsignedInt
@ kUnsignedInt
Definition: runtime_types.h:28
impeller::DebugResourceType::kShader
@ kShader
impeller::ToFont
static Font ToFont(const SkTextBlobRunIterator &run)
Definition: text_frame_skia.cc:19
impeller::kTransform
@ kTransform
Definition: canvas_recorder.h:26
impeller::AppendColor
static void AppendColor(const Color &color, GradientData *data)
Definition: gradient.cc:12
impeller::CompareFunction::kAlways
@ kAlways
Comparison test passes always passes.
impeller::kDrawAtlas
@ kDrawAtlas
Definition: canvas_recorder.h:48
impeller::skia_conversions::ToPoint
Point ToPoint(const SkPoint &point)
Definition: skia_conversions.cc:140
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:26
impeller::kSignedShort
@ kSignedShort
Definition: runtime_types.h:25
impeller::TextureType::kTexture2D
@ kTexture2D
impeller::FillType::kNonZero
@ kNonZero
impeller::PixelFormat::kR32G32B32A32Float
@ kR32G32B32A32Float
impeller::DescriptorType::kUniformBuffer
@ kUniformBuffer
impeller::ToVKAttachmentStoreOp
constexpr vk::AttachmentStoreOp ToVKAttachmentStoreOp(StoreAction store_action)
Definition: formats_vk.h:316
impeller::SamplerDescriptor::mip_filter
MipFilter mip_filter
Definition: sampler_descriptor.h:18
IMPELLER_FOR_EACH_BLEND_MODE
#define IMPELLER_FOR_EACH_BLEND_MODE(V)
Definition: color.h:19
impeller::HandleType::kProgram
@ kProgram
impeller::kDrawPaint
@ kDrawPaint
Definition: canvas_recorder.h:35
impeller::TPoint::x
Type x
Definition: point.h:25
impeller::VerifyExistingCache
static bool VerifyExistingCache(const fml::Mapping &mapping, const CapabilitiesVK &caps)
Definition: pipeline_cache_vk.cc:19
impeller::kNew
@ kNew
Definition: canvas_recorder.h:20
impeller::kUV
@ kUV
Definition: geometry.h:37
impeller::ToMTLPixelFormat
constexpr MTLPixelFormat ToMTLPixelFormat(PixelFormat format)
Definition: formats_mtl.h:77
impeller::CompareFunction::kNever
@ kNever
Comparison test never passes.
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::ISize
TSize< int64_t > ISize
Definition: size.h:138
impeller::kMagicSubpassInputBinding
static constexpr size_t kMagicSubpassInputBinding
Definition: binding_helpers_vk.cc:24
impeller::kSaveLayer
@ kSaveLayer
Definition: canvas_recorder.h:22
impeller::HeapAlloc
static void * HeapAlloc(void *userData, unsigned int size)
Definition: tessellator.cc:11
impeller::TextureDescriptor::size
ISize size
Definition: texture_descriptor.h:41
impeller::ToVKAttachmentLoadOp
constexpr vk::AttachmentLoadOp ToVKAttachmentLoadOp(LoadAction load_action)
Definition: formats_vk.h:303
impeller::NearEqual
static bool NearEqual(Scalar a, Scalar b, Scalar epsilon)
Definition: path_component.cc:245
impeller::BlendMode::kDestinationIn
@ kDestinationIn
impeller::ToMTLTextureType
constexpr MTLTextureType ToMTLTextureType(TextureType type)
Definition: formats_mtl.h:376
impeller::Join::kBevel
@ kBevel
VALIDATION_LOG
#define VALIDATION_LOG
Definition: validation.h:67
impeller::CullMode::kFrontFace
@ kFrontFace
_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:264
impeller::BlendMode::kDestinationOut
@ kDestinationOut
impeller::ShaderType::kStruct
@ kStruct
impeller::ClipColor
static constexpr Vector3 ClipColor(Vector3 color)
Definition: color.cc:144
impeller::ColorWriteMask::kAll
@ kAll
impeller::PixelFormat::kR8G8B8A8UNormIntSRGB
@ kR8G8B8A8UNormIntSRGB
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:33
impeller::HasSuitableColorFormat
static bool HasSuitableColorFormat(const vk::PhysicalDevice &device, vk::Format format)
Definition: capabilities_vk.cc:241
impeller::kDrawPoints
@ kDrawPoints
Definition: canvas_recorder.h:39
impeller::BlendSelectValues::kHardLight
@ kHardLight
impeller::ConfigureBlending
void ConfigureBlending(const ProcTableGLES &gl, const ColorAttachmentDescriptor *color)
Definition: render_pass_gles.cc:43
impeller::LoadAction::kDontCare
@ kDontCare
impeller::kSignedInt64
@ kSignedInt64
Definition: runtime_types.h:29
impeller::BlendSelectValues::kScreen
@ kScreen
DISABLE_COLOR_FONT_SUPPORT
#define DISABLE_COLOR_FONT_SUPPORT
Definition: typographer_context_stb.cc:18
impeller::BindImages
static bool BindImages(const Bindings &bindings, Allocator &allocator, const std::shared_ptr< CommandEncoderVK > &encoder, vk::DescriptorSet &vk_desc_set, std::vector< vk::DescriptorImageInfo > &images, std::vector< vk::WriteDescriptorSet > &writes)
Definition: binding_helpers_vk.cc:26
impeller::Tessellator::Tessellate
Tessellator::Result Tessellate(const Path &path, Scalar tolerance, const BuilderCallback &callback)
Generates filled triangles from the path. A callback is invoked once for the entire tessellation.
Definition: tessellator.cc:64
impeller::ToMTLBlendFactor
constexpr MTLBlendFactor ToMTLBlendFactor(BlendFactor type)
Definition: formats_mtl.h:115
impeller::BlendFactor::kOneMinusSourceColor
@ kOneMinusSourceColor
impeller::HasPrefix
bool HasPrefix(const std::string &string, const std::string &prefix)
Definition: strings.cc:30
impeller::compiler::TargetPlatform::kOpenGLES
@ kOpenGLES
impeller::BlendSelectValues::kLighten
@ kLighten
impeller::MipFilter::kLinear
@ kLinear
impeller::BlendMode::kSourceIn
@ kSourceIn
impeller::RuntimeShaderStage::kCompute
@ kCompute
impeller::FromMTLPixelFormat
constexpr PixelFormat FromMTLPixelFormat(MTLPixelFormat format)
Definition: formats_mtl.h:23
impeller::kUnusedAttachmentReference
static constexpr vk::AttachmentReference kUnusedAttachmentReference
Definition: formats_vk.h:493
impeller::ScalarNearlyEqual
constexpr bool ScalarNearlyEqual(Scalar x, Scalar y, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:30
impeller::SamplerDescriptor::label
std::string label
Definition: sampler_descriptor.h:24
impeller::ToBlendMode
static BlendMode ToBlendMode(flutter::DlBlendMode mode)
Definition: dl_dispatcher.cc:47
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::BlendMode::kLast
@ kLast
impeller::SampleCount::kCount1
@ kCount1
impeller::BlendSelectValues::kHue
@ kHue
impeller::SampleCount::kCount4
@ kCount4
impeller::BlendSelectValues::kLuminosity
@ kLuminosity
impeller::FillType::kNegative
@ kNegative
impeller::TextureDescriptor::storage_mode
StorageMode storage_mode
Definition: texture_descriptor.h:38
impeller::UseSubpassInput::kYes
@ kYes
impeller::kPrecomputedDivisionCount
static constexpr int kPrecomputedDivisionCount
Definition: tessellator.cc:227
impeller::kScale3
@ kScale3
Definition: canvas_recorder.h:31
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:221
impeller::DescriptorType::kInputAttachment
@ kInputAttachment
impeller::ToColorFilter
static std::shared_ptr< ColorFilter > ToColorFilter(const flutter::DlColorFilter *filter)
Definition: dl_dispatcher.cc:445
impeller::TextureDescriptor
A lightweight object that describes the attributes of a texture that can then used an allocator to cr...
Definition: texture_descriptor.h:37
impeller::ToBlendOperation
constexpr GLenum ToBlendOperation(BlendOperation op)
Definition: formats_gles.h:127
IMPELLER_GL_CLAMP_TO_BORDER
#define IMPELLER_GL_CLAMP_TO_BORDER
Definition: gles.h:12
impeller::kBlendModeNames
static constexpr const char * kBlendModeNames[]
Definition: color.cc:44
impeller::CompareFunction::kNotEqual
@ kNotEqual
Comparison test passes if new_value != current_value.
impeller::HandleType::kFrameBuffer
@ kFrameBuffer
impeller::PixelFormat::kB10G10R10XRSRGB
@ kB10G10R10XRSRGB
impeller::UseSubpassInput::kNo
@ kNo
impeller::ToVKBlendOp
constexpr vk::BlendOp ToVKBlendOp(BlendOperation op)
Definition: formats_vk.h:65
impeller::BlendMode::kXor
@ kXor
impeller::HandleType::kBuffer
@ kBuffer
impeller::Convexity::kConvex
@ kConvex
impeller::kDrawVertices
@ kDrawVertices
Definition: canvas_recorder.h:47
impeller::PixelFormat::kB8G8R8A8UNormInt
@ kB8G8R8A8UNormInt
impeller::BlendFactor::kSourceAlpha
@ kSourceAlpha
impeller::AttachmentTypeString
static const char * AttachmentTypeString(GLint type)
Definition: proc_table_gles.cc:220
impeller::ToVKBufferMemoryPropertyFlags
static constexpr vk::Flags< vk::MemoryPropertyFlagBits > ToVKBufferMemoryPropertyFlags(StorageMode mode)
Definition: allocator_vk.cc:20
impeller::kDrawPath
@ kDrawPath
Definition: canvas_recorder.h:34
impeller::kDrawRRect
@ kDrawRRect
Definition: canvas_recorder.h:37
impeller::ColorMatrix
Definition: color.h:117
impeller::GetShaderInfoLog
static std::string GetShaderInfoLog(const ProcTableGLES &gl, GLuint shader)
Definition: pipeline_library_gles.cc:22
impeller::ToStencilOp
constexpr GLenum ToStencilOp(StencilOperation op)
Definition: formats_gles.h:47
impeller::RuntimeStageBackend::kMetal
@ kMetal
impeller::ToRect
static Rect ToRect(const SkRect &rect)
Definition: text_frame_skia.cc:35
impeller::TextureUsage::kShaderWrite
@ kShaderWrite
impeller::TextureUsageToString
constexpr const char * TextureUsageToString(TextureUsage usage)
Definition: formats.h:308
impeller::CompareFunction::kLess
@ kLess
Comparison test passes if new_value < current_value.
impeller::kRestore
@ kRestore
Definition: canvas_recorder.h:23
impeller::BlendMode::kSourceATop
@ kSourceATop
impeller::kPosition
@ kPosition
Definition: geometry.h:35
impeller::kPiOver4
constexpr float kPiOver4
Definition: constants.h:35
impeller::BlendSelectValues::kColorDodge
@ kColorDodge
impeller::BlendOperation::kSubtract
@ kSubtract
impeller::kTranslate
@ kTranslate
Definition: canvas_recorder.h:29
impeller::Color::Premultiply
constexpr Color Premultiply() const
Definition: color.h:214
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::BlendMode::kSourceOver
@ kSourceOver
impeller::DebugToFramebufferError
std::string DebugToFramebufferError(int status)
Definition: formats_gles.cc:9
impeller::BlendSelectValues::kOverlay
@ kOverlay
impeller::BlendFactor::kOneMinusDestinationAlpha
@ kOneMinusDestinationAlpha
impeller::kClipRect
@ kClipRect
Definition: canvas_recorder.h:43
impeller::VKClearValueFromColor
static vk::ClearColorValue VKClearValueFromColor(Color color)
Definition: render_pass_vk.cc:216
impeller::compiler::TargetPlatform::kSkSL
@ kSkSL
impeller::DescriptorType::kStorageBuffer
@ kStorageBuffer
impeller::ToVKColorComponentFlags
constexpr vk::ColorComponentFlags ToVKColorComponentFlags(std::underlying_type_t< ColorWriteMask > type)
Definition: formats_vk.h:77
impeller::kRestoreToCount
@ kRestoreToCount
Definition: canvas_recorder.h:24
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...