Flutter Impeller
impeller Namespace Reference

Namespaces

 android
 
 compiler
 
 egl
 
 saturated
 
 scene
 
 skia_conversions
 
 testing
 

Classes

class  AHBTextureSourceVK
 A texture source that wraps an instance of AHardwareBuffer. More...
 
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
 
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
 
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
 
struct  ClipCoverageLayer
 
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  CommandQueue
 An interface for submitting command buffers to the GPU for encoding and execution. More...
 
class  CommandQueueVK
 
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
 
class  ComputePass
 Compute passes encode compute shader into the underlying command buffer. More...
 
struct  ComputePassBindingsCacheMTL
 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...
 
struct  DescriptorPoolSize
 
class  DescriptorPoolVK
 A per-frame 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  DeviceHolderVK
 Holds a strong reference to the underlying logical Vulkan device. This comes in handy when the context is being torn down and the various components on different threads may need to orchestrate safe shutdown. More...
 
class  DilateImageFilter
 
class  DirectionalMorphologyFilterContents
 
class  DlDispatcher
 
class  DlImageImpeller
 
class  DlPlayground
 
class  DriverInfoVK
 Get information about the Vulkan driver. More...
 
struct  EGLImageKHRWithDisplay
 
struct  EGLImageKHRWithDisplayTraits
 
struct  EGLImageWithDisplay
 
struct  EGLImageWithDisplayTraits
 
class  EllipseGeometry
 
class  Entity
 
class  EntityPass
 
class  EntityPassClipStack
 A class that tracks all clips that have been recorded in the current entity pass stencil. More...
 
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
 
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
 
struct  ImmutableSamplerKeyVK
 
class  ImpellerBenchmarkAccessor
 
class  ImpellerEntityUnitTestAccessor
 
class  InlinePassContext
 
struct  IPoint16
 
struct  KHRFrameSynchronizerVK
 
class  KHRSurfaceVK
 
class  KHRSwapchainImageVK
 
class  KHRSwapchainImplVK
 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  KHRSwapchainVK
 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  LazyGlyphAtlas
 
class  LinearGradientContents
 
struct  LinearPathComponent
 
class  LinearToSrgbColorFilter
 
class  LinearToSrgbFilterContents
 
class  LineGeometry
 
class  LocalMatrixFilterContents
 
class  LocalMatrixImageFilter
 
class  Lock
 
struct  Mask
 A mask of typed enums. More...
 
struct  MaskTraits
 
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  NoExceptionPromise
 
class  OpacityPeepholePassDelegate
 
struct  Padded
 Struct used for padding uniform buffer array elements. More...
 
struct  Padding
 
struct  Paint
 
class  PaintPassDelegate
 
struct  PassBindingsCacheMTL
 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  PendingCommandBuffers
 
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  PlaygroundPoint
 
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...
 
class  RenderPassBuilderVK
 
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  RenderTargetConfig
 
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
 
struct  ScopedValidationFatal
 
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  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
 Abstract base class that represents a vkImage and an vkImageView. More...
 
class  TextureVK
 
class  TiledTextureContents
 
struct  TPoint
 
class  TraceSerializer
 
class  TrackedObjectsVK
 A per-frame object used to track resource lifetimes and allocate command buffers and descriptor sets. More...
 
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
 
struct  YUVConversionDescriptorVKEqual
 
struct  YUVConversionDescriptorVKHash
 
class  YUVConversionLibraryVK
 Due the way the Vulkan spec. treats "identically defined" conversions, creating two conversion with identical descriptors, using one with the image and the other with the sampler, is invalid use. More...
 
class  YUVConversionVK
 It is sometimes necessary to deal with formats not native to Vulkan. In such cases, extra information is necessary to access images. A YUV conversion object is needed in such instances. More...
 
class  YUVToRGBFilterContents
 

Typedefs

using CanvasType = Canvas
 
using MyMask = Mask< MyMaskBits >
 
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 = Mask< TextureUsage >
 
using ColorWriteMask = Mask< ColorWriteMaskBits >
 
using SamplerMap = std::unordered_map< SamplerDescriptor, std::unique_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 TextureStrictSrcPipeline = RenderPipelineT< TextureFillVertexShader, TextureFillStrictSrcFragmentShader >
 
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 VS = SolidFillVertexShader
 
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 AHBProperties = vk::StructureChain< vk::AndroidHardwareBufferPropertiesANDROID, vk::AndroidHardwareBufferFormatPropertiesANDROID >
 
using CommandPoolMap = std::unordered_map< uint64_t, std::shared_ptr< CommandPoolVK > >
 
using WaitSet = std::vector< std::shared_ptr< WaitSetEntry > >
 
template<class T >
using SharedHandleVK = std::shared_ptr< SharedObjectVKT< T > >
 
using UniqueAllocatorVMA = fml::UniqueObject< VmaAllocator, AllocatorVMATraits >
 
using UniquePoolVMA = fml::UniqueObject< PoolVMA, PoolVMATraits >
 
using UniqueBufferVMA = fml::UniqueObject< BufferVMA, BufferVMATraits >
 
using UniqueImageVMA = fml::UniqueObject< ImageVMA, ImageVMATraits >
 
using YUVConversionDescriptorVK = vk::StructureChain< vk::SamplerYcbcrConversionCreateInfo >
 
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  SourceRectConstraint {
  SourceRectConstraint::kFast,
  SourceRectConstraint::kStrict
}
 Controls the behavior of the source rectangle given to DrawImageRect. More...
 
enum  CanvasRecorderOp : uint16_t {
  kNew,
  kSave,
  kSaveLayer,
  kRestore,
  kRestoreToCount,
  kResetTransform,
  kTransform,
  kConcat,
  kPreConcat,
  kTranslate,
  kScale2,
  kScale3,
  kSkew,
  kRotate,
  kDrawPath,
  kDrawPaint,
  kDrawLine,
  kDrawRect,
  kDrawOval,
  kDrawRRect,
  kDrawCircle,
  kDrawPoints,
  kDrawImage,
  kDrawImageRect,
  kClipPath,
  kClipRect,
  kClipOval,
  kClipRRect,
  kDrawTextFrame,
  kDrawVertices,
  kDrawAtlas
}
 
enum  MyMaskBits : uint32_t {
  MyMaskBits::kFoo = 0,
  MyMaskBits::kBar = 1 << 0,
  MyMaskBits::kBaz = 1 << 1,
  MyMaskBits::kBang = 1 << 2
}
 
enum  WindingOrder {
  WindingOrder::kClockwise,
  WindingOrder::kCounterClockwise
}
 
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 {
  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  ColorWriteMaskBits : uint64_t {
  ColorWriteMaskBits::kNone = 0,
  ColorWriteMaskBits::kRed = 1 << 0,
  ColorWriteMaskBits::kGreen = 1 << 1,
  ColorWriteMaskBits::kBlue = 1 << 2,
  ColorWriteMaskBits::kAlpha = 1 << 3,
  ColorWriteMaskBits::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 {
  kFloat,
  kSampledImage,
  kStruct
}
 
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  ContentBoundsPromise {
  ContentBoundsPromise::kUnknown,
  ContentBoundsPromise::kContainsContents,
  ContentBoundsPromise::kMayClipContents
}
 
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  UVMode {
  UVMode::kNoUV,
  UVMode::kUVRect,
  UVMode::kUVRectTx
}
 
enum  Cap {
  Cap::kButt,
  Cap::kRound,
  Cap::kSquare
}
 
enum  Join {
  Join::kMiter,
  Join::kRound,
  Join::kBevel
}
 
enum  FillType {
  FillType::kNonZero,
  FillType::kOdd
}
 
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  RequiredCommonDeviceExtensionVK : uint32_t {
  RequiredCommonDeviceExtensionVK::kKHRSwapchain,
  RequiredCommonDeviceExtensionVK::kLast
}
 A device extension available on all platforms. Without the presence of these extensions, context creation will fail. More...
 
enum  RequiredAndroidDeviceExtensionVK : uint32_t {
  RequiredAndroidDeviceExtensionVK::kANDROIDExternalMemoryAndroidHardwareBuffer,
  RequiredAndroidDeviceExtensionVK::kKHRSamplerYcbcrConversion,
  RequiredAndroidDeviceExtensionVK::kKHRExternalMemory,
  RequiredAndroidDeviceExtensionVK::kEXTQueueFamilyForeign,
  RequiredAndroidDeviceExtensionVK::kKHRDedicatedAllocation,
  RequiredAndroidDeviceExtensionVK::kLast
}
 A device extension available on all Android platforms. Without the presence of these extensions on Android, context creation will fail. More...
 
enum  OptionalDeviceExtensionVK : uint32_t {
  OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback,
  OptionalDeviceExtensionVK::kVKKHRPortabilitySubset,
  OptionalDeviceExtensionVK::kLast
}
 A device extension enabled if available. Subsystems cannot assume availability and must check if these extensions are available. More...
 
enum  VendorVK {
  VendorVK::kUnknown,
  VendorVK::kGoogle,
  VendorVK::kQualcomm,
  VendorVK::kARM,
  VendorVK::kImgTec,
  VendorVK::kPowerVR = kImgTec,
  VendorVK::kAMD,
  VendorVK::kNvidia,
  VendorVK::kIntel,
  VendorVK::kMesa,
  VendorVK::kApple
}
 
enum  DeviceTypeVK {
  DeviceTypeVK::kUnknown,
  DeviceTypeVK::kIntegratedGPU,
  DeviceTypeVK::kDiscreteGPU,
  DeviceTypeVK::kVirtualGPU,
  DeviceTypeVK::kCPU
}
 
enum  ArchiveShaderType {
  ArchiveShaderType::kVertex,
  ArchiveShaderType::kFragment,
  ArchiveShaderType::kCompute
}
 
enum  ArchiveRenderingBackend {
  ArchiveRenderingBackend::kMetal,
  ArchiveRenderingBackend::kVulkan,
  ArchiveRenderingBackend::kOpenGLES
}
 

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)
 
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)
 
 IMPELLER_ENUM_IS_MASK (MyMaskBits)
 
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<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask< EnumType > operator| (const EnumType &lhs, const EnumType &rhs)
 
template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask< EnumType > operator& (const EnumType &lhs, const EnumType &rhs)
 
template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask< EnumType > operator^ (const EnumType &lhs, const EnumType &rhs)
 
template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask< EnumType > operator~ (const EnumType &other)
 
template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask< EnumType > operator| (const EnumType &lhs, const Mask< EnumType > &rhs)
 
template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask< EnumType > operator& (const EnumType &lhs, const Mask< EnumType > &rhs)
 
template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask< EnumType > operator^ (const EnumType &lhs, const Mask< EnumType > &rhs)
 
template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool operator< (const EnumType &lhs, const Mask< EnumType > &rhs)
 
template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool operator> (const EnumType &lhs, const Mask< EnumType > &rhs)
 
template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool operator<= (const EnumType &lhs, const Mask< EnumType > &rhs)
 
template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool operator>= (const EnumType &lhs, const Mask< EnumType > &rhs)
 
template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool operator== (const EnumType &lhs, const Mask< EnumType > &rhs)
 
template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool operator!= (const EnumType &lhs, const Mask< EnumType > &rhs)
 
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)
 
bool ImpellerValidationErrorsAreFatal ()
 
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)
 
 IMPELLER_ENUM_IS_MASK (TextureUsage)
 
constexpr const char * TextureUsageToString (TextureUsage usage)
 
 IMPELLER_ENUM_IS_MASK (ColorWriteMaskBits)
 
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< ColorToColors (const flutter::DlColor colors[], int count)
 
static std::optional< ColorSource::TypeToColorSourceType (flutter::DlColorSourceType type)
 
static std::shared_ptr< ColorFilterToColorFilter (const flutter::DlColorFilter *filter)
 
static FilterContents::BlurStyle ToBlurStyle (flutter::DlBlurStyle blur_style)
 
static std::shared_ptr< ImageFilterToImageFilter (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::VerticesGeometryMakeVertices (const flutter::DlVertices *vertices)
 
static Scalar GetShaderClipDepth (const Entity &entity)
 
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< BlendModeInvertPorterDuffBlend (BlendMode blend_mode)
 
template<typename TPipeline >
static std::optional< EntityAdvancedBlend (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< EntityPipelineBlend (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)
 
KernelPipeline::FragmentShader::KernelSamples GenerateBlurInfo (BlurParameters parameters)
 
KernelPipeline::FragmentShader::KernelSamples LerpHackKernelSamples (KernelPipeline::FragmentShader::KernelSamples parameters)
 
std::shared_ptr< TextureCreateGradientTexture (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< StopDataCreateGradientColors (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< ShaderMetadataMakeShaderMetadata (const RuntimeUniformDescription &uniform)
 
static std::optional< SamplerAddressModeTileModeToAddressMode (Entity::TileMode tile_mode, const Capabilities &capabilities)
 
static EntityPassTarget CreateRenderTarget (ContentContext &renderer, ISize size, int mip_count, const Color &clear_color)
 
static void SetClipScissor (std::optional< Rect > clip_coverage, RenderPass &pass, Point global_pass_position)
 
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_bounds, Matrix effect_transform, const ContentContext &renderer, const Entity &entity, RenderPass &pass)
 Computes geometry and UV coordinates for a rectangle to be rendered. More...
 
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 ApplyBlendedColor (Color dst, Color src, Vector3 blend_result)
 
static constexpr Color DoColorBlend (Color dst, Color src, const std::function< Vector3(Vector3, Vector3)> &blend_rgb_func)
 
static constexpr Color DoColorBlendComponents (Color dst, Color src, 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_StrokePolyline (benchmark::State &state, Args &&... args)
 
template<class... Args>
static void BM_Convex (benchmark::State &state, Args &&... args)
 
 BENCHMARK_CAPTURE (BM_Polyline, cubic_polyline, CreateCubic(true), false)
 
 BENCHMARK_CAPTURE (BM_Polyline, cubic_polyline_tess, CreateCubic(true), true)
 
 BENCHMARK_CAPTURE (BM_Polyline, unclosed_cubic_polyline, CreateCubic(false), false)
 
 BENCHMARK_CAPTURE (BM_Polyline, unclosed_cubic_polyline_tess, CreateCubic(false), true)
 
 MAKE_STROKE_BENCHMARK_CAPTURE_UVS (Cubic)
 
 BENCHMARK_CAPTURE (BM_Polyline, quad_polyline, CreateQuadratic(true), false)
 
 BENCHMARK_CAPTURE (BM_Polyline, quad_polyline_tess, CreateQuadratic(true), true)
 
 BENCHMARK_CAPTURE (BM_Polyline, unclosed_quad_polyline, CreateQuadratic(false), false)
 
 BENCHMARK_CAPTURE (BM_Polyline, unclosed_quad_polyline_tess, CreateQuadratic(false), true)
 
 MAKE_STROKE_BENCHMARK_CAPTURE_UVS (Quadratic)
 
 BENCHMARK_CAPTURE (BM_Convex, rrect_convex, CreateRRect(), true)
 
 MAKE_STROKE_BENCHMARK_CAPTURE (RRect, Butt, Bevel,,, UVMode::kNoUV)
 
 MAKE_STROKE_BENCHMARK_CAPTURE (RRect, Butt, Bevel,, _uv, UVMode::kUVRectTx)
 
 MAKE_STROKE_BENCHMARK_CAPTURE (RRect, Butt, Bevel,, _uvNoTx, UVMode::kUVRect)
 
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)
 
 TEST (ValidationTest, IsFatal)
 
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 void FindSwiftShaderICDAtKnownPaths ()
 
void SetupSwiftshaderOnce (bool use_swiftshader)
 Find and setup the installable client driver for a locally built SwiftShader at known paths. The option to use SwiftShader can only be used once in the process. While calling this method multiple times is fine, specifying a different use_swiftshader value will trip an assertion. More...
 
static std::string FormatWindowTitle (const std::string &test_name)
 
static size_t GetBytesPerPixel (DecompressedImage::Format format)
 
std::string PlaygroundBackendToString (PlaygroundBackend backend)
 
static void InitializeGLFWOnce ()
 
static void PlaygroundKeyCallback (GLFWwindow *window, int key, int scancode, int action, int mods)
 
static std::shared_ptr< TextureCreateTextureForDecompressedImage (const std::shared_ptr< Context > &context, DecompressedImage &decompressed_image, bool enable_mipmapping)
 
constexpr RuntimeStageBackend PlaygroundBackendToRuntimeStageBackend (PlaygroundBackend backend)
 
Point DrawPlaygroundPoint (PlaygroundPoint &point)
 
std::tuple< Point, PointDrawPlaygroundLine (PlaygroundPoint &point_a, PlaygroundPoint &point_b)
 
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 bool DetermineIfANGLE (const std::string &version)
 
static std::optional< VersionDetermineVersion (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)
 
void() glClearDepthf (GLfloat depth)
 
void() glDepthRangef (GLfloat n, GLfloat f)
 
void() glClearDepth (GLdouble depth)
 
void() glDepthRange (GLdouble n, GLdouble f)
 
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 bool IsDepthStencilFormat (PixelFormat format)
 
static TextureGLES::Type GetTextureTypeFromDescriptor (const TextureDescriptor &desc)
 
HandleType ToHandleType (TextureGLES::Type type)
 
static std::optional< GLenum > ToRenderBufferFormat (PixelFormat format)
 
static GLenum ToAttachmentType (TextureGLES::AttachmentType 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 DeviceSupportsFramebufferFetch (id< MTLDevice > device)
 
static bool DeviceSupportsComputeSubgroups (id< MTLDevice > device)
 
static std::unique_ptr< CapabilitiesInferMetalCapabilities (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 (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< TextureMTLCreateTextureFromDrawableFuture (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 (PassBindingsCacheMTL &pass, ShaderStage stage, size_t bind_index, const BufferView &view)
 
static bool Bind (PassBindingsCacheMTL &pass, ShaderStage stage, size_t bind_index, const std::unique_ptr< const Sampler > &sampler, const Texture &texture)
 
static MTLFunctionType ToMTLFunctionType (ShaderStage stage)
 
static std::optional< RenderTargetWrapTextureWithRenderTarget (Allocator &allocator, id< MTLTexture > texture, bool requires_blit, std::optional< IRect > clip_rect)
 
std::shared_ptr< TextureWrapperMTL (TextureDescriptor desc, const void *mtl_texture, std::function< void()> deletion_proc)
 
std::shared_ptr< TextureWrapTextureMTL (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, bool readback)
 
static PoolVMA CreateBufferPool (VmaAllocator allocator)
 
static constexpr VmaMemoryUsage ToVMAMemoryUsage ()
 
static constexpr vk::Flags< vk::MemoryPropertyFlagBits > ToVKTextureMemoryPropertyFlags (StorageMode mode, bool supports_memoryless_textures)
 
static VmaAllocationCreateFlags ToVmaAllocationCreateFlags (StorageMode mode)
 
static vk::UniqueImage CreateVKImageWrapperForAndroidHarwareBuffer (const vk::Device &device, const AHBProperties &ahb_props, const AHardwareBuffer_Desc &ahb_desc)
 
static vk::UniqueDeviceMemory ImportVKDeviceMemoryFromAndroidHarwareBuffer (const vk::Device &device, const vk::PhysicalDevice &physical_device, const vk::Image &image, struct AHardwareBuffer *hardware_buffer, const AHBProperties &ahb_props)
 
static std::shared_ptr< YUVConversionVKCreateYUVConversion (const ContextVK &context, const AHBProperties &ahb_props)
 
static vk::UniqueImageView CreateVKImageView (const vk::Device &device, const vk::Image &image, const vk::SamplerYcbcrConversion &yuv_conversion, const AHBProperties &ahb_props, const AHardwareBuffer_Desc &ahb_desc)
 
static PixelFormat ToPixelFormat (AHardwareBuffer_Format format)
 
static TextureType ToTextureType (const AHardwareBuffer_Desc &ahb_desc)
 
static TextureDescriptor ToTextureDescriptor (const AHardwareBuffer_Desc &ahb_desc)
 
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 * GetExtensionName (RequiredCommonDeviceExtensionVK ext)
 
static const char * GetExtensionName (RequiredAndroidDeviceExtensionVK ext)
 
static const char * GetExtensionName (OptionalDeviceExtensionVK ext)
 
template<class T >
static bool IterateExtensions (const std::function< bool(T)> &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)
 
template<class ExtensionEnum >
static bool IsExtensionInList (const std::vector< std::string > &list, ExtensionEnum ext)
 
static std::unordered_map< const ContextVK *, std::vector< std::weak_ptr< CommandPoolVK > > > g_all_pools_map IPLR_GUARDED_BY (g_all_pools_map_mutex)
 
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< QueueIndexVKPickQueue (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)
 
constexpr VendorVK IdentifyVendor (uint32_t vendor)
 
constexpr DeviceTypeVK ToDeviceType (const vk::PhysicalDeviceType &type)
 
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 (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, bool is_resolve_texture)
 
constexpr bool StoreActionPerformsResolve (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 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::PipelineCreationFeedbackEXT EmptyFeedback ()
 
constexpr vk::FrontFace ToVKFrontFace (WindingOrder order)
 
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::UniqueRenderPass CreateCompatRenderPassForPipeline (const vk::Device &device, const PipelineDescriptor &desc)
 
void InsertBarrierForInputAttachmentRead (const vk::CommandBuffer &buffer, const vk::Image &image)
 Inserts the appropriate barriers to ensure that subsequent commands can read from the specified image (itself a framebuffer attachment) as an input attachment. More...
 
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 vk::UniqueSampler CreateSampler (const vk::Device &device, const SamplerDescriptor &desc, const std::shared_ptr< YUVConversionVK > &yuv_conversion)
 
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)
 
vk::Format ToVertexDescriptorFormat (const ShaderStageIOSlot &input)
 
template<typename T >
static std::shared_ptr< DeviceBufferCreateDeviceBuffer (const std::shared_ptr< Context > &context, const std::string &label, StorageMode storage_mode=StorageMode::kDevicePrivate)
 
PipelineFuture< PipelineDescriptorCreatePipelineFuture (const Context &context, std::optional< PipelineDescriptor > desc)
 
PipelineFuture< ComputePipelineDescriptorCreatePipelineFuture (const Context &context, std::optional< ComputePipelineDescriptor > desc)
 
fml::Status AddMipmapGeneration (const std::shared_ptr< CommandBuffer > &command_buffer, const std::shared_ptr< Context > &context, const std::shared_ptr< Texture > &texture)
 Adds a blit command to the render pass. More...
 
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< ArchiveShaderTypeInferShaderTypefromFileExtension (const std::filesystem::path &path)
 
constexpr fb::Stage ToStage (ArchiveShaderType type)
 
PathBuilderCreatePathBuilder ()
 
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 VerticesTessellate (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< TextFrameMakeTextFrameFromTextBlobSkia (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< TextureUploadGlyphTextureAtlas (const std::shared_ptr< Allocator > &allocator, std::shared_ptr< SkBitmap > bitmap, const ISize &atlas_size, PixelFormat format)
 
std::shared_ptr< TextFrameMakeTextFrameSTB (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< BitmapSTBCreateAtlasBitmap (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< TextureUploadGlyphTextureAtlas (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 std::atomic_size_t sLastID
 
static std::atomic_int32_t sValidationLogsDisabledCount = 0
 
static std::atomic_int32_t sValidationLogsAreFatal = 0
 
constexpr size_t kAllocatorBlockSize = 1024000
 
static const constexpr size_t kHostBufferArenaSize = 3u
 Approximately the same size as the max frames in flight. More...
 
constexpr std::array< std::array< Scalar, 5 >, 15 > kPorterDuffCoefficients
 
constexpr Matrix kMatrixBT601LimitedRange
 
constexpr Matrix kMatrixBT601FullRange
 
static const constexpr RenderTarget::AttachmentConfig kDefaultStencilConfig
 
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 constexpr std::string_view kAngleInputAttachmentPrefix
 
static const constexpr char * kFramebufferFetchExt
 
static const constexpr char * kTextureBorderClampExt
 
static const constexpr char * kNvidiaTextureBorderClampExt
 
static const constexpr char * kMultisampledRenderToTextureExt
 
static const std::unique_ptr< const SamplerkNullSampler = nullptr
 
static const std::unique_ptr< const SamplerkNullSampler = nullptr
 
static constexpr const char * kInstanceLayer = "ImpellerInstance"
 
static thread_local std::unique_ptr< CommandPoolMaptls_command_pool_map
 
static Mutex g_all_pools_map_mutex
 
static bool gHasValidationLayers = false
 
static const constexpr DescriptorPoolSize kDefaultBindingSize
 Descriptor pools are always allocated with the following sizes. More...
 
static constexpr vk::AttachmentReference kUnusedAttachmentReference
 
static constexpr uint32_t kPoolSize = 128u
 
constexpr size_t kImageSizeThresholdForDedicatedMemoryAllocation
 
static constexpr const char * kPipelineCacheFileName
 
static constexpr size_t kMaxBindings = 32
 
constexpr auto kSelfDependencySrcStageMask
 
constexpr auto kSelfDependencySrcAccessMask
 
constexpr auto kSelfDependencyDstStageMask
 
constexpr auto kSelfDependencyDstAccessMask
 
constexpr auto kSelfDependencyFlags = vk::DependencyFlagBits::eByRegion
 
static constexpr size_t kMagicSubpassInputBinding = 64u
 
static const std::unique_ptr< const SamplerkNullSampler = nullptr
 
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
 
static const std::shared_ptr< GlyphAtlaskNullGlyphAtlas = nullptr
 

Typedef Documentation

â—† AHBProperties

using impeller::AHBProperties = typedef vk::StructureChain< vk::AndroidHardwareBufferPropertiesANDROID, vk::AndroidHardwareBufferFormatPropertiesANDROID>

Definition at line 18 of file ahb_texture_source_vk.cc.

â—† BlendColorBurnPipeline

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

Definition at line 185 of file content_context.h.

â—† BlendColorDodgePipeline

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

Definition at line 187 of file content_context.h.

â—† BlendColorPipeline

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

Definition at line 183 of file content_context.h.

â—† BlendDarkenPipeline

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

Definition at line 189 of file content_context.h.

â—† BlendDifferencePipeline

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

Definition at line 191 of file content_context.h.

â—† BlendExclusionPipeline

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

Definition at line 193 of file content_context.h.

â—† BlendHardLightPipeline

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

Definition at line 195 of file content_context.h.

â—† BlendHuePipeline

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

Definition at line 197 of file content_context.h.

â—† BlendLightenPipeline

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

Definition at line 199 of file content_context.h.

â—† BlendLuminosityPipeline

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

Definition at line 201 of file content_context.h.

â—† BlendMultiplyPipeline

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

Definition at line 203 of file content_context.h.

â—† BlendOverlayPipeline

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

Definition at line 205 of file content_context.h.

â—† BlendPipeline

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

Definition at line 132 of file content_context.h.

â—† BlendSaturationPipeline

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

Definition at line 207 of file content_context.h.

â—† BlendScreenPipeline

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

Definition at line 209 of file content_context.h.

â—† BlendSoftLightPipeline

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

Definition at line 211 of file content_context.h.

â—† BorderMaskBlurPipeline

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

Definition at line 153 of file content_context.h.

â—† BufferResource

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 174 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 159 of file content_context.h.

â—† ColorWriteMask

Definition at line 446 of file formats.h.

â—† CommandPoolMap

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

Definition at line 160 of file command_pool_vk.cc.

â—† ComputePipelineMap

â—† ConicalGradientFillPipeline

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

Definition at line 115 of file content_context.h.

â—† ConicalGradientSSBOFillPipeline

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

Definition at line 123 of file content_context.h.

â—† CTessellator

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

Definition at line 24 of file tessellator.h.

â—† EllipticalVertexGenerator

â—† 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 218 of file content_context.h.

â—† FramebufferBlendColorDodgePipeline

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

Definition at line 221 of file content_context.h.

â—† FramebufferBlendColorPipeline

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

Definition at line 215 of file content_context.h.

â—† FramebufferBlendDarkenPipeline

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

Definition at line 224 of file content_context.h.

â—† FramebufferBlendDifferencePipeline

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

Definition at line 227 of file content_context.h.

â—† FramebufferBlendExclusionPipeline

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

Definition at line 230 of file content_context.h.

â—† FramebufferBlendHardLightPipeline

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

Definition at line 233 of file content_context.h.

â—† FramebufferBlendHuePipeline

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

Definition at line 236 of file content_context.h.

â—† FramebufferBlendLightenPipeline

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

Definition at line 239 of file content_context.h.

â—† FramebufferBlendLuminosityPipeline

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

Definition at line 242 of file content_context.h.

â—† FramebufferBlendMultiplyPipeline

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

Definition at line 245 of file content_context.h.

â—† FramebufferBlendOverlayPipeline

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

Definition at line 248 of file content_context.h.

â—† FramebufferBlendSaturationPipeline

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

Definition at line 251 of file content_context.h.

â—† FramebufferBlendScreenPipeline

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

Definition at line 254 of file content_context.h.

â—† FramebufferBlendSoftLightPipeline

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

Definition at line 257 of file content_context.h.

â—† GaussianBlurDecalPipeline

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

Definition at line 144 of file content_context.h.

â—† GaussianBlurFragmentShader

â—† GaussianBlurPipeline

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

Definition at line 147 of file content_context.h.

â—† GaussianBlurVertexShader

â—† GeometryColorPipeline

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

Definition at line 177 of file content_context.h.

â—† GlyphAtlasColorPipeline

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

Definition at line 169 of file content_context.h.

â—† GlyphAtlasPipeline

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

Definition at line 167 of file content_context.h.

â—† IPoint

using impeller::IPoint = typedef TPoint<int64_t>

Definition at line 317 of file point.h.

â—† IPoint32

using impeller::IPoint32 = typedef TPoint<int32_t>

Definition at line 318 of file point.h.

â—† IRect

using impeller::IRect = typedef TRect<int64_t>

Definition at line 662 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 149 of file content_context.h.

â—† KernelPipeline

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

Definition at line 151 of file content_context.h.

â—† LinearGradientFillPipeline

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

Definition at line 108 of file content_context.h.

â—† LinearGradientSSBOFillPipeline

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

Definition at line 120 of file content_context.h.

â—† LinearToSrgbFilterPipeline

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

Definition at line 162 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 156 of file content_context.h.

â—† MyMask

using impeller::MyMask = typedef Mask<MyMaskBits>

Definition at line 20 of file base_unittests.cc.

â—† PathComponentVariant

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

Definition at line 169 of file path_component.h.

â—† PipelineMap

â—† 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 316 of file point.h.

â—† PointsComputeShaderPipeline

using impeller::PointsComputeShaderPipeline = typedef ComputePipelineBuilder<PointsComputeShader>

Geometry Pipelines.

Definition at line 260 of file content_context.h.

â—† PorterDuffBlendPipeline

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

Definition at line 171 of file content_context.h.

â—† PositionUVPipeline

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

Definition at line 139 of file content_context.h.

â—† Quad

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

Definition at line 321 of file point.h.

â—† RadialGradientFillPipeline

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

Definition at line 112 of file content_context.h.

â—† RadialGradientSSBOFillPipeline

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

Definition at line 126 of file content_context.h.

â—† Rect

using impeller::Rect = typedef TRect<Scalar>

Definition at line 661 of file rect.h.

â—† RRectBlurPipeline

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

Definition at line 131 of file content_context.h.

â—† SamplerMap

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

Definition at line 35 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 110 of file content_context.h.

â—† SrgbToLinearFilterPipeline

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

Definition at line 165 of file content_context.h.

â—† SweepGradientFillPipeline

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

Definition at line 117 of file content_context.h.

â—† SweepGradientSSBOFillPipeline

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

Definition at line 129 of file content_context.h.

â—† TessellatedVertexProc

â—† TexturePipeline

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

Definition at line 134 of file content_context.h.

â—† TextureResource

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

Definition at line 58 of file command.h.

â—† TextureStrictSrcPipeline

using impeller::TextureStrictSrcPipeline = typedef RenderPipelineT<TextureFillVertexShader, TextureFillStrictSrcFragmentShader>

Definition at line 137 of file content_context.h.

â—† TextureUsageMask

Definition at line 309 of file formats.h.

â—† TiledTexturePipeline

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

Definition at line 141 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 319 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

Definition at line 42 of file image.h.

â—† UniqueEGLImageKHR

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

Definition at line 261 of file content_context.h.

â—† Vector2

using impeller::Vector2 = typedef Point

Definition at line 320 of file point.h.

â—† VS

using impeller::VS = typedef SolidFillVertexShader

Definition at line 15 of file stroke_path_geometry.cc.

â—† WaitSet

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

Definition at line 25 of file fence_waiter_vk.h.

â—† YUVConversionDescriptorVK

using impeller::YUVConversionDescriptorVK = typedef vk::StructureChain<vk::SamplerYcbcrConversionCreateInfo >

A descriptor used to create a new YUV conversion in a conversion library.

Definition at line 30 of file yuv_conversion_vk.h.

â—† YUVToRGBFilterPipeline

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

Definition at line 179 of file content_context.h.

Enumeration Type Documentation

â—† ArchiveRenderingBackend

Enumerator
kMetal 
kVulkan 
kOpenGLES 

Definition at line 16 of file shader_archive_types.h.

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

â—† ArchiveShaderType

Enumerator
kVertex 
kFragment 
kCompute 

Definition at line 10 of file shader_archive_types.h.

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

â—† BlendFactor

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

Definition at line 179 of file formats.h.

â—† 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,
67  kSourceIn,
69  kSourceOut,
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,
85  kColorBurn,
86  kHardLight,
87  kSoftLight,
89  kExclusion,
90  kMultiply,
91  kHue,
93  kColor,
95 
97 };

â—† BlendOperation

Enumerator
kAdd 
kSubtract 
kReverseSubtract 

Definition at line 197 of file formats.h.

197  {
198  kAdd,
199  kSubtract,
201 };

â—† BlendSelectValues

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,
21  kColorBurn,
22  kHardLight,
23  kSoftLight,
25  kExclusion,
26  kMultiply,
27  kHue,
29  kColor,
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 
kDrawLine 
kDrawRect 
kDrawOval 
kDrawRRect 
kDrawCircle 
kDrawPoints 
kDrawImage 
kDrawImageRect 
kClipPath 
kClipRect 
kClipOval 
kClipRRect 
kDrawTextFrame 
kDrawVertices 
kDrawAtlas 

Definition at line 19 of file canvas_recorder.h.

19  : uint16_t {
20  kNew,
21  kSave,
22  kSaveLayer,
23  kRestore,
26  kTransform,
27  kConcat,
28  kPreConcat,
29  kTranslate,
30  kScale2,
31  kScale3,
32  kSkew,
33  kRotate,
34  kDrawPath,
35  kDrawPaint,
36  kDrawLine,
37  kDrawRect,
38  kDrawOval,
39  kDrawRRect,
42  kDrawImage,
44  kClipPath,
45  kClipRect,
46  kClipOval,
47  kClipRRect,
50  kDrawAtlas,
51 };

â—† Cap

enum impeller::Cap
strong
Enumerator
kButt 
kRound 
kSquare 

Definition at line 17 of file path.h.

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

â—† ColorWriteMaskBits

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

Definition at line 436 of file formats.h.

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

â—† 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 534 of file formats.h.

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

â—† CompressionType

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 };

â—† ContentBoundsPromise

Specifies how much to trust the bounds rectangle provided for a list of contents. Used by both |EntityPass| and |Canvas::SaveLayer|.

Enumerator
kUnknown 

The caller makes no claims related to the size of the bounds.

kContainsContents 

The caller claims the bounds are a reasonably tight estimate of the coverage of the contents and should contain all of the contents.

kMayClipContents 

The caller claims the bounds are a subset of an estimate of the reasonably tight bounds but likely clips off some of the contents.

Definition at line 28 of file entity_pass.h.

28  {
29  /// @brief The caller makes no claims related to the size of the bounds.
30  kUnknown,
31 
32  /// @brief The caller claims the bounds are a reasonably tight estimate
33  /// of the coverage of the contents and should contain all of the
34  /// contents.
36 
37  /// @brief The caller claims the bounds are a subset of an estimate of
38  /// the reasonably tight bounds but likely clips off some of the
39  /// contents.
41 };

â—† Convexity

enum impeller::Convexity
strong
Enumerator
kUnknown 
kConvex 

Definition at line 34 of file path.h.

34  {
35  kUnknown,
36  kConvex,
37 };

â—† CullMode

enum impeller::CullMode
strong
Enumerator
kNone 
kFrontFace 
kBackFace 

Definition at line 338 of file formats.h.

338  {
339  kNone,
340  kFrontFace,
341  kBackFace,
342 };

â—† DebugResourceType

Enumerator
kTexture 
kBuffer 
kProgram 
kShader 
kRenderBuffer 
kFrameBuffer 

Definition at line 220 of file proc_table_gles.h.

220  {
221  kTexture,
222  kBuffer,
223  kProgram,
224  kShader,
226  kFrameBuffer,
227 };

â—† DescriptorType

Enumerator
kUniformBuffer 
kStorageBuffer 
kSampledImage 
kImage 
kSampler 
kInputAttachment 

Definition at line 153 of file shader_types.h.

153  {
157  kImage,
158  kSampler,
160 };

â—† DeviceTypeVK

Enumerator
kUnknown 
kIntegratedGPU 

The device is an integrated GPU. Typically mobile GPUs.

kDiscreteGPU 

The device is a discrete GPU. Typically desktop GPUs.

kVirtualGPU 

The device is a GPU in a virtualized environment.

kCPU 

There is no GPU. Vulkan is implemented on the CPU. This is typically emulators like SwiftShader and LLVMPipe.

Definition at line 36 of file driver_info_vk.h.

36  {
37  kUnknown,
38  //----------------------------------------------------------------------------
39  /// The device is an integrated GPU. Typically mobile GPUs.
40  ///
42  //----------------------------------------------------------------------------
43  /// The device is a discrete GPU. Typically desktop GPUs.
44  ///
46  //----------------------------------------------------------------------------
47  /// The device is a GPU in a virtualized environment.
48  ///
50  //----------------------------------------------------------------------------
51  /// There is no GPU. Vulkan is implemented on the CPU. This is typically
52  /// emulators like SwiftShader and LLVMPipe.
53  ///
54  kCPU,
55 };

â—† FillType

enum impeller::FillType
strong
Enumerator
kNonZero 
kOdd 

Definition at line 29 of file path.h.

29  {
30  kNonZero, // The default winding order.
31  kOdd,
32 };

â—† GeometryVertexType

Enumerator
kPosition 
kColor 
kColor 
kUV 

Definition at line 49 of file geometry.h.

49  {
50  kPosition,
51  kColor,
52  kUV,
53 };

â—† 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,
29 };

â—† IndexType

enum impeller::IndexType
strong
Enumerator
kUnknown 
k16bit 
k32bit 
kNone 

Does not use the index buffer.

Definition at line 344 of file formats.h.

344  {
345  kUnknown,
346  k16bit,
347  k32bit,
348  /// Does not use the index buffer.
349  kNone,
350 };

â—† Join

enum impeller::Join
strong
Enumerator
kMiter 
kRound 
kBevel 

Definition at line 23 of file path.h.

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

â—† LoadAction

enum impeller::LoadAction
strong
Enumerator
kDontCare 
kLoad 
kClear 

Definition at line 203 of file formats.h.

203  {
204  kDontCare,
205  kLoad,
206  kClear,
207 };

â—† MinMagFilter

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

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

â—† 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 415 of file formats.h.

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

â—† MyMaskBits

enum impeller::MyMaskBits : uint32_t
strong
Enumerator
kFoo 
kBar 
kBaz 
kBang 

Definition at line 13 of file base_unittests.cc.

13  : uint32_t {
14  kFoo = 0,
15  kBar = 1 << 0,
16  kBaz = 1 << 1,
17  kBang = 1 << 2,
18 };

â—† OptionalDeviceExtensionVK

enum impeller::OptionalDeviceExtensionVK : uint32_t
strong

A device extension enabled if available. Subsystems cannot assume availability and must check if these extensions are available.

See also
CapabilitiesVK::HasExtension.
Enumerator
kEXTPipelineCreationFeedback 

To instrument and profile PSO creation.

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_pipeline_creation_feedback.html

kVKKHRPortabilitySubset 

To enable context creation on MoltenVK. A non-conformant Vulkan implementation.

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_portability_subset.html

kLast 

Definition at line 91 of file capabilities_vk.h.

91  : uint32_t {
92  //----------------------------------------------------------------------------
93  /// To instrument and profile PSO creation.
94  ///
95  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_pipeline_creation_feedback.html
96  ///
98 
99  //----------------------------------------------------------------------------
100  /// To enable context creation on MoltenVK. A non-conformant Vulkan
101  /// implementation.
102  ///
103  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_portability_subset.html
104  ///
106 
107  kLast,
108 };

â—† 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 100 of file formats.h.

100  : uint8_t {
101  kUnknown,
102  kA8UNormInt,
103  kR8UNormInt,
111  kB10G10R10XR,
114  // Depth and stencil formats.
115  kS8UInt,
118 };

â—† PlaygroundBackend

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 41 of file canvas.h.

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

â—† PolygonMode

enum impeller::PolygonMode
strong
Enumerator
kFill 
kLine 

Definition at line 384 of file formats.h.

384  {
385  kFill,
386  kLine,
387 };

â—† 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 353 of file formats.h.

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

â—† RequiredAndroidDeviceExtensionVK

A device extension available on all Android platforms. Without the presence of these extensions on Android, context creation will fail.

Platform agnostic code can still check if these Android extensions are present.

Enumerator
kANDROIDExternalMemoryAndroidHardwareBuffer 

For importing hardware buffers used in external texture composition.

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_ANDROID_external_memory_android_hardware_buffer.html

kKHRSamplerYcbcrConversion 

Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_sampler_ycbcr_conversion.html

kKHRExternalMemory 

Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_memory.html

kEXTQueueFamilyForeign 

Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_queue_family_foreign.html

kKHRDedicatedAllocation 

Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_dedicated_allocation.html

kLast 

Definition at line 45 of file capabilities_vk.h.

45  : uint32_t {
46  //----------------------------------------------------------------------------
47  /// For importing hardware buffers used in external texture composition.
48  ///
49  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_ANDROID_external_memory_android_hardware_buffer.html
50  ///
52 
53  //----------------------------------------------------------------------------
54  /// Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.
55  ///
56  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_sampler_ycbcr_conversion.html
57  ///
59 
60  //----------------------------------------------------------------------------
61  /// Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.
62  ///
63  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_memory.html
64  ///
66 
67  //----------------------------------------------------------------------------
68  /// Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.
69  ///
70  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_queue_family_foreign.html
71  ///
73 
74  //----------------------------------------------------------------------------
75  /// Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.
76  ///
77  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_dedicated_allocation.html
78  ///
80 
81  kLast,
82 };

â—† RequiredCommonDeviceExtensionVK

A device extension available on all platforms. Without the presence of these extensions, context creation will fail.

Enumerator
kKHRSwapchain 

For displaying content in the window system.

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html

kLast 

Definition at line 26 of file capabilities_vk.h.

26  : uint32_t {
27  //----------------------------------------------------------------------------
28  /// For displaying content in the window system.
29  ///
30  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html
31  ///
33 
34  kLast,
35 };

â—† RuntimeShaderStage

Enumerator
kVertex 
kFragment 
kCompute 

Definition at line 28 of file runtime_types.h.

28  {
29  kVertex,
30  kFragment,
31  kCompute,
32 };

â—† RuntimeStageBackend

Enumerator
kSkSL 
kMetal 
kOpenGLES 
kVulkan 

Definition at line 15 of file runtime_types.h.

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

â—† RuntimeUniformType

Enumerator
kFloat 
kSampledImage 
kStruct 

Definition at line 22 of file runtime_types.h.

22  {
23  kFloat,
25  kStruct,
26 };

â—† SampleCount

enum impeller::SampleCount : uint8_t
strong
Enumerator
kCount1 
kCount4 

Definition at line 296 of file formats.h.

296  : uint8_t {
297  kCount1 = 1,
298  kCount4 = 4,
299 };

â—† SamplerAddressMode

Enumerator
kClampToEdge 
kRepeat 
kMirror 
kDecal 

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

Definition at line 423 of file formats.h.

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

â—† 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,
49  kSignedInt,
54  kHalfFloat,
55  kFloat,
56  kDouble,
57  kStruct,
58  kImage,
60  kSampler,
61 };

â—† SourceRectConstraint

Controls the behavior of the source rectangle given to DrawImageRect.

Enumerator
kFast 

Faster, but may sample outside the bounds of the source rectangle.

kStrict 

Sample only within the source rectangle. May be slower.

Definition at line 50 of file canvas.h.

50  {
51  /// @brief Faster, but may sample outside the bounds of the source rectangle.
52  kFast,
53 
54  /// @brief Sample only within the source rectangle. May be slower.
55  kStrict,
56 };

â—† 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 553 of file formats.h.

553  : uint8_t {
554  /// Don't modify the current stencil value.
555  kKeep,
556  /// Reset the stencil value to zero.
557  kZero,
558  /// Reset the stencil value to the reference value.
560  /// Increment the current stencil value by 1. Clamp it to the maximum.
562  /// Decrement the current stencil value by 1. Clamp it to zero.
564  /// Perform a logical bitwise invert on the current stencil value.
565  kInvert,
566  /// Increment the current stencil value by 1. If at maximum, set to zero.
568  /// Decrement the current stencil value by 1. If at zero, set to maximum.
570 };

â—† 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 33 of file formats.h.

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

â—† StoreAction

enum impeller::StoreAction
strong
Enumerator
kDontCare 
kStore 
kMultisampleResolve 
kStoreAndMultisampleResolve 

Definition at line 209 of file formats.h.

209  {
210  kDontCare,
211  kStore,
214 };

â—† TextureCoordinateSystem

Enumerator
kUploadFromHost 
kRenderToTexture 

Definition at line 328 of file formats.h.

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

â—† TextureType

enum impeller::TextureType
strong
Enumerator
kTexture2D 
kTexture2DMultisample 
kTextureCube 
kTextureExternalOES 

Definition at line 263 of file formats.h.

263  {
264  kTexture2D,
266  kTextureCube,
268 };

â—† TextureUsage

Enumerator
kUnknown 
kShaderRead 
kShaderWrite 
kRenderTarget 

Definition at line 301 of file formats.h.

301  {
302  kUnknown = 0,
303  kShaderRead = 1 << 0,
304  kShaderWrite = 1 << 1,
305  kRenderTarget = 1 << 2,
306 };

â—† UVMode

enum impeller::UVMode
strong
Enumerator
kNoUV 
kUVRect 
kUVRectTx 

Definition at line 100 of file geometry_benchmarks.cc.

100  {
101  kNoUV,
102  kUVRect,
103  kUVRectTx,
104 };

â—† VendorVK

enum impeller::VendorVK
strong
Enumerator
kUnknown 
kGoogle 

Includes the SwiftShader CPU implementation.

kQualcomm 
kARM 
kImgTec 
kPowerVR 
kAMD 
kNvidia 
kIntel 
kMesa 

Includes the LLVM Pipe CPU implementation.

kApple 

Includes Vulkan on Metal via MoltenVK.

Definition at line 13 of file driver_info_vk.h.

13  {
14  kUnknown,
15  //----------------------------------------------------------------------------
16  /// Includes the SwiftShader CPU implementation.
17  ///
18  kGoogle,
19  kQualcomm,
20  kARM,
21  kImgTec,
22  kPowerVR = kImgTec,
23  kAMD,
24  kNvidia,
25  kIntel,
26  //----------------------------------------------------------------------------
27  /// Includes the LLVM Pipe CPU implementation.
28  ///
29  kMesa,
30  //----------------------------------------------------------------------------
31  /// Includes Vulkan on Metal via MoltenVK.
32  ///
33  kApple,
34 };

â—† WindingOrder

Enumerator
kClockwise 
kCounterClockwise 

Definition at line 23 of file formats.h.

23  {
24  kClockwise,
26 };

â—† YUVColorSpace

Enumerator
kBT601LimitedRange 
kBT601FullRange 

Definition at line 55 of file color.h.

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

â—† AddMipmapGeneration()

fml::Status impeller::AddMipmapGeneration ( const std::shared_ptr< CommandBuffer > &  command_buffer,
const std::shared_ptr< Context > &  context,
const std::shared_ptr< Texture > &  texture 
)

Adds a blit command to the render pass.

Definition at line 11 of file texture_mipmap.cc.

14  {
15  std::shared_ptr<BlitPass> blit_pass = command_buffer->CreateBlitPass();
16  bool success = blit_pass->GenerateMipmap(texture);
17  if (!success) {
18  return fml::Status(fml::StatusCode::kUnknown, "");
19  }
20  success = blit_pass->EncodeCommands(context->GetResourceAllocator());
21  if (!success) {
22  return fml::Status(fml::StatusCode::kUnknown, "");
23  }
24  return fml::Status();
25 }

Referenced by impeller::InlinePassContext::EndPass(), and impeller::ContentContext::MakeSubpass().

â—† 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.value(), 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.value(), 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 = renderer.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 #ifdef IMPELLER_DEBUG
168  pass.SetCommandLabel(
169  SPrintF("Advanced Blend Filter (%s)", BlendModeToString(blend_mode)));
170 #endif // IMPELLER_DEBUG
171  pass.SetVertexBuffer(std::move(vtx_buffer));
172  pass.SetPipeline(pipeline);
173 
174  typename FS::BlendInfo blend_info;
175  typename VS::FrameInfo frame_info;
176 
177  auto dst_sampler_descriptor = dst_snapshot->sampler_descriptor;
178  if (renderer.GetDeviceCapabilities().SupportsDecalSamplerAddressMode()) {
179  dst_sampler_descriptor.width_address_mode = SamplerAddressMode::kDecal;
180  dst_sampler_descriptor.height_address_mode = SamplerAddressMode::kDecal;
181  }
182  const std::unique_ptr<const Sampler>& dst_sampler =
183  renderer.GetContext()->GetSamplerLibrary()->GetSampler(
184  dst_sampler_descriptor);
185  FS::BindTextureSamplerDst(pass, dst_snapshot->texture, dst_sampler);
186  frame_info.dst_y_coord_scale = dst_snapshot->texture->GetYCoordScale();
187  blend_info.dst_input_alpha =
188  absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
189  ? dst_snapshot->opacity
190  : 1.0;
191 
192  if (foreground_color.has_value()) {
193  blend_info.color_factor = 1;
194  blend_info.color = foreground_color.value();
195  // This texture will not be sampled from due to the color factor. But
196  // this is present so that validation doesn't trip on a missing
197  // binding.
198  FS::BindTextureSamplerSrc(pass, dst_snapshot->texture, dst_sampler);
199  } else {
200  auto src_sampler_descriptor = src_snapshot->sampler_descriptor;
201  if (renderer.GetDeviceCapabilities().SupportsDecalSamplerAddressMode()) {
202  src_sampler_descriptor.width_address_mode = SamplerAddressMode::kDecal;
203  src_sampler_descriptor.height_address_mode = SamplerAddressMode::kDecal;
204  }
205  const std::unique_ptr<const Sampler>& src_sampler =
206  renderer.GetContext()->GetSamplerLibrary()->GetSampler(
207  src_sampler_descriptor);
208  blend_info.color_factor = 0;
209  blend_info.src_input_alpha = src_snapshot->opacity;
210  FS::BindTextureSamplerSrc(pass, src_snapshot->texture, src_sampler);
211  frame_info.src_y_coord_scale = src_snapshot->texture->GetYCoordScale();
212  }
213  auto blend_uniform = host_buffer.EmplaceUniform(blend_info);
214  FS::BindBlendInfo(pass, blend_uniform);
215 
216  frame_info.mvp = pass.GetOrthographicTransform() *
217  Matrix::MakeTranslation(coverage.GetOrigin() -
218  subpass_coverage.GetOrigin());
219 
220  auto uniform_view = host_buffer.EmplaceUniform(frame_info);
221  VS::BindFrameInfo(pass, uniform_view);
222 
223  return pass.Draw().ok();
224  };
225 
226  fml::StatusOr<RenderTarget> render_target = renderer.MakeSubpass(
227  "Advanced Blend Filter", ISize(subpass_coverage.GetSize()), callback);
228  if (!render_target.ok()) {
229  return std::nullopt;
230  }
231 
232  return Entity::FromSnapshot(
233  Snapshot{
234  .texture = render_target.value().GetRenderTargetTexture(),
235  .transform = Matrix::MakeTranslation(subpass_coverage.GetOrigin()),
236  // Since we absorbed the transform of the inputs and used the
237  // respective snapshot sampling modes when blending, pass on
238  // the default NN clamp sampler.
239  .sampler_descriptor = {},
240  .opacity = (absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
241  ? 1.0f
242  : dst_snapshot->opacity) *
243  alpha.value_or(1.0)},
244  entity.GetBlendMode(), entity.GetClipDepth());
245 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), BlendModeToString(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), 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::ContentContext::GetTransientsBuffer(), impeller::TRect< T >::Intersection(), kDecal, kSource, kTriangleStrip, impeller::ColorFilterContents::kYes, impeller::ContentContext::MakeSubpass(), impeller::Matrix::MakeTranslation(), OptionsFromPass(), SPrintF(), impeller::Capabilities::SupportsDecalSamplerAddressMode(), and impeller::Snapshot::texture.

â—† API_AVAILABLE()

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

Definition at line 17 of file command_buffer_mtl.mm.

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

â—† 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().

â—† ApplyBlendedColor()

static constexpr Color impeller::ApplyBlendedColor ( Color  dst,
Color  src,
Vector3  blend_result 
)
inlinestaticconstexpr

Composite a blended color onto the destination. All three parameters are unpremultiplied. Returns a premultiplied result.

This routine is the same as IPApplyBlendedColor in the Impeller shader library.

Definition at line 201 of file color.cc.

203  {
204  dst = dst.Premultiply();
205  src =
206  // Use the blended color for areas where the source and destination
207  // colors overlap.
208  FromRGB(blend_result, src.alpha * dst.alpha).Premultiply() +
209  // Use the original source color for any remaining non-overlapping areas.
210  src.Premultiply() * (1.0f - dst.alpha);
211 
212  // Source-over composite the blended source color atop the destination.
213  return src + dst * (1.0f - src.alpha);
214 }

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

Referenced by DoColorBlend(), and DoColorBlendComponents().

â—† 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::ToLinearPathComponents().

â—† 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=("
109  attachment.texture->GetTextureDescriptor())
110  << "),";
111  }
112  if (attachment.resolve_texture) {
113  stream << "ResolveTexture=("
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 229 of file proc_table_gles.cc.

229  {
230  switch (type) {
231  case GL_RENDERBUFFER:
232  return "GL_RENDERBUFFER";
233  case GL_TEXTURE:
234  return "GL_TEXTURE";
235  case GL_NONE:
236  return "GL_NONE";
237  }
238 
239  return "Unknown Type";
240 }

Referenced by DescribeFramebufferAttachment().

â—† BENCHMARK_CAPTURE() [1/12]

impeller::BENCHMARK_CAPTURE ( BM_CanvasRecord  ,
draw_circle  ,
DrawCircle 
)

â—† BENCHMARK_CAPTURE() [2/12]

impeller::BENCHMARK_CAPTURE ( BM_CanvasRecord  ,
draw_line  ,
DrawLine 
)

â—† BENCHMARK_CAPTURE() [3/12]

impeller::BENCHMARK_CAPTURE ( BM_CanvasRecord  ,
draw_rect  ,
DrawRect 
)

â—† BENCHMARK_CAPTURE() [4/12]

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

â—† BENCHMARK_CAPTURE() [5/12]

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

â—† BENCHMARK_CAPTURE() [6/12]

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

â—† BENCHMARK_CAPTURE() [7/12]

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

â—† BENCHMARK_CAPTURE() [8/12]

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

â—† BENCHMARK_CAPTURE() [9/12]

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

â—† BENCHMARK_CAPTURE() [10/12]

impeller::BENCHMARK_CAPTURE ( BM_Polyline  ,
unclosed_cubic_polyline_tess  ,
CreateCubic(false)  ,
true   
)

â—† BENCHMARK_CAPTURE() [11/12]

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

â—† BENCHMARK_CAPTURE() [12/12]

impeller::BENCHMARK_CAPTURE ( BM_Polyline  ,
unclosed_quad_polyline_tess  ,
CreateQuadratic(false)  ,
true   
)

â—† Bind() [1/2]

static bool impeller::Bind ( PassBindingsCacheMTL pass,
ShaderStage  stage,
size_t  bind_index,
const BufferView view 
)
static

Definition at line 189 of file render_pass_mtl.mm.

192  {
193  if (!view.buffer) {
194  return false;
195  }
196 
197  auto device_buffer = view.buffer;
198  if (!device_buffer) {
199  return false;
200  }
201 
202  auto buffer = DeviceBufferMTL::Cast(*device_buffer).GetMTLBuffer();
203  // The Metal call is a void return and we don't want to make it on nil.
204  if (!buffer) {
205  return false;
206  }
207 
208  return pass.SetBuffer(stage, bind_index, view.range.offset, buffer);
209 }

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

â—† Bind() [2/2]

static bool impeller::Bind ( PassBindingsCacheMTL pass,
ShaderStage  stage,
size_t  bind_index,
const std::unique_ptr< const Sampler > &  sampler,
const Texture texture 
)
static

Definition at line 211 of file render_pass_mtl.mm.

215  {
216  if (!sampler || !texture.IsValid()) {
217  return false;
218  }
219 
220  if (texture.NeedsMipmapGeneration()) {
221  // TODO(127697): generate mips when the GPU is available on iOS.
222 #if !FML_OS_IOS
224  << "Texture at binding index " << bind_index
225  << " has a mip count > 1, but the mipmap has not been generated.";
226  return false;
227 #endif // !FML_OS_IOS
228  }
229 
230  return pass.SetTexture(stage, bind_index,
231  TextureMTL::Cast(texture).GetMTLTexture()) &&
232  pass.SetSampler(stage, bind_index,
233  SamplerMTL::Cast(*sampler).GetMTLSamplerState());
234 }

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

â—† BlendModeToString()

const char * impeller::BlendModeToString ( BlendMode  blend_mode)

Definition at line 47 of file color.cc.

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

References kBlendModeNames.

Referenced by AdvancedBlend(), PipelineBlend(), impeller::AtlasContents::Render(), 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 151 of file geometry_benchmarks.cc.

151  {
152  auto args_tuple = std::make_tuple(std::move(args)...);
153  auto path = std::get<Path>(args_tuple);
154 
155  size_t point_count = 0u;
156  size_t single_point_count = 0u;
157  auto points = std::make_unique<std::vector<Point>>();
158  points->reserve(2048);
159  while (state.KeepRunning()) {
160  auto points = tess.TessellateConvex(path, 1.0f);
161  single_point_count = points.size();
162  point_count += points.size();
163  }
164  state.counters["SinglePointCount"] = single_point_count;
165  state.counters["TotalPointCount"] = point_count;
166 }

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

59  {
60  auto args_tuple = std::make_tuple(std::move(args)...);
61  auto path = std::get<Path>(args_tuple);
62  bool tessellate = std::get<bool>(args_tuple);
63 
64  size_t point_count = 0u;
65  size_t single_point_count = 0u;
66  auto points = std::make_unique<std::vector<Point>>();
67  points->reserve(2048);
68  while (state.KeepRunning()) {
69  if (tessellate) {
70  tess.Tessellate(path, 1.0f,
71  [&point_count, &single_point_count](
72  const float* vertices, size_t vertices_count,
73  const uint16_t* indices, size_t indices_count) {
74  if (indices_count > 0) {
75  single_point_count = indices_count;
76  point_count += indices_count;
77  } else {
78  single_point_count = vertices_count;
79  point_count += vertices_count;
80  }
81  return true;
82  });
83  } else {
84  auto polyline = path.CreatePolyline(
85  // Clang-tidy doesn't know that the points get moved back before
86  // getting moved again in this loop.
87  // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
88  1.0f, std::move(points),
89  [&points](Path::Polyline::PointBufferPtr reclaimed) {
90  points = std::move(reclaimed);
91  });
92  single_point_count = polyline.points->size();
93  point_count += single_point_count;
94  }
95  }
96  state.counters["SinglePointCount"] = single_point_count;
97  state.counters["TotalPointCount"] = point_count;
98 }

References impeller::Path::Polyline::points, polyline, tess, and impeller::Tessellator::Tessellate().

â—† BM_StrokePolyline()

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

Definition at line 107 of file geometry_benchmarks.cc.

107  {
108  auto args_tuple = std::make_tuple(std::move(args)...);
109  auto path = std::get<Path>(args_tuple);
110  auto cap = std::get<Cap>(args_tuple);
111  auto join = std::get<Join>(args_tuple);
112  auto generate_uv = std::get<UVMode>(args_tuple);
113 
114  const Scalar stroke_width = 5.0f;
115  const Scalar miter_limit = 10.0f;
116  const Scalar scale = 1.0f;
117  const Point texture_origin = Point(0, 0);
118  const Size texture_size = Size(100, 100);
119  const Matrix effect_transform = (generate_uv == UVMode::kUVRectTx)
120  ? Matrix::MakeScale({2.0f, 2.0f, 1.0f})
121  : Matrix();
122 
123  auto points = std::make_unique<std::vector<Point>>();
124  points->reserve(2048);
125  auto polyline =
126  path.CreatePolyline(1.0f, std::move(points),
127  [&points](Path::Polyline::PointBufferPtr reclaimed) {
128  points = std::move(reclaimed);
129  });
130 
131  size_t point_count = 0u;
132  size_t single_point_count = 0u;
133  while (state.KeepRunning()) {
134  if (generate_uv == UVMode::kNoUV) {
135  auto vertices = ImpellerBenchmarkAccessor::GenerateSolidStrokeVertices(
136  polyline, stroke_width, miter_limit, join, cap, scale);
137  single_point_count = vertices.size();
138  } else {
139  auto vertices = ImpellerBenchmarkAccessor::GenerateSolidStrokeVerticesUV(
140  polyline, stroke_width, miter_limit, join, cap, scale, //
141  texture_origin, texture_size, effect_transform);
142  single_point_count = vertices.size();
143  }
144  point_count += single_point_count;
145  }
146  state.counters["SinglePointCount"] = single_point_count;
147  state.counters["TotalPointCount"] = point_count;
148 }

References impeller::ImpellerBenchmarkAccessor::GenerateSolidStrokeVertices(), impeller::ImpellerBenchmarkAccessor::GenerateSolidStrokeVerticesUV(), kNoUV, kUVRectTx, impeller::Matrix::MakeScale(), polyline, scale, and stroke_width.

â—† BytesPerPixelForPixelFormat()

constexpr size_t impeller::BytesPerPixelForPixelFormat ( PixelFormat  format)
constexpr

Definition at line 448 of file formats.h.

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

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 80 of file typographer_context_skia.cc.

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

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

240  {
241  switch (action) {
242  case LoadAction::kLoad:
243  return false;
244  case LoadAction::kDontCare:
245  case LoadAction::kClear:
246  return true;
247  }
248  FML_UNREACHABLE();
249 }

References kClear, kDontCare, and kLoad.

â—† CanDiscardAttachmentWhenDone()

constexpr bool impeller::CanDiscardAttachmentWhenDone ( StoreAction  action)
constexpr

Definition at line 251 of file formats.h.

251  {
252  switch (action) {
253  case StoreAction::kStore:
254  case StoreAction::kStoreAndMultisampleResolve:
255  return false;
256  case StoreAction::kDontCare:
257  case StoreAction::kMultisampleResolve:
258  return true;
259  }
260  FML_UNREACHABLE();
261 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

â—† ChooseAlphaCompositionMode()

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

Definition at line 101 of file khr_swapchain_impl_vk.cc.

102  {
103  if (flags & vk::CompositeAlphaFlagBitsKHR::eInherit) {
104  return vk::CompositeAlphaFlagBitsKHR::eInherit;
105  }
106  if (flags & vk::CompositeAlphaFlagBitsKHR::ePreMultiplied) {
107  return vk::CompositeAlphaFlagBitsKHR::ePreMultiplied;
108  }
109  if (flags & vk::CompositeAlphaFlagBitsKHR::ePostMultiplied) {
110  return vk::CompositeAlphaFlagBitsKHR::ePostMultiplied;
111  }
112  if (flags & vk::CompositeAlphaFlagBitsKHR::eOpaque) {
113  return vk::CompositeAlphaFlagBitsKHR::eOpaque;
114  }
115 
116  return std::nullopt;
117 }

â—† ChooseSurfaceFormat()

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

Definition at line 79 of file khr_swapchain_impl_vk.cc.

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

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::MaskBlurVariantTest(), 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 410 of file color.cc.

410  {
411  return SPrintF("R=%.1f,G=%.1f,B=%.1f,A=%.1f", //
412  color.red, //
413  color.green, //
414  color.blue, //
415  color.alpha //
416  );
417 }

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::saturated::b, 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 318 of file tessellator.cc.

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

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

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

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_bounds,
Matrix  effect_transform,
const ContentContext renderer,
const Entity entity,
RenderPass pass 
)

Computes geometry and UV coordinates for a rectangle to be rendered.

UV is the horizontal and vertical coordinates within the texture.

Parameters
source_rectThe rectangle to be rendered.
texture_boundsThe local space bounding box of the geometry.
effect_transformThe transform to apply to the UV coordinates.
rendererThe content context to use for allocating buffers.
entityThe entity to use for the transform.
passThe render pass to use for the transform.

Definition at line 113 of file geometry.cc.

118  {
119  auto& host_buffer = renderer.GetTransientsBuffer();
120 
121  // Calculate UV-specific transform based on texture coverage and effect.
122  // For example, if the texture is 100x100 and the effect transform is
123  // scaling by 2.0, texture_bounds.GetNormalizingTransform() will result in a
124  // Matrix that scales by 0.01, and then if the effect_transform is
125  // Matrix::MakeScale(Vector2{2, 2}), the resulting uv_transform will have x
126  // and y basis vectors with scale 0.02.
127  auto uv_transform = texture_bounds.GetNormalizingTransform() * //
128  effect_transform;
129 
130  // Allocate space for vertex and UV data (4 vertices)
131  // 0: position
132  // 1: UV
133  // 2: position
134  // 3: UV
135  // etc.
136  Point data[8];
137 
138  // Get the raw points from the rect and transform them into UV space.
139  auto points = source_rect.GetPoints();
140  for (auto i = 0u, j = 0u; i < 8; i += 2, j++) {
141  // Store original coordinates.
142  data[i] = points[j];
143 
144  // Store transformed UV coordinates.
145  data[i + 1] = uv_transform * points[j];
146  }
147 
148  return GeometryResult{
149  .type = PrimitiveType::kTriangleStrip,
150  .vertex_buffer =
151  {
152  .vertex_buffer = host_buffer.Emplace(
153  /*buffer=*/data,
154  /*length=*/16 * sizeof(float),
155  /*align=*/alignof(float)),
156  .vertex_count = 4,
157  .index_type = IndexType::kNone,
158  },
159  .transform = entity.GetShaderTransform(pass),
160  };
161 }

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

Referenced by impeller::RectGeometry::GetPositionUVBuffer().

â—† ConfigureAttachment()

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

Definition at line 56 of file render_pass_mtl.mm.

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

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 = [](ColorWriteMask mask,
63  ColorWriteMask check) -> GLboolean {
64  return (mask & check) ? GL_TRUE : GL_FALSE;
65  };
66 
67  gl.ColorMask(
68  is_set(color->write_mask, ColorWriteMaskBits::kRed), // red
69  is_set(color->write_mask, ColorWriteMaskBits::kGreen), // green
70  is_set(color->write_mask, ColorWriteMaskBits::kBlue), // blue
71  is_set(color->write_mask, ColorWriteMaskBits::kAlpha) // alpha
72  );
73  }
74 }

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

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

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

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

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::AttachmentType::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 framebuffer.";
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 27 of file render_pass_mtl.mm.

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

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

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

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

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

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

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

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 74 of file khr_swapchain_impl_vk.cc.

75  {
76  return std::find(formats.begin(), formats.end(), format) != formats.end();
77 }

Referenced by ChooseSurfaceFormat().

â—† CreateAtlasBitmap() [1/2]

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

Definition at line 217 of file typographer_context_skia.cc.

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

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

â—† CreateBufferPool()

static PoolVMA impeller::CreateBufferPool ( VmaAllocator  allocator)
static

Definition at line 55 of file allocator_vk.cc.

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

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

â—† CreateCommandBuffer()

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

Definition at line 117 of file command_buffer_mtl.mm.

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

â—† CreateCompatRenderPassForPipeline()

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

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

Definition at line 125 of file pipeline_vk.cc.

127  {
128  RenderPassBuilderVK builder;
129 
130  for (const auto& [bind_point, color] : desc.GetColorAttachmentDescriptors()) {
131  builder.SetColorAttachment(bind_point, //
132  color.format, //
133  desc.GetSampleCount(), //
134  LoadAction::kDontCare, //
135  StoreAction::kDontCare //
136  );
137  }
138 
139  if (auto depth = desc.GetDepthStencilAttachmentDescriptor();
140  depth.has_value()) {
141  builder.SetDepthStencilAttachment(desc.GetDepthPixelFormat(), //
142  desc.GetSampleCount(), //
143  LoadAction::kDontCare, //
144  StoreAction::kDontCare //
145  );
146  } else if (desc.HasStencilAttachmentDescriptors()) {
147  builder.SetStencilAttachment(desc.GetStencilPixelFormat(), //
148  desc.GetSampleCount(), //
149  LoadAction::kDontCare, //
150  StoreAction::kDontCare //
151  );
152  }
153 
154  auto pass = builder.Build(device);
155  if (!pass) {
156  VALIDATION_LOG << "Failed to create render pass for pipeline: "
157  << desc.GetLabel();
158  return {};
159  }
160 
161  ContextVK::SetDebugName(device, pass.get(),
162  "Compat Render Pass: " + desc.GetLabel());
163 
164  return pass;
165 }

References impeller::RenderPassBuilderVK::Build(), impeller::PipelineDescriptor::GetColorAttachmentDescriptors(), impeller::PipelineDescriptor::GetDepthPixelFormat(), impeller::PipelineDescriptor::GetDepthStencilAttachmentDescriptor(), impeller::PipelineDescriptor::GetLabel(), impeller::PipelineDescriptor::GetSampleCount(), impeller::PipelineDescriptor::GetStencilPixelFormat(), impeller::PipelineDescriptor::HasStencilAttachmentDescriptors(), kDontCare, impeller::RenderPassBuilderVK::SetColorAttachment(), impeller::ContextVK::SetDebugName(), impeller::RenderPassBuilderVK::SetDepthStencilAttachment(), impeller::RenderPassBuilderVK::SetStencilAttachment(), and VALIDATION_LOG.

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

â—† CreateDefaultPipeline()

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

Definition at line 232 of file content_context.cc.

233  {
234  auto desc = PipelineT::Builder::MakeDefaultPipelineDescriptor(context);
235  if (!desc.has_value()) {
236  return nullptr;
237  }
238  // Apply default ContentContextOptions to the descriptor.
239  const auto default_color_format =
240  context.GetCapabilities()->GetDefaultColorFormat();
241  ContentContextOptions{.sample_count = SampleCount::kCount4,
242  .primitive_type = PrimitiveType::kTriangleStrip,
243  .color_attachment_pixel_format = default_color_format}
244  .ApplyToPipelineDescriptor(*desc);
245  return std::make_unique<PipelineT>(context, desc);
246 }

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

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

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

209  {
210  auto command_queue = device.newCommandQueue;
211  if (!command_queue) {
212  VALIDATION_LOG << "Could not set up the command queue.";
213  return nullptr;
214  }
215  command_queue.label = @"Impeller Command Queue";
216  return command_queue;
217 }

References VALIDATION_LOG.

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

â—† CreateMetalDevice()

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

Definition at line 205 of file context_mtl.mm.

205  {
206  return ::MTLCreateSystemDefaultDevice();
207 }

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

â—† CreateRenderTarget()

static EntityPassTarget impeller::CreateRenderTarget ( ContentContext renderer,
ISize  size,
int  mip_count,
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 315 of file entity_pass.cc.

318  {
319  const std::shared_ptr<Context>& context = renderer.GetContext();
320 
321  /// All of the load/store actions are managed by `InlinePassContext` when
322  /// `RenderPasses` are created, so we just set them to `kDontCare` here.
323  /// What's important is the `StorageMode` of the textures, which cannot be
324  /// changed for the lifetime of the textures.
325 
326  if (context->GetBackendType() == Context::BackendType::kOpenGLES) {
327  // TODO(https://github.com/flutter/flutter/issues/141732): Implement mip map
328  // generation on opengles.
329  mip_count = 1;
330  }
331 
332  RenderTarget target;
333  if (context->GetCapabilities()->SupportsOffscreenMSAA()) {
334  target = renderer.GetRenderTargetCache()->CreateOffscreenMSAA(
335  /*context=*/*context,
336  /*size=*/size,
337  /*mip_count=*/mip_count,
338  /*label=*/"EntityPass",
339  /*color_attachment_config=*/
340  RenderTarget::AttachmentConfigMSAA{
341  .storage_mode = StorageMode::kDeviceTransient,
342  .resolve_storage_mode = StorageMode::kDevicePrivate,
343  .load_action = LoadAction::kDontCare,
344  .store_action = StoreAction::kMultisampleResolve,
345  .clear_color = clear_color},
346  /*stencil_attachment_config=*/
348  } else {
349  target = renderer.GetRenderTargetCache()->CreateOffscreen(
350  *context, // context
351  size, // size
352  /*mip_count=*/mip_count,
353  "EntityPass", // label
354  RenderTarget::AttachmentConfig{
355  .storage_mode = StorageMode::kDevicePrivate,
356  .load_action = LoadAction::kDontCare,
357  .store_action = StoreAction::kDontCare,
358  .clear_color = clear_color,
359  }, // color_attachment_config
360  kDefaultStencilConfig // stencil_attachment_config
361  );
362  }
363 
364  return EntityPassTarget(
365  target, renderer.GetDeviceCapabilities().SupportsReadFromResolve(),
366  renderer.GetDeviceCapabilities().SupportsImplicitResolvingMSAA());
367 }

References impeller::ContentContext::GetContext(), impeller::ContentContext::GetDeviceCapabilities(), impeller::ContentContext::GetRenderTargetCache(), kDefaultStencilConfig, kDevicePrivate, kDeviceTransient, kDontCare, kMultisampleResolve, impeller::Context::kOpenGLES, impeller::RenderTarget::AttachmentConfig::storage_mode, impeller::RenderTarget::AttachmentConfigMSAA::storage_mode, impeller::Capabilities::SupportsImplicitResolvingMSAA(), and impeller::Capabilities::SupportsReadFromResolve().

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

â—† CreateSampler()

static vk::UniqueSampler impeller::CreateSampler ( const vk::Device &  device,
const SamplerDescriptor desc,
const std::shared_ptr< YUVConversionVK > &  yuv_conversion 
)
static

Definition at line 13 of file sampler_vk.cc.

16  {
17  const auto mip_map = ToVKSamplerMipmapMode(desc.mip_filter);
18 
19  const auto min_filter = ToVKSamplerMinMagFilter(desc.min_filter);
20  const auto mag_filter = ToVKSamplerMinMagFilter(desc.mag_filter);
21 
22  const auto address_mode_u = ToVKSamplerAddressMode(desc.width_address_mode);
23  const auto address_mode_v = ToVKSamplerAddressMode(desc.height_address_mode);
24  const auto address_mode_w = ToVKSamplerAddressMode(desc.depth_address_mode);
25 
26  vk::StructureChain<vk::SamplerCreateInfo,
27  // For VK_KHR_sampler_ycbcr_conversion
28  vk::SamplerYcbcrConversionInfo>
29  sampler_chain;
30 
31  auto& sampler_info = sampler_chain.get();
32 
33  sampler_info.magFilter = mag_filter;
34  sampler_info.minFilter = min_filter;
35  sampler_info.addressModeU = address_mode_u;
36  sampler_info.addressModeV = address_mode_v;
37  sampler_info.addressModeW = address_mode_w;
38  sampler_info.borderColor = vk::BorderColor::eFloatTransparentBlack;
39  sampler_info.mipmapMode = mip_map;
40 
41  if (yuv_conversion && yuv_conversion->IsValid()) {
42  sampler_chain.get<vk::SamplerYcbcrConversionInfo>().conversion =
43  yuv_conversion->GetConversion();
44 
45  //
46  // TL;DR: When using YUV conversion, our samplers are somewhat hobbled and
47  // not all options configurable in Impeller (especially the linear
48  // filtering which is by far the most used form of filtering) can be
49  // supported. Switch to safe defaults.
50  //
51  // Spec: If sampler Y'CBCR conversion is enabled and the potential format
52  // features of the sampler Y'CBCR conversion do not support or enable
53  // separate reconstruction filters, minFilter and magFilter must be equal to
54  // the sampler Y'CBCR conversion's chromaFilter.
55  //
56  // Thing is, we don't enable separate reconstruction filters. By the time we
57  // are here, we also don't have access to the descriptor used to create this
58  // conversion. So we don't yet know what the chromaFilter is. But eNearest
59  // is a safe bet since the `AndroidHardwareBufferTextureSourceVK` defaults
60  // to that safe value. So just use that.
61  //
62  // See the validation VUID-VkSamplerCreateInfo-minFilter-01645 for more.
63  //
64  sampler_info.magFilter = vk::Filter::eNearest;
65  sampler_info.minFilter = vk::Filter::eNearest;
66 
67  // Spec: If sampler Y′CBCR conversion is enabled, addressModeU,
68  // addressModeV, and addressModeW must be
69  // VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, anisotropyEnable must be VK_FALSE,
70  // and unnormalizedCoordinates must be VK_FALSE.
71  //
72  // See the validation VUID-VkSamplerCreateInfo-addressModeU-01646 for more.
73  //
74  sampler_info.addressModeU = vk::SamplerAddressMode::eClampToEdge;
75  sampler_info.addressModeV = vk::SamplerAddressMode::eClampToEdge;
76  sampler_info.addressModeW = vk::SamplerAddressMode::eClampToEdge;
77  sampler_info.anisotropyEnable = false;
78  sampler_info.unnormalizedCoordinates = false;
79  } else {
80  sampler_chain.unlink<vk::SamplerYcbcrConversionInfo>();
81  }
82 
83  auto sampler = device.createSamplerUnique(sampler_chain.get());
84  if (sampler.result != vk::Result::eSuccess) {
85  VALIDATION_LOG << "Could not create sampler: "
86  << vk::to_string(sampler.result);
87  return {};
88  }
89 
90  if (!desc.label.empty()) {
91  ContextVK::SetDebugName(device, sampler.value.get(), desc.label.c_str());
92  }
93 
94  return std::move(sampler.value);
95 }

References impeller::SamplerDescriptor::depth_address_mode, impeller::SamplerDescriptor::height_address_mode, impeller::SamplerDescriptor::label, impeller::SamplerDescriptor::mag_filter, impeller::SamplerDescriptor::min_filter, impeller::SamplerDescriptor::mip_filter, impeller::ContextVK::SetDebugName(), ToVKSamplerAddressMode(), ToVKSamplerMinMagFilter(), ToVKSamplerMipmapMode(), VALIDATION_LOG, and impeller::SamplerDescriptor::width_address_mode.

â—† CreateTextureForDecompressedImage()

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

Definition at line 393 of file playground.cc.

396  {
397  auto texture_descriptor = TextureDescriptor{};
398  texture_descriptor.storage_mode = StorageMode::kHostVisible;
399  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
400  texture_descriptor.size = decompressed_image.GetSize();
401  texture_descriptor.mip_count =
402  enable_mipmapping ? decompressed_image.GetSize().MipCount() : 1u;
403 
404  auto texture =
405  context->GetResourceAllocator()->CreateTexture(texture_descriptor);
406  if (!texture) {
407  VALIDATION_LOG << "Could not allocate texture for fixture.";
408  return nullptr;
409  }
410 
411  auto uploaded = texture->SetContents(decompressed_image.GetAllocation());
412  if (!uploaded) {
413  VALIDATION_LOG << "Could not upload texture to device memory for fixture.";
414  return nullptr;
415  }
416  if (enable_mipmapping) {
417  auto command_buffer = context->CreateCommandBuffer();
418  if (!command_buffer) {
419  FML_DLOG(ERROR)
420  << "Could not create command buffer for mipmap generation.";
421  return nullptr;
422  }
423  command_buffer->SetLabel("Mipmap Command Buffer");
424  auto blit_pass = command_buffer->CreateBlitPass();
425  blit_pass->SetLabel("Mipmap Blit Pass");
426  blit_pass->GenerateMipmap(texture);
427  blit_pass->EncodeCommands(context->GetResourceAllocator());
428  if (!context->GetCommandQueue()->Submit({command_buffer}).ok()) {
429  FML_DLOG(ERROR) << "Failed to submit blit pass command buffer.";
430  return nullptr;
431  }
432  }
433  return texture;
434 }

References impeller::DecompressedImage::GetAllocation(), impeller::DecompressedImage::GetSize(), kHostVisible, kR8G8B8A8UNormInt, impeller::TSize< T >::MipCount(), 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 84 of file buffer_bindings_gles.cc.

85  {
86  return NormalizeUniformKey(non_struct_member);
87 }

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

70  {
71  std::string result;
72  result.reserve(struct_name.length() + member.length() + (is_array ? 4 : 1));
73  result += struct_name;
74  if (!member.empty()) {
75  result += '.';
76  result += member;
77  }
78  if (is_array) {
79  result += "[0]";
80  }
81  return NormalizeUniformKey(result);
82 }

References NormalizeUniformKey().

â—† CreateVKImageView()

static vk::UniqueImageView impeller::CreateVKImageView ( const vk::Device &  device,
const vk::Image &  image,
const vk::SamplerYcbcrConversion &  yuv_conversion,
const AHBProperties ahb_props,
const AHardwareBuffer_Desc &  ahb_desc 
)
static

Definition at line 170 of file ahb_texture_source_vk.cc.

175  {
176  const auto& ahb_format =
177  ahb_props.get<vk::AndroidHardwareBufferFormatPropertiesANDROID>();
178 
179  vk::StructureChain<vk::ImageViewCreateInfo,
180  // Core in 1.1
181  vk::SamplerYcbcrConversionInfo>
182  view_chain;
183 
184  auto& view_info = view_chain.get();
185 
186  view_info.image = image;
187  view_info.viewType = vk::ImageViewType::e2D;
188  view_info.format = ahb_format.format;
189  view_info.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
190  view_info.subresourceRange.baseMipLevel = 0u;
191  view_info.subresourceRange.baseArrayLayer = 0u;
192  view_info.subresourceRange.levelCount =
193  (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE)
194  ? ISize{ahb_desc.width, ahb_desc.height}.MipCount()
195  : 1u;
196  view_info.subresourceRange.layerCount = ahb_desc.layers;
197 
198  // We need a custom YUV conversion only if we don't recognize the format.
199  if (view_info.format == vk::Format::eUndefined) {
200  view_chain.get<vk::SamplerYcbcrConversionInfo>().conversion =
201  yuv_conversion;
202  } else {
203  view_chain.unlink<vk::SamplerYcbcrConversionInfo>();
204  }
205 
206  auto image_view = device.createImageViewUnique(view_info);
207  if (image_view.result != vk::Result::eSuccess) {
208  VALIDATION_LOG << "Could not create external image view: "
209  << vk::to_string(image_view.result);
210  return {};
211  }
212 
213  return std::move(image_view.value);
214 }

References VALIDATION_LOG, and impeller::TSize< T >::width.

Referenced by impeller::AHBTextureSourceVK::AHBTextureSourceVK().

â—† CreateVKImageWrapperForAndroidHarwareBuffer()

static vk::UniqueImage impeller::CreateVKImageWrapperForAndroidHarwareBuffer ( const vk::Device &  device,
const AHBProperties ahb_props,
const AHardwareBuffer_Desc &  ahb_desc 
)
static

Definition at line 20 of file ahb_texture_source_vk.cc.

23  {
24  const auto& ahb_format =
25  ahb_props.get<vk::AndroidHardwareBufferFormatPropertiesANDROID>();
26 
27  vk::StructureChain<vk::ImageCreateInfo,
28  // For VK_KHR_external_memory
29  vk::ExternalMemoryImageCreateInfo,
30  // For VK_ANDROID_external_memory_android_hardware_buffer
31  vk::ExternalFormatANDROID>
32  image_chain;
33 
34  auto& image_info = image_chain.get<vk::ImageCreateInfo>();
35 
36  vk::ImageUsageFlags image_usage_flags;
37  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE) {
38  image_usage_flags |= vk::ImageUsageFlagBits::eSampled;
39  }
40  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER) {
41  image_usage_flags |= vk::ImageUsageFlagBits::eColorAttachment;
42  }
43 
44  vk::ImageCreateFlags image_create_flags;
45  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT) {
46  image_create_flags |= vk::ImageCreateFlagBits::eProtected;
47  }
48  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP) {
49  image_create_flags |= vk::ImageCreateFlagBits::eCubeCompatible;
50  }
51 
52  image_info.imageType = vk::ImageType::e2D;
53  image_info.format = ahb_format.format;
54  image_info.extent.width = ahb_desc.width;
55  image_info.extent.height = ahb_desc.height;
56  image_info.extent.depth = 1;
57  image_info.mipLevels =
58  (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE)
59  ? ISize{ahb_desc.width, ahb_desc.height}.MipCount()
60  : 1u;
61  image_info.arrayLayers = ahb_desc.layers;
62  image_info.samples = vk::SampleCountFlagBits::e1;
63  image_info.tiling = vk::ImageTiling::eOptimal;
64  image_info.usage = image_usage_flags;
65  image_info.flags = image_create_flags;
66  image_info.sharingMode = vk::SharingMode::eExclusive;
67  image_info.initialLayout = vk::ImageLayout::eUndefined;
68 
69  image_chain.get<vk::ExternalMemoryImageCreateInfo>().handleTypes =
70  vk::ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID;
71 
72  // If the format isn't natively supported by Vulkan (i.e, be a part of the
73  // base vkFormat enum), an untyped "external format" must be specified when
74  // creating the image and the image views. Usually includes YUV formats.
75  if (ahb_format.format == vk::Format::eUndefined) {
76  image_chain.get<vk::ExternalFormatANDROID>().externalFormat =
77  ahb_format.externalFormat;
78  } else {
79  image_chain.unlink<vk::ExternalFormatANDROID>();
80  }
81 
82  auto image = device.createImageUnique(image_chain.get());
83  if (image.result != vk::Result::eSuccess) {
84  VALIDATION_LOG << "Could not create image for external buffer: "
85  << vk::to_string(image.result);
86  return {};
87  }
88 
89  return std::move(image.value);
90 }

References VALIDATION_LOG, and impeller::TSize< T >::width.

Referenced by impeller::AHBTextureSourceVK::AHBTextureSourceVK().

â—† CreateYUVConversion()

static std::shared_ptr<YUVConversionVK> impeller::CreateYUVConversion ( const ContextVK context,
const AHBProperties ahb_props 
)
static

Definition at line 136 of file ahb_texture_source_vk.cc.

138  {
139  YUVConversionDescriptorVK conversion_chain;
140 
141  const auto& ahb_format =
142  ahb_props.get<vk::AndroidHardwareBufferFormatPropertiesANDROID>();
143 
144  auto& conversion_info = conversion_chain.get();
145 
146  conversion_info.format = ahb_format.format;
147  conversion_info.ycbcrModel = ahb_format.suggestedYcbcrModel;
148  conversion_info.ycbcrRange = ahb_format.suggestedYcbcrRange;
149  conversion_info.components = ahb_format.samplerYcbcrConversionComponents;
150  conversion_info.xChromaOffset = ahb_format.suggestedXChromaOffset;
151  conversion_info.yChromaOffset = ahb_format.suggestedYChromaOffset;
152  // If the potential format features of the sampler Y′CBCR conversion do not
153  // support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
154  // chromaFilter must not be VK_FILTER_LINEAR.
155  //
156  // Since we are not checking, let's just default to a safe value.
157  conversion_info.chromaFilter = vk::Filter::eNearest;
158  conversion_info.forceExplicitReconstruction = false;
159 
160  if (conversion_info.format == vk::Format::eUndefined) {
161  auto& external_format = conversion_chain.get<vk::ExternalFormatANDROID>();
162  external_format.externalFormat = ahb_format.externalFormat;
163  } else {
164  conversion_chain.unlink<vk::ExternalFormatANDROID>();
165  }
166 
167  return context.GetYUVConversionLibrary()->GetConversion(conversion_chain);
168 }

References impeller::ContextVK::GetYUVConversionLibrary().

Referenced by impeller::AHBTextureSourceVK::AHBTextureSourceVK().

â—† CubicPathBoundingPopulateValues()

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

Definition at line 257 of file path_component.cc.

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

References impeller::saturated::b, and 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 242 of file proc_table_gles.cc.

243  {
244  GLint param = GL_NONE;
245  gl.GetFramebufferAttachmentParameteriv(
246  GL_FRAMEBUFFER, // target
247  attachment, // attachment
248  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, // parameter name
249  &param // parameter
250  );
251 
252  if (param != GL_NONE) {
253  param = GL_NONE;
254  gl.GetFramebufferAttachmentParameteriv(
255  GL_FRAMEBUFFER, // target
256  attachment, // attachment
257  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, // parameter name
258  &param // parameter
259  );
260  std::stringstream stream;
261  stream << AttachmentTypeString(param) << "(" << param << ")";
262  return stream.str();
263  }
264 
265  return "No Attachment";
266 }

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

242  {
243  if (tessellator != nullptr) {
244  ::tessDeleteTess(tessellator);
245  }
246 }

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.

â—† DetermineIfANGLE()

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

Definition at line 43 of file description_gles.cc.

43  {
44  return version.find("ANGLE") != std::string::npos;
45 }

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

â—† 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 47 of file description_gles.cc.

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

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

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

â—† DeviceHasUnifiedMemoryArchitecture()

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

Definition at line 37 of file allocator_mtl.mm.

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

â—† DeviceMaxTextureSizeSupported()

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

Definition at line 52 of file allocator_mtl.mm.

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

â—† DeviceSupportsComputeSubgroups()

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

Definition at line 42 of file context_mtl.mm.

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

Referenced by InferMetalCapabilities().

â—† DeviceSupportsDeviceTransientTargets()

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

Definition at line 16 of file allocator_mtl.mm.

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

â—† DeviceSupportsFramebufferFetch()

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

Definition at line 22 of file context_mtl.mm.

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

Referenced by InferMetalCapabilities().

â—† DoColorBlend()

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

Definition at line 216 of file color.cc.

219  {
220  const Vector3 blend_result = blend_rgb_func(ToRGB(dst), ToRGB(src));
221  return ApplyBlendedColor(dst, src, blend_result).Unpremultiply();
222 }

References ApplyBlendedColor(), ToRGB(), and impeller::Color::Unpremultiply().

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

â—† DoColorBlendComponents()

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

Definition at line 224 of file color.cc.

227  {
228  Vector3 blend_result = Vector3(blend_func(dst.red, src.red), //
229  blend_func(dst.green, src.green), //
230  blend_func(dst.blue, src.blue)); //
231  return ApplyBlendedColor(dst, src, blend_result).Unpremultiply();
232 }

References ApplyBlendedColor(), impeller::Color::blue, impeller::Color::green, 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 157 of file typographer_context_skia.cc.

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

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

â—† DrawPlaygroundLine()

std::tuple< Point, Point > impeller::DrawPlaygroundLine ( PlaygroundPoint point_a,
PlaygroundPoint point_b 
)

Definition at line 50 of file widgets.cc.

51  {
52  Point position_a = DrawPlaygroundPoint(point_a);
53  Point position_b = DrawPlaygroundPoint(point_b);
54 
55  if (ImGui::GetCurrentContext()) {
56  auto dir = (position_b - position_a).Normalize() * point_a.radius;
57  auto line_a = position_a + dir;
58  auto line_b = position_b - dir;
59  ImGui::GetBackgroundDrawList()->AddLine(
60  {line_a.x, line_a.y}, {line_b.x, line_b.y},
61  ImColor(point_b.color.red, point_b.color.green, point_b.color.blue,
62  0.3f));
63  }
64  return std::make_tuple(position_a, position_b);
65 }

References impeller::Color::blue, impeller::PlaygroundPoint::color, DrawPlaygroundPoint(), impeller::Color::green, impeller::PlaygroundPoint::radius, and impeller::Color::red.

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

â—† DrawPlaygroundPoint()

Point impeller::DrawPlaygroundPoint ( PlaygroundPoint point)

Definition at line 9 of file widgets.cc.

9  {
10  if (ImGui::GetCurrentContext()) {
11  impeller::Point mouse_pos(ImGui::GetMousePos().x, ImGui::GetMousePos().y);
12  if (!point.prev_mouse_pos.has_value()) {
13  point.prev_mouse_pos = mouse_pos;
14  }
15 
16  if (ImGui::IsKeyPressed(ImGuiKey_R)) {
17  point.position = point.reset_position;
18  point.dragging = false;
19  }
20 
21  bool hovering =
22  point.position.GetDistance(mouse_pos) < point.radius &&
23  point.position.GetDistance(point.prev_mouse_pos.value()) < point.radius;
24  if (!ImGui::IsMouseDown(0)) {
25  point.dragging = false;
26  } else if (hovering && ImGui::IsMouseClicked(0)) {
27  point.dragging = true;
28  }
29  if (point.dragging) {
30  point.position += mouse_pos - point.prev_mouse_pos.value();
31  }
32  ImGui::GetBackgroundDrawList()->AddCircleFilled(
33  {point.position.x, point.position.y}, point.radius,
34  ImColor(point.color.red, point.color.green, point.color.blue,
35  (hovering || point.dragging) ? 0.6f : 0.3f));
36  if (hovering || point.dragging) {
37  ImGui::GetBackgroundDrawList()->AddText(
38  {point.position.x - point.radius,
39  point.position.y + point.radius + 10},
40  ImColor(point.color.red, point.color.green, point.color.blue, 1.0f),
41  impeller::SPrintF("x:%0.3f y:%0.3f", point.position.x,
42  point.position.y)
43  .c_str());
44  }
45  point.prev_mouse_pos = mouse_pos;
46  }
47  return point.position;
48 }

References impeller::Color::blue, impeller::PlaygroundPoint::color, impeller::PlaygroundPoint::dragging, impeller::TPoint< T >::GetDistance(), impeller::Color::green, impeller::PlaygroundPoint::position, impeller::PlaygroundPoint::prev_mouse_pos, impeller::PlaygroundPoint::radius, impeller::Color::red, impeller::PlaygroundPoint::reset_position, SPrintF(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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

â—† EmptyFeedback()

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

Definition at line 20 of file pipeline_vk.cc.

20  {
21  vk::PipelineCreationFeedbackEXT feedback;
22  // If the VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT is not set in flags, an
23  // implementation must not set any other bits in flags, and the values of all
24  // other VkPipelineCreationFeedback data members are undefined.
25  feedback.flags = vk::PipelineCreationFeedbackFlagBits::eValid;
26  return feedback;
27 }

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

â—† 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 144 of file render_pass_gles.cc.

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

References impeller::Color::alpha, impeller::Color::blue, impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::BackendCast< DeviceBufferGLES, DeviceBuffer >::Cast(), impeller::BackendCast< PipelineGLES, Pipeline< PipelineDescriptor > >::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, ConfigureBlending(), ConfigureStencil(), DebugToFramebufferError(), impeller::RenderPassData::depth_attachment, impeller::RenderPassData::discard_color_attachment, impeller::RenderPassData::discard_depth_attachment, impeller::RenderPassData::discard_stencil_attachment, impeller::ReactorGLES::GetProcTable(), 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::ProcTableGLES::PushDebugGroup(), 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().

â—† FindSwiftShaderICDAtKnownPaths()

static void impeller::FindSwiftShaderICDAtKnownPaths ( )
static

Definition at line 20 of file swiftshader_utilities.cc.

20  {
21  static constexpr const char* kSwiftShaderICDJSON = "vk_swiftshader_icd.json";
22  static constexpr const char* kVulkanICDFileNamesEnvVariableKey =
23  "VK_ICD_FILENAMES";
24  const auto executable_directory_path =
25  fml::paths::GetExecutableDirectoryPath();
26  FML_CHECK(executable_directory_path.first);
27  const auto executable_directory =
28  fml::OpenDirectory(executable_directory_path.second.c_str(), false,
29  fml::FilePermission::kRead);
30  FML_CHECK(executable_directory.is_valid());
31  if (fml::FileExists(executable_directory, kSwiftShaderICDJSON)) {
32  const auto icd_path = fml::paths::JoinPaths(
33  {executable_directory_path.second, kSwiftShaderICDJSON});
34 #if FML_OS_WIN
35  const auto success =
36  ::SetEnvironmentVariableA(kVulkanICDFileNamesEnvVariableKey, //
37  icd_path.c_str() //
38  ) != 0;
39 #else // FML_OS_WIN
40  const auto success = ::setenv(kVulkanICDFileNamesEnvVariableKey, //
41  icd_path.c_str(), //
42  1 // overwrite
43  ) == 0;
44 #endif // FML_OS_WIN
45  FML_CHECK(success)
46  << "Could not set the environment variable to use SwiftShader.";
47  } else {
48  FML_CHECK(false)
49  << "Was asked to use SwiftShader but could not find the installable "
50  "client driver (ICD) for the locally built SwiftShader.";
51  }
52 }

Referenced by SetupSwiftshaderOnce().

â—† FormatWindowTitle()

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

â—† FramebufferStatusToString()

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

Definition at line 208 of file proc_table_gles.cc.

208  {
209  switch (status) {
210  case GL_FRAMEBUFFER_COMPLETE:
211  return "GL_FRAMEBUFFER_COMPLETE";
212  case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
213  return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
214 #if GL_ES_VERSION_2_0
215  case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
216  return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
217 #endif
218  case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
219  return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
220  case GL_FRAMEBUFFER_UNSUPPORTED:
221  return "GL_FRAMEBUFFER_UNSUPPORTED";
222  case GL_INVALID_ENUM:
223  return "GL_INVALID_ENUM";
224  }
225 
226  return "Unknown FBO Error Status";
227 }

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

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

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

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

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

â—† GenerateBlurInfo()

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

Definition at line 586 of file gaussian_blur_filter_contents.cc.

587  {
588  KernelPipeline::FragmentShader::KernelSamples result;
589  result.sample_count =
590  ((2 * parameters.blur_radius) / parameters.step_size) + 1;
591 
592  // Chop off the last samples if the radius >= 3 where they account for < 1.56%
593  // of the result.
594  int x_offset = 0;
595  if (parameters.blur_radius >= 3) {
596  result.sample_count -= 2;
597  x_offset = 1;
598  }
599 
600  Scalar tally = 0.0f;
601  for (int i = 0; i < result.sample_count; ++i) {
602  int x = x_offset + (i * parameters.step_size) - parameters.blur_radius;
603  result.samples[i] = KernelPipeline::FragmentShader::KernelSample{
604  .uv_offset = parameters.blur_uv_offset * x,
605  .coefficient = expf(-0.5f * (x * x) /
606  (parameters.blur_sigma * parameters.blur_sigma)) /
607  (sqrtf(2.0f * M_PI) * parameters.blur_sigma),
608  };
609  tally += result.samples[i].coefficient;
610  }
611 
612  // Make sure everything adds up to 1.
613  for (auto& sample : result.samples) {
614  sample.coefficient /= tally;
615  }
616 
617  return result;
618 }

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

â—† 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().

â—† GetExtensionName() [1/3]

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

Definition at line 184 of file capabilities_vk.cc.

184  {
185  switch (ext) {
186  case OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback:
187  return VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME;
188  case OptionalDeviceExtensionVK::kVKKHRPortabilitySubset:
189  return "VK_KHR_portability_subset";
190  case OptionalDeviceExtensionVK::kLast:
191  return "Unknown";
192  }
193  FML_UNREACHABLE();
194 }

References kEXTPipelineCreationFeedback, kLast, and kVKKHRPortabilitySubset.

â—† GetExtensionName() [2/3]

static const char* impeller::GetExtensionName ( RequiredAndroidDeviceExtensionVK  ext)
static

Definition at line 165 of file capabilities_vk.cc.

165  {
166  switch (ext) {
167  case RequiredAndroidDeviceExtensionVK::
168  kANDROIDExternalMemoryAndroidHardwareBuffer:
169  return "VK_ANDROID_external_memory_android_hardware_buffer";
170  case RequiredAndroidDeviceExtensionVK::kKHRSamplerYcbcrConversion:
171  return VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME;
172  case RequiredAndroidDeviceExtensionVK::kKHRExternalMemory:
173  return VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME;
174  case RequiredAndroidDeviceExtensionVK::kEXTQueueFamilyForeign:
175  return VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME;
176  case RequiredAndroidDeviceExtensionVK::kKHRDedicatedAllocation:
177  return VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME;
178  case RequiredAndroidDeviceExtensionVK::kLast:
179  return "Unknown";
180  }
181  FML_UNREACHABLE();
182 }

References kANDROIDExternalMemoryAndroidHardwareBuffer, kEXTQueueFamilyForeign, kKHRDedicatedAllocation, kKHRExternalMemory, kKHRSamplerYcbcrConversion, and kLast.

â—† GetExtensionName() [3/3]

static const char* impeller::GetExtensionName ( RequiredCommonDeviceExtensionVK  ext)
static

Definition at line 155 of file capabilities_vk.cc.

155  {
156  switch (ext) {
157  case RequiredCommonDeviceExtensionVK::kKHRSwapchain:
158  return VK_KHR_SWAPCHAIN_EXTENSION_NAME;
159  case RequiredCommonDeviceExtensionVK::kLast:
160  return "Unknown";
161  }
162  FML_UNREACHABLE();
163 }

References kKHRSwapchain, and kLast.

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

â—† 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] =
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 63 of file context_vk.cc.

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

â—† GetShaderClipDepth()

static Scalar impeller::GetShaderClipDepth ( const Entity entity)
static

Definition at line 18 of file clip_contents.cc.

18  {
19  // Draw the clip at the max of the clip entity's depth slice, so that other
20  // draw calls with this same depth value will be culled even if they have a
21  // perspective transform.
22  return std::nextafterf(
23  Entity::GetShaderClipDepth(entity.GetNewClipDepth() + 1), 0.0f);
24 }

References impeller::Entity::GetNewClipDepth(), and impeller::Entity::GetShaderClipDepth().

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

â—† 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:
48  case kFloat:
49  return ShaderType::kFloat;
50  case kStruct:
51  return ShaderType::kStruct;
52  }
53 }

References kFloat, kSampledImage, and kStruct.

Referenced by MakeShaderMetadata().

â—† GetSupportedDeviceExtensions()

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

Definition at line 209 of file capabilities_vk.cc.

210  {
211  auto device_extensions = physical_device.enumerateDeviceExtensionProperties();
212  if (device_extensions.result != vk::Result::eSuccess) {
213  return std::nullopt;
214  }
215 
216  std::set<std::string> exts;
217  for (const auto& device_extension : device_extensions.value) {
218  exts.insert(device_extension.extensionName);
219  };
220 
221  return exts;
222 }

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

â—† GetTextureTypeFromDescriptor()

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

Definition at line 45 of file texture_gles.cc.

46  {
47  const auto usage = static_cast<TextureUsageMask>(desc.usage);
48  const auto render_target = TextureUsage::kRenderTarget;
49  const auto is_msaa = desc.sample_count == SampleCount::kCount4;
50  if (usage == render_target && IsDepthStencilFormat(desc.format)) {
51  return is_msaa ? TextureGLES::Type::kRenderBufferMultisampled
52  : TextureGLES::Type::kRenderBuffer;
53  }
54  return is_msaa ? TextureGLES::Type::kTextureMultisampled
55  : TextureGLES::Type::kTexture;
56 }

References impeller::TextureDescriptor::format, IsDepthStencilFormat(), kCount4, impeller::TextureGLES::kRenderBuffer, impeller::TextureGLES::kRenderBufferMultisampled, kRenderTarget, 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 54 of file render_pass_vk.cc.

55  {
56  std::vector<vk::ClearValue> clears;
57 
58  for (const auto& [_, color] : target.GetColorAttachments()) {
59  clears.emplace_back(VKClearValueFromColor(color.clear_color));
60  if (color.resolve_texture) {
61  clears.emplace_back(VKClearValueFromColor(color.clear_color));
62  }
63  }
64 
65  const auto& depth = target.GetDepthAttachment();
66  const auto& stencil = target.GetStencilAttachment();
67 
68  if (depth.has_value()) {
69  clears.emplace_back(VKClearValueFromDepthStencil(
70  stencil ? stencil->clear_stencil : 0u, depth->clear_depth));
71  } else if (stencil.has_value()) {
72  clears.emplace_back(VKClearValueFromDepthStencil(
73  stencil->clear_stencil, depth ? depth->clear_depth : 0.0f));
74  }
75 
76  return clears;
77 }

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

â—† glClearDepth()

void() impeller::glClearDepth ( GLdouble  depth)

â—† glClearDepthf()

void() impeller::glClearDepthf ( GLfloat  depth)

â—† glDepthRange()

void() impeller::glDepthRange ( GLdouble  n,
GLdouble  f 
)

â—† glDepthRangef()

void() impeller::glDepthRangef ( GLfloat  n,
GLfloat  f 
)

â—† 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 307 of file capabilities_vk.cc.

307  {
308  auto properties = physical_device.getProperties();
309  if (!(properties.limits.framebufferColorSampleCounts &
310  (vk::SampleCountFlagBits::e1 | vk::SampleCountFlagBits::e4))) {
311  return false;
312  }
313  return true;
314 }

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

â—† HasRequiredQueues()

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

Definition at line 316 of file capabilities_vk.cc.

316  {
317  auto queue_flags = vk::QueueFlags{};
318  for (const auto& queue : physical_device.getQueueFamilyProperties()) {
319  if (queue.queueCount == 0) {
320  continue;
321  }
322  queue_flags |= queue.queueFlags;
323  }
324  return static_cast<VkQueueFlags>(queue_flags &
325  (vk::QueueFlagBits::eGraphics |
326  vk::QueueFlagBits::eCompute |
327  vk::QueueFlagBits::eTransfer));
328 }

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

283  {
284  const auto props = device.getFormatProperties(format);
285  // This needs to be more comprehensive.
286  return !!(props.optimalTilingFeatures &
287  vk::FormatFeatureFlagBits::eColorAttachment);
288 }

Referenced by PhysicalDeviceSupportsRequiredFormats().

â—† HasSuitableDepthStencilFormat()

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

Definition at line 290 of file capabilities_vk.cc.

291  {
292  const auto props = device.getFormatProperties(format);
293  return !!(props.optimalTilingFeatures &
294  vk::FormatFeatureFlagBits::eDepthStencilAttachment);
295 }

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

â—† HasValidationLayers()

â—† 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 }

â—† IdentifyVendor()

constexpr VendorVK impeller::IdentifyVendor ( uint32_t  vendor)
constexpr

Definition at line 9 of file driver_info_vk.cc.

9  {
10  // Check if the vendor has a PCI ID:
11  // https://pcisig.com/membership/member-companies
12  switch (vendor) {
13  case 0x1AE0:
14  return VendorVK::kGoogle;
15  case 0x168C:
16  case 0x17CB:
17  case 0x1969:
18  case 0x5143:
19  return VendorVK::kQualcomm;
20  case 0x13B5:
21  return VendorVK::kARM;
22  case 0x1010:
23  return VendorVK::kImgTec;
24  case 0x1002:
25  case 0x1022:
26  return VendorVK::kAMD;
27  case 0x10DE:
28  return VendorVK::kNvidia;
29  case 0x8086: // :)
30  return VendorVK::kIntel;
31  case 0x106B:
32  return VendorVK::kApple;
33  }
34  // Check if the ID is a known Khronos vendor.
35  switch (vendor) {
36  case VK_VENDOR_ID_MESA:
37  return VendorVK::kMesa;
38  // There are others but have never been observed. These can be added as
39  // needed.
40  }
41  return VendorVK::kUnknown;
42 }

References kAMD, kApple, kARM, kGoogle, kImgTec, kIntel, kMesa, kNvidia, kQualcomm, and kUnknown.

Referenced by impeller::DriverInfoVK::DriverInfoVK().

â—† IMPELLER_ENUM_IS_MASK() [1/3]

impeller::IMPELLER_ENUM_IS_MASK ( ColorWriteMaskBits  )

â—† IMPELLER_ENUM_IS_MASK() [2/3]

impeller::IMPELLER_ENUM_IS_MASK ( MyMaskBits  )

â—† IMPELLER_ENUM_IS_MASK() [3/3]

impeller::IMPELLER_ENUM_IS_MASK ( TextureUsage  )

â—† 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 48 of file validation.cc.

48  {
49  std::stringstream stream;
50 #if FLUTTER_RELEASE
51  stream << "Impeller validation: " << message;
52 #else
53  stream << "Break on '" << __FUNCTION__
54  << "' to inspect point of failure: " << message;
55 #endif
56  if (sValidationLogsAreFatal > 0) {
57  FML_LOG(FATAL) << stream.str();
58  } else {
59  FML_LOG(ERROR) << stream.str();
60  }
61 }

References sValidationLogsAreFatal.

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

â—† ImpellerValidationErrorsAreFatal()

bool impeller::ImpellerValidationErrorsAreFatal ( )

Definition at line 63 of file validation.cc.

63  {
65 }

References sValidationLogsAreFatal.

Referenced by TEST().

â—† ImpellerValidationErrorsSetFatal()

void impeller::ImpellerValidationErrorsSetFatal ( bool  fatal)

Definition at line 16 of file validation.cc.

16  {
18 }

References sValidationLogsAreFatal.

Referenced by main(), and impeller::PlaygroundTest::SetUp().

â—† ImportVKDeviceMemoryFromAndroidHarwareBuffer()

static vk::UniqueDeviceMemory impeller::ImportVKDeviceMemoryFromAndroidHarwareBuffer ( const vk::Device &  device,
const vk::PhysicalDevice &  physical_device,
const vk::Image &  image,
struct AHardwareBuffer *  hardware_buffer,
const AHBProperties ahb_props 
)
static

Definition at line 92 of file ahb_texture_source_vk.cc.

97  {
98  vk::PhysicalDeviceMemoryProperties memory_properties;
99  physical_device.getMemoryProperties(&memory_properties);
100  int memory_type_index = AllocatorVK::FindMemoryTypeIndex(
101  ahb_props.get().memoryTypeBits, memory_properties);
102  if (memory_type_index < 0) {
103  VALIDATION_LOG << "Could not find memory type of external image.";
104  return {};
105  }
106 
107  vk::StructureChain<vk::MemoryAllocateInfo,
108  // Core in 1.1
109  vk::MemoryDedicatedAllocateInfo,
110  // For VK_ANDROID_external_memory_android_hardware_buffer
111  vk::ImportAndroidHardwareBufferInfoANDROID>
112  memory_chain;
113 
114  auto& mem_alloc_info = memory_chain.get<vk::MemoryAllocateInfo>();
115  mem_alloc_info.allocationSize = ahb_props.get().allocationSize;
116  mem_alloc_info.memoryTypeIndex = memory_type_index;
117 
118  auto& dedicated_alloc_info =
119  memory_chain.get<vk::MemoryDedicatedAllocateInfo>();
120  dedicated_alloc_info.image = image;
121 
122  auto& ahb_import_info =
123  memory_chain.get<vk::ImportAndroidHardwareBufferInfoANDROID>();
124  ahb_import_info.buffer = hardware_buffer;
125 
126  auto device_memory = device.allocateMemoryUnique(memory_chain.get());
127  if (device_memory.result != vk::Result::eSuccess) {
128  VALIDATION_LOG << "Could not allocate device memory for external image : "
129  << vk::to_string(device_memory.result);
130  return {};
131  }
132 
133  return std::move(device_memory.value);
134 }

References impeller::AllocatorVK::FindMemoryTypeIndex(), and VALIDATION_LOG.

Referenced by impeller::AHBTextureSourceVK::AHBTextureSourceVK().

â—† InferMetalCapabilities()

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

Definition at line 53 of file context_mtl.mm.

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

References impeller::CapabilitiesBuilder::Build(), DeviceSupportsComputeSubgroups(), DeviceSupportsFramebufferFetch(), kA8UNormInt, kD32FloatS8UInt, kS8UInt, impeller::CapabilitiesBuilder::SetDefaultColorFormat(), impeller::CapabilitiesBuilder::SetDefaultDepthStencilFormat(), impeller::CapabilitiesBuilder::SetDefaultGlyphAtlasFormat(), 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().

â—† InitializeGLFWOnce()

static void impeller::InitializeGLFWOnce ( )
static

Definition at line 56 of file playground.cc.

56  {
57  // This guard is a hack to work around a problem where glfwCreateWindow
58  // hangs when opening a second window after GLFW has been reinitialized (for
59  // example, when flipping through multiple playground tests).
60  //
61  // Explanation:
62  // * glfwCreateWindow calls [NSApp run], which begins running the event
63  // loop on the current thread.
64  // * GLFW then immediately stops the loop when
65  // applicationDidFinishLaunching is fired.
66  // * applicationDidFinishLaunching is only ever fired once during the
67  // application's lifetime, so subsequent calls to [NSApp run] will always
68  // hang with this setup.
69  // * glfwInit resets the flag that guards against [NSApp run] being
70  // called a second time, which causes the subsequent `glfwCreateWindow`
71  // to hang indefinitely in the event loop, because
72  // applicationDidFinishLaunching is never fired.
73  static std::once_flag sOnceInitializer;
74  std::call_once(sOnceInitializer, []() {
75  ::glfwSetErrorCallback([](int code, const char* description) {
76  FML_LOG(ERROR) << "GLFW Error '" << description << "' (" << code << ").";
77  });
78  FML_CHECK(::glfwInit() == GLFW_TRUE);
79  });
80 }

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

â—† InsertBarrierForInputAttachmentRead()

void impeller::InsertBarrierForInputAttachmentRead ( const vk::CommandBuffer &  buffer,
const vk::Image &  image 
)

Inserts the appropriate barriers to ensure that subsequent commands can read from the specified image (itself a framebuffer attachment) as an input attachment.

Unlike most barriers, this barrier may only be inserted within a Vulkan render-pass.

The type of barrier inserted depends on the subpass setup and self-dependencies. Only use this utility method for inserting barriers in render passes created by RenderPassBuilderVK.

Parameters
[in]bufferThe buffer
[in]imageThe image

Definition at line 158 of file render_pass_builder_vk.cc.

159  {
160  // This barrier must be a subset of the masks specified in the subpass
161  // dependency setup.
162  vk::ImageMemoryBarrier barrier;
163  barrier.srcAccessMask = kSelfDependencySrcAccessMask;
164  barrier.dstAccessMask = kSelfDependencyDstAccessMask;
165  barrier.oldLayout = vk::ImageLayout::eGeneral;
166  barrier.newLayout = vk::ImageLayout::eGeneral;
167  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
168  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
169  barrier.image = image;
170 
171  vk::ImageSubresourceRange image_levels;
172  image_levels.aspectMask = vk::ImageAspectFlagBits::eColor;
173  image_levels.baseArrayLayer = 0u;
174  image_levels.baseMipLevel = 0u;
175  image_levels.layerCount = VK_REMAINING_ARRAY_LAYERS;
176  image_levels.levelCount = VK_REMAINING_MIP_LEVELS;
177  barrier.subresourceRange = image_levels;
178 
179  buffer.pipelineBarrier(kSelfDependencySrcStageMask, //
182  {}, //
183  {}, //
184  barrier //
185  );
186 }

References kSelfDependencyDstAccessMask, kSelfDependencyDstStageMask, kSelfDependencyFlags, kSelfDependencySrcAccessMask, and kSelfDependencySrcStageMask.

â—† 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 243 of file blit_command_vk.cc.

252  {
253  if (old_layout == new_layout) {
254  return;
255  }
256 
257  vk::ImageMemoryBarrier barrier;
258  barrier.srcAccessMask = src_access_mask;
259  barrier.dstAccessMask = dst_access_mask;
260  barrier.oldLayout = old_layout;
261  barrier.newLayout = new_layout;
262  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
263  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
264  barrier.image = image;
265  barrier.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
266  barrier.subresourceRange.baseMipLevel = base_mip_level;
267  barrier.subresourceRange.levelCount = mip_level_count;
268  barrier.subresourceRange.baseArrayLayer = 0u;
269  barrier.subresourceRange.layerCount = 1u;
270 
271  cmd.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier);
272 }

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

â—† IsDepthStencilFormat()

static bool impeller::IsDepthStencilFormat ( PixelFormat  format)
static

Definition at line 21 of file texture_gles.cc.

21  {
22  switch (format) {
23  case PixelFormat::kS8UInt:
24  case PixelFormat::kD24UnormS8Uint:
25  case PixelFormat::kD32FloatS8UInt:
26  return true;
27  case PixelFormat::kUnknown:
28  case PixelFormat::kA8UNormInt:
29  case PixelFormat::kR8UNormInt:
30  case PixelFormat::kR8G8UNormInt:
31  case PixelFormat::kR8G8B8A8UNormInt:
32  case PixelFormat::kR8G8B8A8UNormIntSRGB:
33  case PixelFormat::kB8G8R8A8UNormInt:
34  case PixelFormat::kB8G8R8A8UNormIntSRGB:
35  case PixelFormat::kR32G32B32A32Float:
36  case PixelFormat::kR16G16B16A16Float:
37  case PixelFormat::kB10G10R10XR:
38  case PixelFormat::kB10G10R10XRSRGB:
39  case PixelFormat::kB10G10R10A10XR:
40  return false;
41  }
42  FML_UNREACHABLE();
43 }

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

Referenced by GetTextureTypeFromDescriptor().

â—† IsDepthWritable()

constexpr bool impeller::IsDepthWritable ( PixelFormat  format)
constexpr

Definition at line 120 of file formats.h.

120  {
121  switch (format) {
122  case PixelFormat::kD24UnormS8Uint:
123  case PixelFormat::kD32FloatS8UInt:
124  return true;
125  default:
126  return false;
127  }
128 }

References kD24UnormS8Uint, and kD32FloatS8UInt.

â—† IsExtensionInList()

template<class ExtensionEnum >
static bool impeller::IsExtensionInList ( const std::vector< std::string > &  list,
ExtensionEnum  ext 
)
static

Definition at line 331 of file capabilities_vk.cc.

332  {
333  const std::string name = GetExtensionName(ext);
334  return std::find(list.begin(), list.end(), name) != list.end();
335 }

References GetExtensionName().

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

â—† IsMappingSPIRV()

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

Definition at line 118 of file shader_library_vk.cc.

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

â—† IsMultisampleCapable()

constexpr bool impeller::IsMultisampleCapable ( TextureType  type)
constexpr

Definition at line 284 of file formats.h.

284  {
285  switch (type) {
286  case TextureType::kTexture2D:
287  case TextureType::kTextureCube:
288  case TextureType::kTextureExternalOES:
289  return false;
290  case TextureType::kTexture2DMultisample:
291  return true;
292  }
293  return false;
294 }

References kTexture2D, kTexture2DMultisample, kTextureCube, and kTextureExternalOES.

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

â—† IsStencilWritable()

constexpr bool impeller::IsStencilWritable ( PixelFormat  format)
constexpr

Definition at line 130 of file formats.h.

130  {
131  switch (format) {
132  case PixelFormat::kS8UInt:
133  case PixelFormat::kD24UnormS8Uint:
134  case PixelFormat::kD32FloatS8UInt:
135  return true;
136  default:
137  return false;
138  }
139 }

References kD24UnormS8Uint, kD32FloatS8UInt, and kS8UInt.

â—† IterateExtensions()

template<class T >
static bool impeller::IterateExtensions ( const std::function< bool(T)> &  it)
static

Definition at line 197 of file capabilities_vk.cc.

197  {
198  if (!it) {
199  return false;
200  }
201  for (size_t i = 0; i < static_cast<uint32_t>(T::kLast); i++) {
202  if (!it(static_cast<T>(i))) {
203  return false;
204  }
205  }
206  return true;
207 }

â—† 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 }

â—† LerpHackKernelSamples()

KernelPipeline::FragmentShader::KernelSamples impeller::LerpHackKernelSamples ( KernelPipeline::FragmentShader::KernelSamples  samples)

This will shrink the size of a kernel by roughly half by sampling between samples and relying on linear interpolation between the samples.

Definition at line 622 of file gaussian_blur_filter_contents.cc.

623  {
624  KernelPipeline::FragmentShader::KernelSamples result;
625  result.sample_count = ((parameters.sample_count - 1) / 2) + 1;
626  int32_t middle = result.sample_count / 2;
627  int32_t j = 0;
628  for (int i = 0; i < result.sample_count; i++) {
629  if (i == middle) {
630  result.samples[i] = parameters.samples[j++];
631  } else {
632  KernelPipeline::FragmentShader::KernelSample left = parameters.samples[j];
633  KernelPipeline::FragmentShader::KernelSample right =
634  parameters.samples[j + 1];
635  result.samples[i] = KernelPipeline::FragmentShader::KernelSample{
636  .uv_offset = (left.uv_offset * left.coefficient +
637  right.uv_offset * right.coefficient) /
638  (left.coefficient + right.coefficient),
639  .coefficient = left.coefficient + right.coefficient,
640  };
641  j += 2;
642  }
643  }
644 
645  return result;
646 }

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

â—† 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::MaskBlurVariantTest(), 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 216 of file formats.h.

216  {
217  switch (action) {
218  case LoadAction::kDontCare:
219  return "DontCare";
220  case LoadAction::kLoad:
221  return "Load";
222  case LoadAction::kClear:
223  return "Clear";
224  }
225 }

References kClear, kDontCare, and kLoad.

Referenced by AttachmentToString().

â—† LogMTLCommandBufferErrorIfPresent()

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

Definition at line 60 of file command_buffer_mtl.mm.

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

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

â—† MAKE_STROKE_BENCHMARK_CAPTURE() [1/3]

impeller::MAKE_STROKE_BENCHMARK_CAPTURE ( RRect  ,
Butt  ,
Bevel  ,
_uv  ,
UVMode::kUVRectTx   
)

â—† MAKE_STROKE_BENCHMARK_CAPTURE() [2/3]

impeller::MAKE_STROKE_BENCHMARK_CAPTURE ( RRect  ,
Butt  ,
Bevel  ,
_uvNoTx  ,
UVMode::kUVRect   
)

â—† MAKE_STROKE_BENCHMARK_CAPTURE() [3/3]

impeller::MAKE_STROKE_BENCHMARK_CAPTURE ( RRect  ,
Butt  ,
Bevel  ,
UVMode::kNoUV   
)

â—† MAKE_STROKE_BENCHMARK_CAPTURE_UVS() [1/2]

impeller::MAKE_STROKE_BENCHMARK_CAPTURE_UVS ( Cubic  )

â—† MAKE_STROKE_BENCHMARK_CAPTURE_UVS() [2/2]

impeller::MAKE_STROKE_BENCHMARK_CAPTURE_UVS ( Quadratic  )

â—† MakeShaderMetadata()

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

Definition at line 55 of file runtime_effect_contents.cc.

56  {
57  auto metadata = std::make_shared<ShaderMetadata>();
58  metadata->name = uniform.name;
59  metadata->members.emplace_back(ShaderStructMemberMetadata{
60  .type = GetShaderType(uniform.type),
61  .size = uniform.GetSize(),
62  .byte_length = uniform.bit_width / 8,
63  });
64 
65  return metadata;
66 }

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(), impeller::Font::Metrics::point_size, and scale.

â—† 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 35 of file command_buffer_mtl.mm.

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

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

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

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

141  {
142  NSMutableArray<id<MTLLibrary>>* found_libraries = [NSMutableArray array];
143  for (const auto& library_path : libraries_paths) {
144  if (!fml::IsFile(library_path)) {
145  VALIDATION_LOG << "Shader library does not exist at path '"
146  << library_path << "'";
147  return nil;
148  }
149  NSError* shader_library_error = nil;
150  auto library = [device newLibraryWithFile:@(library_path.c_str())
151  error:&shader_library_error];
152  if (!library) {
153  FML_LOG(ERROR) << "Could not create shader library: "
154  << shader_library_error.localizedDescription.UTF8String;
155  return nil;
156  }
157  [found_libraries addObject:library];
158  }
159  return found_libraries;
160 }

References VALIDATION_LOG.

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

â—† NearEqual()

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

Definition at line 249 of file path_component.cc.

249  {
250  return (a > (b - epsilon)) && (a < (b + epsilon));
251 }

References impeller::saturated::b.

Referenced by NearZero().

â—† NearZero()

static bool impeller::NearZero ( Scalar  a)
inlinestatic

Definition at line 253 of file path_component.cc.

253  {
254  return NearEqual(a, 0.0, 1e-12);
255 }

References NearEqual().

Referenced by CubicPathBoundingPopulateValues().

â—† NormalizeUniformKey()

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

Definition at line 57 of file buffer_bindings_gles.cc.

57  {
58  std::string result;
59  result.reserve(key.length());
60  for (char ch : key) {
61  if (ch != '_') {
62  result.push_back(toupper(ch));
63  }
64  }
65  return result;
66 }

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!=()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool impeller::operator!= ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 223 of file mask.h.

224  {
225  return Mask<EnumType>{lhs} != rhs;
226 }

â—† operator&() [1/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask<EnumType> impeller::operator& ( const EnumType &  lhs,
const EnumType &  rhs 
)
inlineconstexpr

Definition at line 139 of file mask.h.

140  {
141  return Mask<EnumType>{lhs} & rhs;
142 }

â—† operator&() [2/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask<EnumType> impeller::operator& ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 170 of file mask.h.

171  {
172  return Mask<EnumType>{lhs} & rhs;
173 }

â—† operator*() [1/7]

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

Definition at line 263 of file point.h.

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

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

â—† operator*() [2/7]

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

Definition at line 268 of file point.h.

268  {
269  return p2 * p1;
270 }

â—† 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 307 of file point.h.

307  {
308  return p * s;
309 }

â—† operator*() [4/7]

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color impeller::operator* ( 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* ( s,
const TPoint< T > &  p 
)
constexpr

Definition at line 285 of file point.h.

285  {
286  return p * s;
287 }

â—† operator*() [6/7]

template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TSize<T> impeller::operator* ( 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* ( 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 243 of file point.h.

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

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

â—† operator+() [2/5]

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

Definition at line 248 of file point.h.

248  {
249  return p2 + p1;
250 }

â—† 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 297 of file point.h.

297  {
298  return p + s;
299 }

â—† operator+() [4/5]

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color impeller::operator+ ( 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+ ( 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 253 of file point.h.

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

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

â—† operator-() [2/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 258 of file point.h.

258  {
259  return {static_cast<F>(p1.x) - p2.x, static_cast<F>(p1.y) - p2.y};
260 }

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

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

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

â—† operator-() [4/5]

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr Color impeller::operator- ( 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- ( 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 273 of file point.h.

273  {
274  return {p1.x / static_cast<F>(p2.x), p1.y / static_cast<F>(p2.y)};
275 }

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

278  {
279  return {static_cast<F>(p1.x) / p2.x, static_cast<F>(p1.y) / p2.y};
280 }

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

312  {
313  return {static_cast<T>(s.width) / p.x, static_cast<T>(s.height) / p.y};
314 }

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/ ( 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/ ( s,
const TPoint< T > &  p 
)
constexpr

Definition at line 290 of file point.h.

290  {
291  return {static_cast<T>(s) / p.x, static_cast<T>(s) / p.y};
292 }

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/ ( s,
const TSize< T > &  p 
)
constexpr

Definition at line 133 of file size.h.

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

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

â—† operator/() [7/7]

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr Vector3 impeller::operator/ ( 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.

â—† operator<()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool impeller::operator< ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 188 of file mask.h.

189  {
190  return Mask<EnumType>{lhs} < rhs;
191 }

â—† operator<=()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool impeller::operator<= ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 202 of file mask.h.

203  {
204  return Mask<EnumType>{lhs} <= rhs;
205 }

â—† operator==()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool impeller::operator== ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 216 of file mask.h.

217  {
218  return Mask<EnumType>{lhs} == rhs;
219 }

â—† operator>()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool impeller::operator> ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 195 of file mask.h.

196  {
197  return Mask<EnumType>{lhs} > rhs;
198 }

â—† operator>=()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>
constexpr bool impeller::operator>= ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 209 of file mask.h.

210  {
211  return Mask<EnumType>{lhs} >= rhs;
212 }

â—† operator^() [1/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask<EnumType> impeller::operator^ ( const EnumType &  lhs,
const EnumType &  rhs 
)
inlineconstexpr

Definition at line 147 of file mask.h.

148  {
149  return Mask<EnumType>{lhs} ^ rhs;
150 }

â—† operator^() [2/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask<EnumType> impeller::operator^ ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 178 of file mask.h.

179  {
180  return Mask<EnumType>{lhs} ^ rhs;
181 }

â—† operator|() [1/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask<EnumType> impeller::operator| ( const EnumType &  lhs,
const EnumType &  rhs 
)
inlineconstexpr

Definition at line 131 of file mask.h.

132  {
133  return Mask<EnumType>{lhs} | rhs;
134 }

â—† operator|() [2/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask<EnumType> impeller::operator| ( const EnumType &  lhs,
const Mask< EnumType > &  rhs 
)
inlineconstexpr

Definition at line 162 of file mask.h.

163  {
164  return Mask<EnumType>{lhs} | rhs;
165 }

â—† operator~()

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>
constexpr Mask<EnumType> impeller::operator~ ( const EnumType &  other)
inlineconstexpr

Definition at line 155 of file mask.h.

155  {
156  return ~Mask<EnumType>{other};
157 }

â—† 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 118 of file typographer_context_skia.cc.

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

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 
25  bool has_depth_stencil_attachments =
26  pass.HasDepthAttachment() && pass.HasStencilAttachment();
27  FML_DCHECK(pass.HasDepthAttachment() == pass.HasStencilAttachment());
28 
29  opts.has_depth_stencil_attachments = has_depth_stencil_attachments;
30  if constexpr (ContentContext::kEnableStencilThenCover) {
31  opts.depth_compare = CompareFunction::kGreater;
32  opts.stencil_mode = ContentContextOptions::StencilMode::kIgnore;
33  }
34  return opts;
35 }

References impeller::ContentContextOptions::color_attachment_pixel_format, impeller::ContentContextOptions::depth_compare, impeller::RenderPass::GetRenderTargetPixelFormat(), impeller::RenderPass::GetSampleCount(), impeller::ContentContextOptions::has_depth_stencil_attachments, impeller::RenderPass::HasDepthAttachment(), impeller::RenderPass::HasStencilAttachment(), impeller::ContentContext::kEnableStencilThenCover, kGreater, impeller::ContentContextOptions::kIgnore, impeller::ContentContextOptions::sample_count, and impeller::ContentContextOptions::stencil_mode.

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

â—† OptionsFromPassAndEntity()

â—† 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 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, scale, impeller::TSize< T >::width, impeller::IPoint16::x(), and impeller::IPoint16::y().

â—† 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 45 of file typographer_context_skia.cc.

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

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

â—† PhysicalDeviceSupportsRequiredFormats()

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

Definition at line 297 of file capabilities_vk.cc.

298  {
299  const auto has_color_format =
300  HasSuitableColorFormat(device, vk::Format::eB8G8R8A8Unorm);
301  const auto has_stencil_format =
302  HasSuitableDepthStencilFormat(device, vk::Format::eD32SfloatS8Uint) ||
303  HasSuitableDepthStencilFormat(device, vk::Format::eD24UnormS8Uint);
304  return has_color_format && has_stencil_format;
305 }

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

54  {
55  for (const auto& device : instance.enumeratePhysicalDevices().value) {
56  if (caps.GetEnabledDeviceFeatures(device).has_value()) {
57  return device;
58  }
59  }
60  return std::nullopt;
61 }

References impeller::CapabilitiesVK::GetEnabledDeviceFeatures().

â—† PickQueue()

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

Definition at line 86 of file context_vk.cc.

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

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

405  {
406  using VS = BlendPipeline::VertexShader;
407  using FS = BlendPipeline::FragmentShader;
408 
409  auto dst_snapshot =
410  inputs[0]->GetSnapshot("PipelineBlend(Dst)", renderer, entity);
411  if (!dst_snapshot.has_value()) {
412  return std::nullopt; // Nothing to render.
413  }
414 
415  Rect subpass_coverage = coverage;
416  if (entity.GetContents()) {
417  auto coverage_hint = entity.GetContents()->GetCoverageHint();
418 
419  if (coverage_hint.has_value()) {
420  auto maybe_subpass_coverage =
421  subpass_coverage.Intersection(*coverage_hint);
422  if (!maybe_subpass_coverage.has_value()) {
423  return std::nullopt; // Nothing to render.
424  }
425 
426  subpass_coverage = *maybe_subpass_coverage;
427  }
428  }
429 
430  ContentContext::SubpassCallback callback = [&](const ContentContext& renderer,
431  RenderPass& pass) {
432  auto& host_buffer = renderer.GetTransientsBuffer();
433 
434 #ifdef IMPELLER_DEBUG
435  pass.SetCommandLabel(
436  SPrintF("Pipeline Blend Filter (%s)", BlendModeToString(blend_mode)));
437 #endif // IMPELLER_DEBUG
438  auto options = OptionsFromPass(pass);
439  options.primitive_type = PrimitiveType::kTriangleStrip;
440 
441  auto add_blend_command = [&](std::optional<Snapshot> input) {
442  if (!input.has_value()) {
443  return false;
444  }
445  auto input_coverage = input->GetCoverage();
446  if (!input_coverage.has_value()) {
447  return false;
448  }
449 
450  const std::unique_ptr<const Sampler>& sampler =
451  renderer.GetContext()->GetSamplerLibrary()->GetSampler(
452  input->sampler_descriptor);
453  FS::BindTextureSamplerSrc(pass, input->texture, sampler);
454 
455  auto size = input->texture->GetSize();
456  VertexBufferBuilder<VS::PerVertexData> vtx_builder;
457  vtx_builder.AddVertices({
458  {Point(0, 0), Point(0, 0)},
459  {Point(size.width, 0), Point(1, 0)},
460  {Point(0, size.height), Point(0, 1)},
461  {Point(size.width, size.height), Point(1, 1)},
462  });
463  pass.SetVertexBuffer(vtx_builder.CreateVertexBuffer(host_buffer));
464 
465  VS::FrameInfo frame_info;
466  frame_info.mvp = pass.GetOrthographicTransform() *
467  Matrix::MakeTranslation(-subpass_coverage.GetOrigin()) *
468  input->transform;
469  frame_info.texture_sampler_y_coord_scale =
470  input->texture->GetYCoordScale();
471 
472  FS::FragInfo frag_info;
473  frag_info.input_alpha =
474  absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
475  ? input->opacity
476  : 1.0;
477  FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
478  VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
479 
480  return pass.Draw().ok();
481  };
482 
483  // Draw the first texture using kSource.
484  options.blend_mode = BlendMode::kSource;
485  pass.SetPipeline(renderer.GetBlendPipeline(options));
486  if (!add_blend_command(dst_snapshot)) {
487  return true;
488  }
489 
490  // Write subsequent textures using the selected blend mode.
491 
492  if (inputs.size() >= 2) {
493  options.blend_mode = blend_mode;
494  pass.SetPipeline(renderer.GetBlendPipeline(options));
495 
496  for (auto texture_i = inputs.begin() + 1; texture_i < inputs.end();
497  texture_i++) {
498  auto src_input = texture_i->get()->GetSnapshot("PipelineBlend(Src)",
499  renderer, entity);
500  if (!add_blend_command(src_input)) {
501  return true;
502  }
503  }
504  }
505 
506  // If a foreground color is set, blend it in.
507 
508  if (foreground_color.has_value()) {
509  auto contents = std::make_shared<SolidColorContents>();
510  contents->SetGeometry(
511  Geometry::MakeRect(Rect::MakeSize(pass.GetRenderTargetSize())));
512  contents->SetColor(foreground_color.value());
513 
514  Entity foreground_entity;
515  foreground_entity.SetBlendMode(blend_mode);
516  foreground_entity.SetContents(contents);
517  if (!foreground_entity.Render(renderer, pass)) {
518  return false;
519  }
520  }
521 
522  return true;
523  };
524 
525  fml::StatusOr<RenderTarget> render_target = renderer.MakeSubpass(
526  "Pipeline Blend Filter", ISize(subpass_coverage.GetSize()), callback);
527 
528  if (!render_target.ok()) {
529  return std::nullopt;
530  }
531 
532  return Entity::FromSnapshot(
533  Snapshot{
534  .texture = render_target.value().GetRenderTargetTexture(),
535  .transform = Matrix::MakeTranslation(subpass_coverage.GetOrigin()),
536  // Since we absorbed the transform of the inputs and used the
537  // respective snapshot sampling modes when blending, pass on
538  // the default NN clamp sampler.
539  .sampler_descriptor = {},
540  .opacity = (absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
541  ? 1.0f
542  : dst_snapshot->opacity) *
543  alpha.value_or(1.0)},
544  entity.GetBlendMode(), entity.GetClipDepth());
545 }

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), BlendModeToString(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), 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::ContentContext::GetTransientsBuffer(), impeller::TRect< T >::Intersection(), kSource, kTriangleStrip, impeller::ColorFilterContents::kYes, impeller::Geometry::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::ContentContext::MakeSubpass(), impeller::Matrix::MakeTranslation(), OptionsFromPass(), 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 392 of file formats_vk.h.

392  {
393  switch (format) {
394  case PixelFormat::kUnknown:
395  case PixelFormat::kA8UNormInt:
396  case PixelFormat::kR8UNormInt:
397  case PixelFormat::kR8G8UNormInt:
398  case PixelFormat::kR8G8B8A8UNormInt:
399  case PixelFormat::kR8G8B8A8UNormIntSRGB:
400  case PixelFormat::kB8G8R8A8UNormInt:
401  case PixelFormat::kB8G8R8A8UNormIntSRGB:
402  case PixelFormat::kR32G32B32A32Float:
403  case PixelFormat::kR16G16B16A16Float:
404  case PixelFormat::kB10G10R10XR:
405  case PixelFormat::kB10G10R10XRSRGB:
406  case PixelFormat::kB10G10R10A10XR:
407  return false;
408  case PixelFormat::kS8UInt:
409  case PixelFormat::kD24UnormS8Uint:
410  case PixelFormat::kD32FloatS8UInt:
411  return true;
412  }
413  return false;
414 }

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

Referenced by impeller::AllocatorVK::ToVKImageUsageFlags().

â—† PixelFormatToString()

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

Definition at line 141 of file formats.h.

141  {
142  switch (format) {
143  case PixelFormat::kUnknown:
144  return "Unknown";
145  case PixelFormat::kA8UNormInt:
146  return "A8UNormInt";
147  case PixelFormat::kR8UNormInt:
148  return "R8UNormInt";
149  case PixelFormat::kR8G8UNormInt:
150  return "R8G8UNormInt";
151  case PixelFormat::kR8G8B8A8UNormInt:
152  return "R8G8B8A8UNormInt";
153  case PixelFormat::kR8G8B8A8UNormIntSRGB:
154  return "R8G8B8A8UNormIntSRGB";
155  case PixelFormat::kB8G8R8A8UNormInt:
156  return "B8G8R8A8UNormInt";
157  case PixelFormat::kB8G8R8A8UNormIntSRGB:
158  return "B8G8R8A8UNormIntSRGB";
159  case PixelFormat::kR32G32B32A32Float:
160  return "R32G32B32A32Float";
161  case PixelFormat::kR16G16B16A16Float:
162  return "R16G16B16A16Float";
163  case PixelFormat::kB10G10R10XR:
164  return "B10G10R10XR";
165  case PixelFormat::kB10G10R10XRSRGB:
166  return "B10G10R10XRSRGB";
167  case PixelFormat::kB10G10R10A10XR:
168  return "B10G10R10A10XR";
169  case PixelFormat::kS8UInt:
170  return "S8UInt";
171  case PixelFormat::kD24UnormS8Uint:
172  return "D24UnormS8Uint";
173  case PixelFormat::kD32FloatS8UInt:
174  return "D32FloatS8UInt";
175  }
176  FML_UNREACHABLE();
177 }

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

44  {
45  switch (backend) {
46  case PlaygroundBackend::kMetal:
47  return "Metal";
48  case PlaygroundBackend::kOpenGLES:
49  return "OpenGLES";
50  case PlaygroundBackend::kVulkan:
51  return "Vulkan";
52  }
53  FML_UNREACHABLE();
54 }

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 165 of file playground.cc.

169  {
170  if ((key == GLFW_KEY_ESCAPE) && action == GLFW_RELEASE) {
171  if (mods & (GLFW_MOD_CONTROL | GLFW_MOD_SUPER | GLFW_MOD_SHIFT)) {
173  }
174  ::glfwSetWindowShouldClose(window, GLFW_TRUE);
175  }
176 }

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:
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)

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 }

â—† 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 104 of file pipeline_vk.cc.

106  {
107  constexpr bool kReportPipelineCreationFeedbackToLogs = false;
108  constexpr bool kReportPipelineCreationFeedbackToTraces = true;
109  if (kReportPipelineCreationFeedbackToLogs) {
110  ReportPipelineCreationFeedbackToLog(desc, feedback);
111  }
112  if (kReportPipelineCreationFeedbackToTraces) {
114  }
115 }

References ReportPipelineCreationFeedbackToLog(), and ReportPipelineCreationFeedbackToTrace().

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

â—† ReportPipelineCreationFeedbackToLog() [1/2]

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

Definition at line 56 of file pipeline_vk.cc.

58  {
59  std::stringstream stream;
60  stream << std::fixed << std::showpoint << std::setprecision(2);
61  stream << std::endl << ">>>>>>" << std::endl;
62  stream << "Pipeline '" << desc.GetLabel() << "' ";
64  *feedback.pPipelineCreationFeedback);
65  if (feedback.pipelineStageCreationFeedbackCount != 0) {
66  stream << std::endl;
67  }
68  for (size_t i = 0, count = feedback.pipelineStageCreationFeedbackCount;
69  i < count; i++) {
70  stream << "\tStage " << i + 1 << ": ";
72  stream, feedback.pPipelineStageCreationFeedbacks[i]);
73  if (i != count - 1) {
74  stream << std::endl;
75  }
76  }
77  stream << std::endl << "<<<<<<" << std::endl;
78  FML_LOG(ERROR) << stream.str();
79 }

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

â—† ReportPipelineCreationFeedbackToLog() [2/2]

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

Definition at line 39 of file pipeline_vk.cc.

41  {
42  const auto pipeline_cache_hit =
43  feedback.flags &
44  vk::PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit;
45  const auto base_pipeline_accl =
46  feedback.flags &
47  vk::PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration;
48  auto duration = std::chrono::duration_cast<MillisecondsF>(
49  std::chrono::nanoseconds{feedback.duration});
50  stream << "Time: " << duration.count() << "ms"
51  << " Cache Hit: " << static_cast<bool>(pipeline_cache_hit)
52  << " Base Accel: " << static_cast<bool>(base_pipeline_accl)
53  << " Thread: " << std::this_thread::get_id();
54 }

Referenced by ReportPipelineCreationFeedback(), and ReportPipelineCreationFeedbackToLog().

â—† ReportPipelineCreationFeedbackToTrace()

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

Definition at line 81 of file pipeline_vk.cc.

83  {
84  static int64_t gPipelineCacheHits = 0;
85  static int64_t gPipelineCacheMisses = 0;
86  static int64_t gPipelines = 0;
87  if (feedback.pPipelineCreationFeedback->flags &
88  vk::PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit) {
89  gPipelineCacheHits++;
90  } else {
91  gPipelineCacheMisses++;
92  }
93  gPipelines++;
94  static constexpr int64_t kImpellerPipelineTraceID = 1988;
95  FML_TRACE_COUNTER("impeller", //
96  "PipelineCache", // series name
97  kImpellerPipelineTraceID, // series ID
98  "PipelineCacheHits", gPipelineCacheHits, //
99  "PipelineCacheMisses", gPipelineCacheMisses, //
100  "TotalPipelines", gPipelines //
101  );
102 }

Referenced by ReportPipelineCreationFeedback().

â—† ResourceIsLive()

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

Definition at line 328 of file proc_table_gles.cc.

330  {
331  switch (type) {
332  case DebugResourceType::kTexture:
333  return gl.IsTexture(name);
334  case DebugResourceType::kBuffer:
335  return gl.IsBuffer(name);
336  case DebugResourceType::kProgram:
337  return gl.IsProgram(name);
338  case DebugResourceType::kShader:
339  return gl.IsShader(name);
340  case DebugResourceType::kRenderBuffer:
341  return gl.IsRenderbuffer(name);
342  case DebugResourceType::kFrameBuffer:
343  return gl.IsFramebuffer(name);
344  }
345  FML_UNREACHABLE();
346 }

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

â—† 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 32 of file half.h.

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

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

â—† SetClipScissor()

static void impeller::SetClipScissor ( std::optional< Rect clip_coverage,
RenderPass pass,
Point  global_pass_position 
)
static

Definition at line 756 of file entity_pass.cc.

758  {
759  if constexpr (!ContentContext::kEnableStencilThenCover) {
760  return;
761  }
762  // Set the scissor to the clip coverage area. We do this prior to rendering
763  // the clip itself and all its contents.
764  IRect scissor;
765  if (clip_coverage.has_value()) {
766  clip_coverage = clip_coverage->Shift(-global_pass_position);
767  scissor = IRect::RoundOut(clip_coverage.value());
768  // The scissor rect must not exceed the size of the render target.
769  scissor = scissor.Intersection(IRect::MakeSize(pass.GetRenderTargetSize()))
770  .value_or(IRect());
771  }
772  pass.SetScissor(scissor);
773 }

References impeller::RenderPass::GetRenderTargetSize(), impeller::TRect< T >::Intersection(), impeller::ContentContext::kEnableStencilThenCover, impeller::TRect< int64_t >::MakeSize(), impeller::TRect< int64_t >::RoundOut(), impeller::RenderPass::SetScissor(), and impeller::TRect< T >::Shift().

â—† 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().

â—† SetupSwiftshaderOnce()

void impeller::SetupSwiftshaderOnce ( bool  use_swiftshader)

Find and setup the installable client driver for a locally built SwiftShader at known paths. The option to use SwiftShader can only be used once in the process. While calling this method multiple times is fine, specifying a different use_swiftshader value will trip an assertion.

Warning
This call must be made before any Vulkan contexts are created in the process.
Parameters
[in]use_swiftshaderIf SwiftShader should be used.

Definition at line 54 of file swiftshader_utilities.cc.

54  {
55  static bool swiftshader_preference = false;
56  static std::once_flag sOnceInitializer;
57  std::call_once(sOnceInitializer, [use_swiftshader]() {
58  if (use_swiftshader) {
60  swiftshader_preference = use_swiftshader;
61  }
62  });
63  FML_CHECK(swiftshader_preference == use_swiftshader)
64  << "The option to use SwiftShader in a process can only be set once and "
65  "may not be changed later.";
66 }

References FindSwiftShaderICDAtKnownPaths().

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

â—† 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 106 of file playground_impl_gles.cc.

106  {
107  return {
108  std::make_shared<fml::NonOwnedMapping>(
109  impeller_entity_shaders_gles_data,
110  impeller_entity_shaders_gles_length),
111  std::make_shared<fml::NonOwnedMapping>(
112  impeller_modern_shaders_gles_data,
113  impeller_modern_shaders_gles_length),
114  std::make_shared<fml::NonOwnedMapping>(
115  impeller_framebuffer_blend_shaders_gles_data,
116  impeller_framebuffer_blend_shaders_gles_length),
117  std::make_shared<fml::NonOwnedMapping>(
118  impeller_fixtures_shaders_gles_data,
119  impeller_fixtures_shaders_gles_length),
120  std::make_shared<fml::NonOwnedMapping>(
121  impeller_imgui_shaders_gles_data, impeller_imgui_shaders_gles_length),
122  std::make_shared<fml::NonOwnedMapping>(
123  impeller_scene_shaders_gles_data, impeller_scene_shaders_gles_length),
124  };
125 }

Referenced by 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::RenderTargetAllocator::CreateOffscreen(), impeller::RenderTargetAllocator::CreateOffscreenMSAA(), DepthAttachmentToString(), DrawPlaygroundPoint(), 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::RenderTarget::SetupDepthStencilAttachments(), 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 61 of file formats.h.

61  {
62  switch (mode) {
63  case StorageMode::kHostVisible:
64  return "HostVisible";
65  case StorageMode::kDevicePrivate:
66  return "DevicePrivate";
67  case StorageMode::kDeviceTransient:
68  return "DeviceTransient";
69  }
70  FML_UNREACHABLE();
71 }

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

â—† StoreActionPerformsResolve()

constexpr bool impeller::StoreActionPerformsResolve ( StoreAction  store_action)
constexpr

Definition at line 338 of file formats_vk.h.

338  {
339  switch (store_action) {
340  case StoreAction::kDontCare:
341  case StoreAction::kStore:
342  return false;
343  case StoreAction::kMultisampleResolve:
344  case StoreAction::kStoreAndMultisampleResolve:
345  return true;
346  }
347  FML_UNREACHABLE();
348 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by impeller::RenderPassBuilderVK::SetColorAttachment().

â—† StoreActionToString()

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

Definition at line 227 of file formats.h.

227  {
228  switch (action) {
229  case StoreAction::kDontCare:
230  return "DontCare";
231  case StoreAction::kStore:
232  return "Store";
233  case StoreAction::kMultisampleResolve:
234  return "MultisampleResolve";
235  case StoreAction::kStoreAndMultisampleResolve:
236  return "StoreAndMultisampleResolve";
237  }
238 }

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 80 of file allocator_mtl.mm.

80  {
81 #ifdef FML_OS_IOS_SIMULATOR
82  return false;
83 #else
84  if (@available(macOS 10.15, iOS 13, tvOS 13, *)) {
85  return [device supportsFamily:MTLGPUFamilyApple8];
86  }
87  return false;
88 #endif
89 }

â—† 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().

â—† TEST()

impeller::TEST ( ValidationTest  ,
IsFatal   
)

Definition at line 29 of file main.cc.

29  {
30  EXPECT_TRUE(ImpellerValidationErrorsAreFatal());
31 }

References ImpellerValidationErrorsAreFatal().

â—† 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 270 of file formats.h.

270  {
271  switch (type) {
272  case TextureType::kTexture2D:
273  return "Texture2D";
274  case TextureType::kTexture2DMultisample:
275  return "Texture2DMultisample";
276  case TextureType::kTextureCube:
277  return "TextureCube";
278  case TextureType::kTextureExternalOES:
279  return "TextureExternalOES";
280  }
281  FML_UNREACHABLE();
282 }

References kTexture2D, kTexture2DMultisample, kTextureCube, and kTextureExternalOES.

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

â—† TextureUsageMaskToString()

std::string impeller::TextureUsageMaskToString ( TextureUsageMask  mask)

Definition at line 81 of file formats.cc.

81  {
82  std::vector<TextureUsage> usages;
83  if (mask & TextureUsage::kShaderRead) {
84  usages.push_back(TextureUsage::kShaderRead);
85  }
86  if (mask & TextureUsage::kShaderWrite) {
87  usages.push_back(TextureUsage::kShaderWrite);
88  }
89  if (mask & 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 311 of file formats.h.

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

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

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

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 50 of file sampler_gles.cc.

51  {
52  switch (mode) {
53  case SamplerAddressMode::kClampToEdge:
54  return GL_CLAMP_TO_EDGE;
55  case SamplerAddressMode::kRepeat:
56  return GL_REPEAT;
57  case SamplerAddressMode::kMirror:
58  return GL_MIRRORED_REPEAT;
59  case SamplerAddressMode::kDecal:
60  if (supports_decal_sampler_address_mode) {
62  } else {
63  return GL_CLAMP_TO_EDGE;
64  }
65  }
66  FML_UNREACHABLE();
67 }

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

517  {
518  switch (type) {
519  case TextureType::kTexture2D:
520  case TextureType::kTexture2DMultisample:
521  return 1u;
522  case TextureType::kTextureCube:
523  return 6u;
524  case TextureType::kTextureExternalOES:
526  << "kTextureExternalOES can not be used with the Vulkan backend.";
527  }
528  FML_UNREACHABLE();
529 }

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

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK(), impeller::KHRSwapchainImageVK::KHRSwapchainImageVK(), and impeller::TextureSourceVK::SetLayout().

â—† ToAttachmentType()

static GLenum impeller::ToAttachmentType ( TextureGLES::AttachmentType  point)
static

Definition at line 488 of file texture_gles.cc.

488  {
489  switch (point) {
490  case TextureGLES::AttachmentType::kColor0:
491  return GL_COLOR_ATTACHMENT0;
492  case TextureGLES::AttachmentType::kDepth:
493  return GL_DEPTH_ATTACHMENT;
494  case TextureGLES::AttachmentType::kStencil:
495  return GL_STENCIL_ATTACHMENT;
496  }
497 }

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

716  {
717  switch (clip_op) {
718  case flutter::DlCanvas::ClipOp::kDifference:
719  return Entity::ClipOperation::kDifference;
720  case flutter::DlCanvas::ClipOp::kIntersect:
721  return Entity::ClipOperation::kIntersect;
722  }
723 }

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

â—† ToCommitResult()

static CommandBuffer::Status impeller::ToCommitResult ( MTLCommandBufferStatus  status)
static

Definition at line 148 of file command_buffer_mtl.mm.

148  {
149  switch (status) {
150  case MTLCommandBufferStatusCompleted:
151  return CommandBufferMTL::Status::kCompleted;
152  case MTLCommandBufferStatusEnqueued:
153  return CommandBufferMTL::Status::kPending;
154  default:
155  break;
156  }
157  return CommandBufferMTL::Status::kError;
158 }

â—† 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 310 of file proc_table_gles.cc.

310  {
311  switch (type) {
312  case DebugResourceType::kTexture:
313  return GL_TEXTURE;
314  case DebugResourceType::kBuffer:
315  return GL_BUFFER_KHR;
316  case DebugResourceType::kProgram:
317  return GL_PROGRAM_KHR;
318  case DebugResourceType::kShader:
319  return GL_SHADER_KHR;
320  case DebugResourceType::kRenderBuffer:
321  return GL_RENDERBUFFER;
322  case DebugResourceType::kFrameBuffer:
323  return GL_FRAMEBUFFER;
324  }
325  FML_UNREACHABLE();
326 }

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.

â—† ToDeviceType()

constexpr DeviceTypeVK impeller::ToDeviceType ( const vk::PhysicalDeviceType &  type)
constexpr

Definition at line 44 of file driver_info_vk.cc.

44  {
45  switch (type) {
46  case vk::PhysicalDeviceType::eOther:
47  return DeviceTypeVK::kUnknown;
48  case vk::PhysicalDeviceType::eIntegratedGpu:
49  return DeviceTypeVK::kIntegratedGPU;
50  case vk::PhysicalDeviceType::eDiscreteGpu:
51  return DeviceTypeVK::kDiscreteGPU;
52  case vk::PhysicalDeviceType::eVirtualGpu:
53  return DeviceTypeVK::kVirtualGPU;
54  case vk::PhysicalDeviceType::eCpu:
55  return DeviceTypeVK::kCPU;
56  break;
57  }
58  return DeviceTypeVK::kUnknown;
59 }

References kCPU, kDiscreteGPU, kIntegratedGPU, kUnknown, and kVirtualGPU.

Referenced by impeller::DriverInfoVK::DriverInfoVK().

â—† 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 58 of file texture_gles.cc.

58  {
59  switch (type) {
60  case TextureGLES::Type::kTexture:
61  case TextureGLES::Type::kTextureMultisampled:
62  return HandleType::kTexture;
63  case TextureGLES::Type::kRenderBuffer:
64  case TextureGLES::Type::kRenderBufferMultisampled:
65  return HandleType::kRenderBuffer;
66  }
67  FML_UNREACHABLE();
68 }

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

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

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

Referenced by impeller::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 369 of file formats_mtl.h.

369  {
370  return MTLClearColorMake(color.red, color.green, color.blue, color.alpha);
371 }

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

Referenced by ConfigureColorAttachment().

â—† ToMTLColorWriteMask()

constexpr MTLColorWriteMask impeller::ToMTLColorWriteMask ( ColorWriteMask  type)
constexpr

Definition at line 210 of file formats_mtl.h.

210  {
211  MTLColorWriteMask mask = MTLColorWriteMaskNone;
212 
213  if (type & ColorWriteMaskBits::kRed) {
214  mask |= MTLColorWriteMaskRed;
215  }
216 
217  if (type & ColorWriteMaskBits::kGreen) {
218  mask |= MTLColorWriteMaskGreen;
219  }
220 
221  if (type & ColorWriteMaskBits::kBlue) {
222  mask |= MTLColorWriteMaskBlue;
223  }
224 
225  if (type & ColorWriteMaskBits::kAlpha) {
226  mask |= MTLColorWriteMaskAlpha;
227  }
228 
229  return mask;
230 };

References kAlpha, kBlue, kGreen, and kRed.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

â—† ToMTLCompareFunction()

constexpr MTLCompareFunction impeller::ToMTLCompareFunction ( CompareFunction  func)
constexpr

Definition at line 232 of file formats_mtl.h.

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

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

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

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:
103  case PixelFormat::kD32FloatS8UInt:
104  return MTLPixelFormatDepth32Float_Stencil8;
105  case PixelFormat::kB10G10R10XRSRGB:
107  case PixelFormat::kB10G10R10XR:
109  case PixelFormat::kB10G10R10A10XR:
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::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 104 of file render_pass_mtl.mm.

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

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 110 of file allocator_mtl.mm.

112  {
113  switch (type) {
114  case StorageMode::kHostVisible:
115 #if FML_OS_IOS
116  return MTLResourceStorageModeShared;
117 #else
118  if (supports_uma) {
119  return MTLResourceStorageModeShared;
120  } else {
121  return MTLResourceStorageModeManaged;
122  }
123 #endif
124  case StorageMode::kDevicePrivate:
125  return MTLResourceStorageModePrivate;
126  case StorageMode::kDeviceTransient:
127  if (supports_memoryless_targets) {
128  // Device may support but the OS has not been updated.
129  if (@available(macOS 11.0, *)) {
130  return MTLResourceStorageModeMemoryless;
131  } else {
132  return MTLResourceStorageModePrivate;
133  }
134  } else {
135  return MTLResourceStorageModePrivate;
136  }
137  FML_UNREACHABLE();
138  }
139  FML_UNREACHABLE();
140 }

â—† ToMTLSamplerAddressMode()

constexpr MTLSamplerAddressMode impeller::ToMTLSamplerAddressMode ( SamplerAddressMode  mode)
constexpr

Definition at line 354 of file formats_mtl.h.

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

References kClampToEdge, kDecal, kMirror, and kRepeat.

â—† ToMTLSamplerMinMagFilter()

constexpr MTLSamplerMinMagFilter impeller::ToMTLSamplerMinMagFilter ( MinMagFilter  filter)
constexpr

Definition at line 334 of file formats_mtl.h.

334  {
335  switch (filter) {
336  case MinMagFilter::kNearest:
337  return MTLSamplerMinMagFilterNearest;
338  case MinMagFilter::kLinear:
339  return MTLSamplerMinMagFilterLinear;
340  }
341  return MTLSamplerMinMagFilterNearest;
342 }

References kLinear, and kNearest.

â—† ToMTLSamplerMipFilter()

constexpr MTLSamplerMipFilter impeller::ToMTLSamplerMipFilter ( MipFilter  filter)
constexpr

Definition at line 344 of file formats_mtl.h.

344  {
345  switch (filter) {
346  case MipFilter::kNearest:
347  return MTLSamplerMipFilterNearest;
348  case MipFilter::kLinear:
349  return MTLSamplerMipFilterLinear;
350  }
351  return MTLSamplerMipFilterNotMipmapped;
352 }

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

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

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 142 of file allocator_mtl.mm.

144  {
145  switch (mode) {
146  case StorageMode::kHostVisible:
147 #if FML_OS_IOS
148  return MTLStorageModeShared;
149 #else
150  if (supports_uma) {
151  return MTLStorageModeShared;
152  } else {
153  return MTLStorageModeManaged;
154  }
155 #endif
156  case StorageMode::kDevicePrivate:
157  return MTLStorageModePrivate;
158  case StorageMode::kDeviceTransient:
159  if (supports_memoryless_targets) {
160  // Device may support but the OS has not been updated.
161  if (@available(macOS 11.0, *)) {
162  return MTLStorageModeMemoryless;
163  } else {
164  return MTLStorageModePrivate;
165  }
166  } else {
167  return MTLStorageModePrivate;
168  }
169  FML_UNREACHABLE();
170  }
171  FML_UNREACHABLE();
172 }

â—† ToMTLStoreAction()

constexpr MTLStoreAction impeller::ToMTLStoreAction ( StoreAction  action)
constexpr

Definition at line 304 of file formats_mtl.h.

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

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 & TextureUsage::kUnknown) {
99  mtl_desc.usage |= MTLTextureUsageUnknown;
100  }
101  if (desc.usage & TextureUsage::kShaderRead) {
102  mtl_desc.usage |= MTLTextureUsageShaderRead;
103  }
104  if (desc.usage & TextureUsage::kShaderWrite) {
105  mtl_desc.usage |= MTLTextureUsageShaderWrite;
106  }
107  if (desc.usage & 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 373 of file formats_mtl.h.

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

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

static GLint impeller::ToParam ( MinMagFilter  minmag_filter,
std::optional< MipFilter mip_filter = std::nullopt 
)
static

Definition at line 19 of file sampler_gles.cc.

20  {
21  if (!mip_filter.has_value()) {
22  switch (minmag_filter) {
23  case MinMagFilter::kNearest:
24  return GL_NEAREST;
25  case MinMagFilter::kLinear:
26  return GL_LINEAR;
27  }
28  FML_UNREACHABLE();
29  }
30 
31  switch (mip_filter.value()) {
32  case MipFilter::kNearest:
33  switch (minmag_filter) {
34  case MinMagFilter::kNearest:
35  return GL_NEAREST_MIPMAP_NEAREST;
36  case MinMagFilter::kLinear:
37  return GL_LINEAR_MIPMAP_NEAREST;
38  }
39  case MipFilter::kLinear:
40  switch (minmag_filter) {
41  case MinMagFilter::kNearest:
42  return GL_NEAREST_MIPMAP_LINEAR;
43  case MinMagFilter::kLinear:
44  return GL_LINEAR_MIPMAP_LINEAR;
45  }
46  }
47  FML_UNREACHABLE();
48 }

References kLinear, and kNearest.

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

â—† ToPixelFormat() [1/2]

static PixelFormat impeller::ToPixelFormat ( AHardwareBuffer_Format  format)
static

Definition at line 216 of file ahb_texture_source_vk.cc.

216  {
217  switch (format) {
218  case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
219  return PixelFormat::kR8G8B8A8UNormInt;
220  case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
221  return PixelFormat::kR16G16B16A16Float;
222  case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
223  return PixelFormat::kD24UnormS8Uint;
224  case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
225  return PixelFormat::kD32FloatS8UInt;
226  case AHARDWAREBUFFER_FORMAT_S8_UINT:
227  return PixelFormat::kS8UInt;
228  case AHARDWAREBUFFER_FORMAT_R8_UNORM:
229  return PixelFormat::kR8UNormInt;
230  case AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM:
231  case AHARDWAREBUFFER_FORMAT_R16G16_UINT:
232  case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
233  case AHARDWAREBUFFER_FORMAT_R16_UINT:
234  case AHARDWAREBUFFER_FORMAT_D24_UNORM:
235  case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
236  case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
237  case AHARDWAREBUFFER_FORMAT_BLOB:
238  case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
239  case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
240  case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
241  case AHARDWAREBUFFER_FORMAT_D16_UNORM:
242  case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
243  // Not understood by the rest of Impeller. Use a placeholder but create
244  // the native image and image views using the right external format.
245  break;
246  }
247  return PixelFormat::kR8G8B8A8UNormInt;
248 }

References kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR8G8B8A8UNormInt, kR8UNormInt, and kS8UInt.

Referenced by ToTextureDescriptor().

â—† ToPixelFormat() [2/2]

constexpr PixelFormat impeller::ToPixelFormat ( vk::Format  format)
constexpr

Definition at line 172 of file formats_vk.h.

172  {
173  switch (format) {
174  case vk::Format::eUndefined:
175  return PixelFormat::kUnknown;
176  case vk::Format::eR8G8B8A8Unorm:
177  return PixelFormat::kR8G8B8A8UNormInt;
178  case vk::Format::eR8G8B8A8Srgb:
179  return PixelFormat::kR8G8B8A8UNormIntSRGB;
180  case vk::Format::eB8G8R8A8Unorm:
181  return PixelFormat::kB8G8R8A8UNormInt;
182  case vk::Format::eB8G8R8A8Srgb:
183  return PixelFormat::kB8G8R8A8UNormIntSRGB;
184  case vk::Format::eR32G32B32A32Sfloat:
185  return PixelFormat::kR32G32B32A32Float;
186  case vk::Format::eR16G16B16A16Sfloat:
187  return PixelFormat::kR16G16B16A16Float;
188  case vk::Format::eS8Uint:
189  return PixelFormat::kS8UInt;
190  case vk::Format::eD24UnormS8Uint:
191  return PixelFormat::kD24UnormS8Uint;
192  case vk::Format::eD32SfloatS8Uint:
193  return PixelFormat::kD32FloatS8UInt;
194  case vk::Format::eR8Unorm:
195  return PixelFormat::kR8UNormInt;
196  case vk::Format::eR8G8Unorm:
197  return PixelFormat::kR8G8UNormInt;
198  default:
199  return PixelFormat::kUnknown;
200  }
201 }

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

308  {
309  switch (format) {
310  case PixelFormat::kB8G8R8A8UNormInt:
311  case PixelFormat::kR8G8B8A8UNormInt:
312  return GL_RGBA4;
313  case PixelFormat::kR32G32B32A32Float:
314  return GL_RGBA32F;
315  case PixelFormat::kR16G16B16A16Float:
316  return GL_RGBA16F;
317  case PixelFormat::kS8UInt:
318  return GL_STENCIL_INDEX8;
319  case PixelFormat::kD24UnormS8Uint:
320  return GL_DEPTH24_STENCIL8;
321  case PixelFormat::kD32FloatS8UInt:
322  return GL_DEPTH32F_STENCIL8;
323  case PixelFormat::kUnknown:
324  case PixelFormat::kA8UNormInt:
325  case PixelFormat::kR8UNormInt:
326  case PixelFormat::kR8G8UNormInt:
327  case PixelFormat::kR8G8B8A8UNormIntSRGB:
328  case PixelFormat::kB8G8R8A8UNormIntSRGB:
329  case PixelFormat::kB10G10R10XRSRGB:
330  case PixelFormat::kB10G10R10XR:
331  case PixelFormat::kB10G10R10A10XR:
332  return std::nullopt;
333  }
334  FML_UNREACHABLE();
335 }

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  {
151  switch (options) {
152  case flutter::DlFilterMode::kNearest:
154  desc.label = "Nearest Sampler";
155  break;
156  case flutter::DlFilterMode::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  {
127  switch (options) {
128  case flutter::DlImageSampling::kNearestNeighbor:
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:
137  desc.label = "Linear Sampler";
138  break;
139  case flutter::DlImageSampling::kMipmapLinear:
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 30 of file runtime_stage.cc.

30  {
31  switch (stage) {
32  case fb::Stage::kVertex:
33  return RuntimeShaderStage::kVertex;
34  case fb::Stage::kFragment:
35  return RuntimeShaderStage::kFragment;
36  case fb::Stage::kCompute:
37  return RuntimeShaderStage::kCompute;
38  }
39  FML_UNREACHABLE();
40 }

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:
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 64 of file device_buffer_gles.cc.

64  {
65  switch (type) {
66  case DeviceBufferGLES::BindingType::kArrayBuffer:
67  return GL_ARRAY_BUFFER;
68  case DeviceBufferGLES::BindingType::kElementArrayBuffer:
69  return GL_ELEMENT_ARRAY_BUFFER;
70  }
71  FML_UNREACHABLE();
72 }

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  }
55  return TESS_WINDING_ODD;
56 }

References kNonZero, and kOdd.

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

â—† ToTextureDescriptor()

static TextureDescriptor impeller::ToTextureDescriptor ( const AHardwareBuffer_Desc &  ahb_desc)
static

Definition at line 263 of file ahb_texture_source_vk.cc.

264  {
265  const auto ahb_size = ISize{ahb_desc.width, ahb_desc.height};
266  TextureDescriptor desc;
267  // We are not going to touch hardware buffers on the CPU or use them as
268  // transient attachments. Just treat them as device private.
269  desc.storage_mode = StorageMode::kDevicePrivate;
270  desc.format =
271  ToPixelFormat(static_cast<AHardwareBuffer_Format>(ahb_desc.format));
272  desc.size = ahb_size;
273  desc.type = ToTextureType(ahb_desc);
274  desc.sample_count = SampleCount::kCount1;
275  desc.compression_type = CompressionType::kLossless;
276  desc.mip_count = (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE)
277  ? ahb_size.MipCount()
278  : 1u;
279  return desc;
280 }

References impeller::TextureDescriptor::compression_type, impeller::TextureDescriptor::format, kCount1, kDevicePrivate, kLossless, impeller::TextureDescriptor::mip_count, impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, ToPixelFormat(), ToTextureType(), impeller::TextureDescriptor::type, and impeller::TSize< T >::width.

â—† 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() [1/2]

static TextureType impeller::ToTextureType ( const AHardwareBuffer_Desc &  ahb_desc)
static

Definition at line 250 of file ahb_texture_source_vk.cc.

250  {
251  if (ahb_desc.layers == 1u) {
252  return TextureType::kTexture2D;
253  }
254  if (ahb_desc.layers % 6u == 0 &&
255  (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP)) {
256  return TextureType::kTextureCube;
257  }
258  // Our texture types seem to understand external OES textures. Should these be
259  // wired up instead?
260  return TextureType::kTexture2D;
261 }

References kTexture2D, and kTextureCube.

â—† ToTextureType() [2/2]

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(), and ToTextureDescriptor().

â—† 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 18 of file runtime_stage.cc.

18  {
19  switch (type) {
26  }
27  FML_UNREACHABLE();
28 }

References kFloat, kSampledImage, and kStruct.

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

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

â—† 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 301 of file formats_vk.h.

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

References kClear, kDontCare, and kLoad.

Referenced by impeller::RenderPassBuilderVK::SetColorAttachment(), impeller::RenderPassBuilderVK::SetDepthStencilAttachment(), and impeller::RenderPassBuilderVK::SetStencilAttachment().

â—† ToVKAttachmentStoreOp()

constexpr vk::AttachmentStoreOp impeller::ToVKAttachmentStoreOp ( StoreAction  store_action,
bool  is_resolve_texture 
)
constexpr

Definition at line 314 of file formats_vk.h.

315  {
316  switch (store_action) {
317  case StoreAction::kStore:
318  // Both MSAA and resolve textures need to be stored. A resolve is NOT
319  // performed.
320  return vk::AttachmentStoreOp::eStore;
321  case StoreAction::kDontCare:
322  // Both MSAA and resolve textures can be discarded. A resolve is NOT
323  // performed.
324  return vk::AttachmentStoreOp::eDontCare;
325  case StoreAction::kMultisampleResolve:
326  // The resolve texture is stored but the MSAA texture can be discarded. A
327  // resolve IS performed.
328  return is_resolve_texture ? vk::AttachmentStoreOp::eStore
329  : vk::AttachmentStoreOp::eDontCare;
330  case StoreAction::kStoreAndMultisampleResolve:
331  // Both MSAA and resolve textures need to be stored. A resolve IS
332  // performed.
333  return vk::AttachmentStoreOp::eStore;
334  }
335  FML_UNREACHABLE();
336 }

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

Referenced by impeller::RenderPassBuilderVK::SetColorAttachment(), impeller::RenderPassBuilderVK::SetDepthStencilAttachment(), and impeller::RenderPassBuilderVK::SetStencilAttachment().

â—† ToVKBlendFactor()

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

Definition at line 31 of file formats_vk.h.

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

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

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

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 ( ColorWriteMask  type)
constexpr

Definition at line 79 of file formats_vk.h.

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

References kAlpha, kBlue, kGreen, and kRed.

Referenced by ToVKPipelineColorBlendAttachmentState().

â—† ToVKCompareOp()

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

Definition at line 431 of file formats_vk.h.

431  {
432  switch (op) {
433  case CompareFunction::kNever:
434  return vk::CompareOp::eNever;
435  case CompareFunction::kAlways:
436  return vk::CompareOp::eAlways;
437  case CompareFunction::kLess:
438  return vk::CompareOp::eLess;
439  case CompareFunction::kEqual:
440  return vk::CompareOp::eEqual;
441  case CompareFunction::kLessEqual:
442  return vk::CompareOp::eLessOrEqual;
443  case CompareFunction::kGreater:
444  return vk::CompareOp::eGreater;
445  case CompareFunction::kNotEqual:
446  return vk::CompareOp::eNotEqual;
447  case CompareFunction::kGreaterEqual:
448  return vk::CompareOp::eGreaterOrEqual;
449  }
450  FML_UNREACHABLE();
451 }

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

419  {
420  switch (mode) {
421  case CullMode::kNone:
422  return vk::CullModeFlagBits::eNone;
423  case CullMode::kFrontFace:
424  return vk::CullModeFlagBits::eFront;
425  case CullMode::kBackFace:
426  return vk::CullModeFlagBits::eBack;
427  }
428  FML_UNREACHABLE();
429 }

References kBackFace, kFrontFace, and kNone.

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

â—† ToVKDescriptorSetLayoutBinding()

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

Definition at line 291 of file formats_vk.h.

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

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

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

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

Referenced by impeller::PipelineVK::Create(), and ToVKDescriptorSetLayoutBinding().

â—† ToVKFrontFace()

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

Definition at line 29 of file pipeline_vk.cc.

29  {
30  switch (order) {
31  case WindingOrder::kClockwise:
32  return vk::FrontFace::eClockwise;
33  case WindingOrder::kCounterClockwise:
34  return vk::FrontFace::eCounterClockwise;
35  }
36  FML_UNREACHABLE();
37 }

References kClockwise, and kCounterClockwise.

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

â—† ToVKImageAspectFlags()

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

Definition at line 491 of file formats_vk.h.

491  {
492  switch (format) {
493  case PixelFormat::kUnknown:
494  case PixelFormat::kA8UNormInt:
495  case PixelFormat::kR8UNormInt:
496  case PixelFormat::kR8G8UNormInt:
497  case PixelFormat::kR8G8B8A8UNormInt:
498  case PixelFormat::kR8G8B8A8UNormIntSRGB:
499  case PixelFormat::kB8G8R8A8UNormInt:
500  case PixelFormat::kB8G8R8A8UNormIntSRGB:
501  case PixelFormat::kR32G32B32A32Float:
502  case PixelFormat::kR16G16B16A16Float:
503  case PixelFormat::kB10G10R10XR:
504  case PixelFormat::kB10G10R10XRSRGB:
505  case PixelFormat::kB10G10R10A10XR:
506  return vk::ImageAspectFlagBits::eColor;
507  case PixelFormat::kS8UInt:
508  return vk::ImageAspectFlagBits::eStencil;
509  case PixelFormat::kD24UnormS8Uint:
510  case PixelFormat::kD32FloatS8UInt:
511  return vk::ImageAspectFlagBits::eDepth |
512  vk::ImageAspectFlagBits::eStencil;
513  }
514  FML_UNREACHABLE();
515 }

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

545  {
546  switch (type) {
547  case TextureType::kTexture2D:
548  case TextureType::kTexture2DMultisample:
549  return {};
550  case TextureType::kTextureCube:
551  return vk::ImageCreateFlagBits::eCubeCompatible;
552  case TextureType::kTextureExternalOES:
554  << "kTextureExternalOES can not be used with the Vulkan backend.";
555  }
556  FML_UNREACHABLE();
557 }

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

135  {
136  switch (format) {
137  case PixelFormat::kUnknown:
138  case PixelFormat::kB10G10R10XR:
139  case PixelFormat::kB10G10R10A10XR:
140  case PixelFormat::kB10G10R10XRSRGB:
141  return vk::Format::eUndefined;
142  case PixelFormat::kA8UNormInt:
143  // TODO(csg): This is incorrect. Don't depend on swizzle support for GLES.
144  return vk::Format::eR8Unorm;
145  case PixelFormat::kR8G8B8A8UNormInt:
146  return vk::Format::eR8G8B8A8Unorm;
147  case PixelFormat::kR8G8B8A8UNormIntSRGB:
148  return vk::Format::eR8G8B8A8Srgb;
149  case PixelFormat::kB8G8R8A8UNormInt:
150  return vk::Format::eB8G8R8A8Unorm;
151  case PixelFormat::kB8G8R8A8UNormIntSRGB:
152  return vk::Format::eB8G8R8A8Srgb;
153  case PixelFormat::kR32G32B32A32Float:
154  return vk::Format::eR32G32B32A32Sfloat;
155  case PixelFormat::kR16G16B16A16Float:
156  return vk::Format::eR16G16B16A16Sfloat;
157  case PixelFormat::kS8UInt:
158  return vk::Format::eS8Uint;
159  case PixelFormat::kD24UnormS8Uint:
160  return vk::Format::eD24UnormS8Uint;
161  case PixelFormat::kD32FloatS8UInt:
162  return vk::Format::eD32SfloatS8Uint;
163  case PixelFormat::kR8UNormInt:
164  return vk::Format::eR8Unorm;
165  case PixelFormat::kR8G8UNormInt:
166  return vk::Format::eR8G8Unorm;
167  }
168 
169  FML_UNREACHABLE();
170 }

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

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK(), ChooseSurfaceFormat(), impeller::KHRSwapchainImageVK::KHRSwapchainImageVK(), impeller::RenderPassBuilderVK::SetColorAttachment(), impeller::RenderPassBuilderVK::SetDepthStencilAttachment(), and impeller::RenderPassBuilderVK::SetStencilAttachment().

â—† ToVKImageViewType()

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

Definition at line 531 of file formats_vk.h.

531  {
532  switch (type) {
533  case TextureType::kTexture2D:
534  case TextureType::kTexture2DMultisample:
535  return vk::ImageViewType::e2D;
536  case TextureType::kTextureCube:
537  return vk::ImageViewType::eCube;
538  case TextureType::kTextureExternalOES:
540  << "kTextureExternalOES can not be used with the Vulkan backend.";
541  }
542  FML_UNREACHABLE();
543 }

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

350  {
351  switch (index_type) {
352  case IndexType::k16bit:
353  return vk::IndexType::eUint16;
354  case IndexType::k32bit:
355  return vk::IndexType::eUint32;
356  case IndexType::kUnknown:
357  return vk::IndexType::eUint32;
358  case IndexType::kNone:
359  FML_UNREACHABLE();
360  }
361 
362  FML_UNREACHABLE();
363 }

References k16bit, k32bit, kNone, and kUnknown.

â—† ToVKPipelineColorBlendAttachmentState()

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

Definition at line 102 of file formats_vk.h.

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

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.

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

â—† 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().

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

â—† ToVKPolygonMode()

constexpr vk::PolygonMode impeller::ToVKPolygonMode ( PolygonMode  mode)
constexpr

Definition at line 365 of file formats_vk.h.

365  {
366  switch (mode) {
367  case PolygonMode::kFill:
368  return vk::PolygonMode::eFill;
369  case PolygonMode::kLine:
370  return vk::PolygonMode::eLine;
371  }
372  FML_UNREACHABLE();
373 }

References kFill, and kLine.

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

â—† ToVKPrimitiveTopology()

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

Definition at line 375 of file formats_vk.h.

375  {
376  switch (primitive) {
377  case PrimitiveType::kTriangle:
378  return vk::PrimitiveTopology::eTriangleList;
379  case PrimitiveType::kTriangleStrip:
380  return vk::PrimitiveTopology::eTriangleStrip;
381  case PrimitiveType::kLine:
382  return vk::PrimitiveTopology::eLineList;
383  case PrimitiveType::kLineStrip:
384  return vk::PrimitiveTopology::eLineStrip;
385  case PrimitiveType::kPoint:
386  return vk::PrimitiveTopology::ePointList;
387  }
388 
389  FML_UNREACHABLE();
390 }

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

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

â—† ToVKSampleCount()

constexpr vk::SampleCountFlagBits impeller::ToVKSampleCount ( SampleCount  sample_count)
constexpr

Definition at line 203 of file formats_vk.h.

203  {
204  switch (sample_count) {
205  case SampleCount::kCount1:
206  return vk::SampleCountFlagBits::e1;
207  case SampleCount::kCount4:
208  return vk::SampleCountFlagBits::e4;
209  }
210 
211  FML_UNREACHABLE();
212 }

References kCount1, and kCount4.

Referenced by impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK(), impeller::RenderPassBuilderVK::SetColorAttachment(), impeller::RenderPassBuilderVK::SetDepthStencilAttachment(), and impeller::RenderPassBuilderVK::SetStencilAttachment().

â—† ToVKSampleCountFlagBits()

constexpr vk::SampleCountFlagBits impeller::ToVKSampleCountFlagBits ( SampleCount  count)
constexpr

Definition at line 21 of file formats_vk.h.

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

References kCount1, and kCount4.

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

â—† ToVKSamplerAddressMode()

constexpr vk::SamplerAddressMode impeller::ToVKSamplerAddressMode ( SamplerAddressMode  mode)
constexpr

Definition at line 236 of file formats_vk.h.

237  {
238  switch (mode) {
239  case SamplerAddressMode::kRepeat:
240  return vk::SamplerAddressMode::eRepeat;
241  case SamplerAddressMode::kMirror:
242  return vk::SamplerAddressMode::eMirroredRepeat;
243  case SamplerAddressMode::kClampToEdge:
244  return vk::SamplerAddressMode::eClampToEdge;
245  case SamplerAddressMode::kDecal:
246  return vk::SamplerAddressMode::eClampToBorder;
247  }
248 
249  FML_UNREACHABLE();
250 }

References kClampToEdge, kDecal, kMirror, and kRepeat.

Referenced by CreateSampler().

â—† ToVKSamplerMinMagFilter()

constexpr vk::Filter impeller::ToVKSamplerMinMagFilter ( MinMagFilter  filter)
constexpr

Definition at line 214 of file formats_vk.h.

214  {
215  switch (filter) {
216  case MinMagFilter::kNearest:
217  return vk::Filter::eNearest;
218  case MinMagFilter::kLinear:
219  return vk::Filter::eLinear;
220  }
221 
222  FML_UNREACHABLE();
223 }

References kLinear, and kNearest.

Referenced by CreateSampler().

â—† ToVKSamplerMipmapMode()

constexpr vk::SamplerMipmapMode impeller::ToVKSamplerMipmapMode ( MipFilter  filter)
constexpr

Definition at line 225 of file formats_vk.h.

225  {
226  switch (filter) {
227  case MipFilter::kNearest:
228  return vk::SamplerMipmapMode::eNearest;
229  case MipFilter::kLinear:
230  return vk::SamplerMipmapMode::eLinear;
231  }
232 
233  FML_UNREACHABLE();
234 }

References kLinear, and kNearest.

Referenced by CreateSampler().

â—† ToVkShaderStage()

constexpr vk::ShaderStageFlags impeller::ToVkShaderStage ( ShaderStage  stage)
constexpr

Definition at line 252 of file formats_vk.h.

252  {
253  switch (stage) {
254  case ShaderStage::kUnknown:
255  return vk::ShaderStageFlagBits::eAll;
256  case ShaderStage::kFragment:
257  return vk::ShaderStageFlagBits::eFragment;
258  case ShaderStage::kCompute:
259  return vk::ShaderStageFlagBits::eCompute;
260  case ShaderStage::kVertex:
261  return vk::ShaderStageFlagBits::eVertex;
262  }
263 
264  FML_UNREACHABLE();
265 }

References kCompute, kFragment, kUnknown, and kVertex.

Referenced by impeller::PipelineVK::Create(), and ToVKDescriptorSetLayoutBinding().

â—† ToVKShaderStageFlagBits()

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

Definition at line 120 of file formats_vk.h.

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

References kCompute, kFragment, kUnknown, and kVertex.

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

â—† ToVKStencilOp()

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

Definition at line 453 of file formats_vk.h.

453  {
454  switch (op) {
455  case StencilOperation::kKeep:
456  return vk::StencilOp::eKeep;
457  case StencilOperation::kZero:
458  return vk::StencilOp::eZero;
459  case StencilOperation::kSetToReferenceValue:
460  return vk::StencilOp::eReplace;
461  case StencilOperation::kIncrementClamp:
462  return vk::StencilOp::eIncrementAndClamp;
463  case StencilOperation::kDecrementClamp:
464  return vk::StencilOp::eDecrementAndClamp;
465  case StencilOperation::kInvert:
466  return vk::StencilOp::eInvert;
467  case StencilOperation::kIncrementWrap:
468  return vk::StencilOp::eIncrementAndWrap;
469  case StencilOperation::kDecrementWrap:
470  return vk::StencilOp::eDecrementAndWrap;
471  break;
472  }
473  FML_UNREACHABLE();
474 }

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

477  {
478  vk::StencilOpState state;
479  state.failOp = ToVKStencilOp(desc.stencil_failure);
480  state.passOp = ToVKStencilOp(desc.depth_stencil_pass);
481  state.depthFailOp = ToVKStencilOp(desc.depth_failure);
482  state.compareOp = ToVKCompareOp(desc.stencil_compare);
483  state.compareMask = desc.read_mask;
484  state.writeMask = desc.write_mask;
485  // This is irrelevant as the stencil references are always dynamic state and
486  // will be set in the render pass.
487  state.reference = 1988;
488  return state;
489 }

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

250  {
251  switch (mode) {
252  case StorageMode::kHostVisible:
253  return vk::MemoryPropertyFlagBits::eHostVisible |
254  vk::MemoryPropertyFlagBits::eDeviceLocal;
255  case StorageMode::kDevicePrivate:
256  return vk::MemoryPropertyFlagBits::eDeviceLocal;
257  case StorageMode::kDeviceTransient:
258  if (supports_memoryless_textures) {
259  return vk::MemoryPropertyFlagBits::eLazilyAllocated |
260  vk::MemoryPropertyFlagBits::eDeviceLocal;
261  }
262  return vk::MemoryPropertyFlagBits::eDeviceLocal;
263  }
264  FML_UNREACHABLE();
265 }

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

â—† ToVmaAllocationBufferCreateFlags()

static VmaAllocationCreateFlags impeller::ToVmaAllocationBufferCreateFlags ( StorageMode  mode,
bool  readback 
)
static

Definition at line 32 of file allocator_vk.cc.

34  {
35  VmaAllocationCreateFlags flags = 0;
36  switch (mode) {
37  case StorageMode::kHostVisible:
38  if (!readback) {
39  flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
40  } else {
41  flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;
42  }
43  flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
44  return flags;
45  case StorageMode::kDevicePrivate:
46  FML_DCHECK(!readback);
47  return flags;
48  case StorageMode::kDeviceTransient:
49  FML_DCHECK(!readback);
50  return flags;
51  }
52  FML_UNREACHABLE();
53 }

References kDevicePrivate, kDeviceTransient, and kHostVisible.

Referenced by CreateBufferPool().

â—† ToVmaAllocationCreateFlags()

static VmaAllocationCreateFlags impeller::ToVmaAllocationCreateFlags ( StorageMode  mode)
static

Definition at line 267 of file allocator_vk.cc.

267  {
268  VmaAllocationCreateFlags flags = 0;
269  switch (mode) {
270  case StorageMode::kHostVisible:
271  return flags;
272  case StorageMode::kDevicePrivate:
273  return flags;
274  case StorageMode::kDeviceTransient:
275  return flags;
276  }
277  FML_UNREACHABLE();
278 }

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

â—† ToVMAMemoryUsage()

static constexpr VmaMemoryUsage impeller::ToVMAMemoryUsage ( )
staticconstexpr

Definition at line 244 of file allocator_vk.cc.

244  {
245  return VMA_MEMORY_USAGE_AUTO;
246 }

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 190 of file typographer_context_skia.cc.

192  {
193  TRACE_EVENT0("impeller", __FUNCTION__);
194  FML_DCHECK(bitmap != nullptr);
195 
196  auto surface = SkSurfaces::WrapPixels(bitmap->pixmap());
197  if (!surface) {
198  return false;
199  }
200  auto canvas = surface->getCanvas();
201  if (!canvas) {
202  return false;
203  }
204 
205  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
206 
207  for (const FontGlyphPair& pair : new_pairs) {
208  auto pos = atlas.FindFontGlyphBounds(pair);
209  if (!pos.has_value()) {
210  continue;
211  }
212  DrawGlyph(canvas, pair.scaled_font, pair.glyph, pos.value(), has_color);
213  }
214  return true;
215 }

References DrawGlyph(), impeller::GlyphAtlas::FindFontGlyphBounds(), impeller::GlyphAtlas::GetType(), and impeller::GlyphAtlas::kColorBitmap.

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

â—† 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 260 of file typographer_context_skia.cc.

261  {
262  TRACE_EVENT0("impeller", __FUNCTION__);
263 
264  FML_DCHECK(bitmap != nullptr);
265  auto texture_descriptor = texture->GetTextureDescriptor();
266 
267  auto mapping = std::make_shared<fml::NonOwnedMapping>(
268  reinterpret_cast<const uint8_t*>(bitmap->getAddr(0, 0)), // data
269  texture_descriptor.GetByteSizeOfBaseMipLevel(), // size
270  [bitmap](auto, auto) mutable { bitmap.reset(); } // proc
271  );
272 
273  return texture->SetContents(mapping);
274 }

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 276 of file typographer_context_skia.cc.

280  {
281  TRACE_EVENT0("impeller", __FUNCTION__);
282  if (!allocator) {
283  return nullptr;
284  }
285 
286  FML_DCHECK(bitmap != nullptr);
287  const auto& pixmap = bitmap->pixmap();
288 
289  TextureDescriptor texture_descriptor;
290  texture_descriptor.storage_mode = StorageMode::kHostVisible;
291  texture_descriptor.format = format;
292  texture_descriptor.size = atlas_size;
293 
294  if (pixmap.rowBytes() * pixmap.height() !=
295  texture_descriptor.GetByteSizeOfBaseMipLevel()) {
296  return nullptr;
297  }
298 
299  auto texture = allocator->CreateTexture(texture_descriptor);
300  if (!texture || !texture->IsValid()) {
301  return nullptr;
302  }
303  texture->SetLabel("GlyphAtlas");
304 
305  auto mapping = std::make_shared<fml::NonOwnedMapping>(
306  reinterpret_cast<const uint8_t*>(bitmap->getAddr(0, 0)), // data
307  texture_descriptor.GetByteSizeOfBaseMipLevel(), // size
308  [bitmap](auto, auto) mutable { bitmap.reset(); } // proc
309  );
310 
311  if (!texture->SetContents(mapping)) {
312  return nullptr;
313  }
314  return texture;
315 }

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

850  {
851  // If there are no vertex color or texture coordinates. Or if there
852  // are vertex coordinates then only if the contents are an image or
853  // a solid color.
854  if (vertices->HasVertexColors()) {
855  return false;
856  }
857  if (vertices->HasTextureCoordinates() &&
858  (paint.color_source.GetType() == ColorSource::Type::kImage ||
859  paint.color_source.GetType() == ColorSource::Type::kColor)) {
860  return true;
861  }
862  return !vertices->HasTextureCoordinates();
863 }

References impeller::Paint::color_source, impeller::ColorSource::GetType(), and kColor.

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

39  {
40  vk::ClearColorValue value;
41  value.setFloat32(
42  std::array<float, 4>{color.red, color.green, color.blue, color.alpha});
43  return value;
44 }

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

47  {
48  vk::ClearDepthStencilValue value;
49  value.depth = depth;
50  value.stencil = stencil;
51  return value;
52 }

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 47 of file surface_mtl.mm.

51  {
52  // compositor_context.cc will offset the rendering by the clip origin. Here we
53  // shrink to the size of the clip. This has the same effect as clipping the
54  // rendering but also creates smaller intermediate passes.
55  ISize root_size;
56  if (requires_blit) {
57  if (!clip_rect.has_value()) {
58  VALIDATION_LOG << "Missing clip rectangle.";
59  return std::nullopt;
60  }
61  root_size = ISize(clip_rect->GetWidth(), clip_rect->GetHeight());
62  } else {
63  root_size = {static_cast<ISize::Type>(texture.width),
64  static_cast<ISize::Type>(texture.height)};
65  }
66 
67  TextureDescriptor resolve_tex_desc;
68  resolve_tex_desc.format = FromMTLPixelFormat(texture.pixelFormat);
69  resolve_tex_desc.size = root_size;
70  resolve_tex_desc.usage =
71  TextureUsage::kRenderTarget | TextureUsage::kShaderRead;
72  resolve_tex_desc.sample_count = SampleCount::kCount1;
73  resolve_tex_desc.storage_mode = StorageMode::kDevicePrivate;
74 
75  if (resolve_tex_desc.format == PixelFormat::kUnknown) {
76  VALIDATION_LOG << "Unknown drawable color format.";
77  return std::nullopt;
78  }
79 
80  // Create color resolve texture.
81  std::shared_ptr<Texture> resolve_tex;
82  if (requires_blit) {
83  resolve_tex_desc.compression_type = CompressionType::kLossy;
84  resolve_tex = allocator.CreateTexture(resolve_tex_desc);
85  } else {
86  resolve_tex = TextureMTL::Create(resolve_tex_desc, texture);
87  }
88 
89  if (!resolve_tex) {
90  VALIDATION_LOG << "Could not wrap resolve texture.";
91  return std::nullopt;
92  }
93  resolve_tex->SetLabel("ImpellerOnscreenResolve");
94 
95  TextureDescriptor msaa_tex_desc;
96  msaa_tex_desc.storage_mode = StorageMode::kDeviceTransient;
97  msaa_tex_desc.type = TextureType::kTexture2DMultisample;
98  msaa_tex_desc.sample_count = SampleCount::kCount4;
99  msaa_tex_desc.format = resolve_tex->GetTextureDescriptor().format;
100  msaa_tex_desc.size = resolve_tex->GetSize();
101  msaa_tex_desc.usage = TextureUsage::kRenderTarget;
102 
103  auto msaa_tex = allocator.CreateTexture(msaa_tex_desc);
104  if (!msaa_tex) {
105  VALIDATION_LOG << "Could not allocate MSAA color texture.";
106  return std::nullopt;
107  }
108  msaa_tex->SetLabel("ImpellerOnscreenColorMSAA");
109 
110  ColorAttachment color0;
111  color0.texture = msaa_tex;
112  color0.clear_color = Color::DarkSlateGray();
113  color0.load_action = LoadAction::kClear;
114  color0.store_action = StoreAction::kMultisampleResolve;
115  color0.resolve_texture = std::move(resolve_tex);
116 
117  auto render_target_desc = std::make_optional<RenderTarget>();
118  render_target_desc->SetColorAttachment(color0, 0u);
119 
120  return render_target_desc;
121 }

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

â—† gHasValidationLayers

bool impeller::gHasValidationLayers = false
static

Definition at line 46 of file context_vk.cc.

Referenced by HasValidationLayers().

â—† gShouldOpenNewPlaygrounds

std::atomic_bool impeller::gShouldOpenNewPlaygrounds = true
static

â—† 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

â—† kAlloc

const TESSalloc impeller::kAlloc
static
Initial value:
= {
16,
16,
16,
16,
16,
0
}

Definition at line 24 of file tessellator.cc.

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

â—† kAllocatorBlockSize

constexpr size_t impeller::kAllocatorBlockSize = 1024000
constexpr

Definition at line 18 of file host_buffer.cc.

â—† kAngleInputAttachmentPrefix

constexpr std::string_view impeller::kAngleInputAttachmentPrefix
staticconstexpr
Initial value:
=
"ANGLEInputAttachment"

Definition at line 21 of file buffer_bindings_gles.cc.

Referenced by impeller::BufferBindingsGLES::ReadUniformsBindings().

â—† kBlendModeNames

constexpr const char* impeller::kBlendModeNames[]
staticconstexpr
Initial value:

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

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

â—† kDefaultBindingSize

const constexpr DescriptorPoolSize impeller::kDefaultBindingSize
staticconstexpr
Initial value:
=
DescriptorPoolSize{
.buffer_bindings = 512u,
.texture_bindings = 256u,
.storage_bindings = 32,
.subpass_bindings = 4u
}

Descriptor pools are always allocated with the following sizes.

Definition at line 24 of file descriptor_pool_vk.cc.

â—† kDefaultCurveTolerance

constexpr Scalar impeller::kDefaultCurveTolerance = .1f
staticconstexpr

â—† kDefaultStencilConfig

const constexpr RenderTarget::AttachmentConfig impeller::kDefaultStencilConfig
staticconstexpr
Initial value:
=
RenderTarget::AttachmentConfig{
.storage_mode = StorageMode::kDeviceTransient,
.load_action = LoadAction::kDontCare,
.store_action = StoreAction::kDontCare,
}

Definition at line 308 of file entity_pass.cc.

Referenced by CreateRenderTarget(), and impeller::EntityPass::Render().

â—† kE

constexpr float impeller::kE = 2.7182818284590452354f
constexpr

Definition at line 11 of file constants.h.

â—† kEhCloseEnough

â—† 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 42 of file geometry.h.

â—† kFramebufferFetchExt

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

Definition at line 13 of file capabilities_gles.cc.

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

â—† kHostBufferArenaSize

const constexpr size_t impeller::kHostBufferArenaSize = 3u
staticconstexpr

Approximately the same size as the max frames in flight.

Definition at line 22 of file host_buffer.h.

Referenced by impeller::HostBuffer::Reset().

â—† 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 15 of file capabilities_vk.cc.

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

â—† kKernelRadiusPerSigma

constexpr static float impeller::kKernelRadiusPerSigma = 1.73205080757
staticconstexpr

For filters that use a Gaussian distribution, this is the Radius size to use per Sigma (standard deviation).

This cutoff (sqrt(3)) is taken from Flutter and Skia (where the multiplicative inverse of this constant is used (1 / sqrt(3)): https://api.flutter.dev/flutter/dart-ui/Shadow/convertRadiusToSigma.html

In practice, this value is somewhat arbitrary, and can be changed to a higher number to integrate more of the Gaussian function and render higher quality blurs (with exponentially diminishing returns for the same sigma input). Making this value any lower results in a noticable loss of quality in the blur.

Definition at line 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 = 64u
staticconstexpr

Definition at line 37 of file render_pass_vk.cc.

â—† 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.

â—† kMaxBindings

constexpr size_t impeller::kMaxBindings = 32
staticconstexpr

Definition at line 26 of file pipeline_vk.h.

â—† kMaxFramesInFlight

constexpr size_t impeller::kMaxFramesInFlight = 3u
staticconstexpr

Definition at line 22 of file khr_swapchain_impl_vk.cc.

â—† kMultisampledRenderToTextureExt

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

Definition at line 22 of file capabilities_gles.cc.

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

â—† kNullGlyphAtlas

const std::shared_ptr<GlyphAtlas> impeller::kNullGlyphAtlas = nullptr
static

Definition at line 17 of file lazy_glyph_atlas.cc.

Referenced by impeller::LazyGlyphAtlas::CreateOrGetGlyphAtlas().

â—† kNullSampler [1/3]

const std::unique_ptr<const Sampler> impeller::kNullSampler = nullptr
static

Definition at line 14 of file sampler_library_gles.cc.

â—† kNullSampler [2/3]

const std::unique_ptr<const Sampler> impeller::kNullSampler = nullptr
static

Definition at line 16 of file sampler_library_mtl.mm.

â—† kNullSampler [3/3]

const std::unique_ptr<const Sampler> impeller::kNullSampler = nullptr
static

Definition at line 19 of file sampler_library_vk.cc.

â—† kNvidiaTextureBorderClampExt

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

Definition at line 18 of file capabilities_gles.cc.

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

â—† kPadding

constexpr size_t impeller::kPadding = 2
constexpr

â—† 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

â—† kPiOver2

constexpr float impeller::kPiOver2 = 1.57079632679489661923f
constexpr

â—† kPiOver4

constexpr float impeller::kPiOver4 = 0.78539816339744830962f
constexpr

â—† 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 27 of file khr_swapchain_impl_vk.cc.

â—† kPoolSize

constexpr uint32_t impeller::kPoolSize = 128u
staticconstexpr

Definition at line 23 of file gpu_tracer_vk.cc.

Referenced by impeller::GPUTracerVK::InitializeQueryPool().

â—† 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 248 of file tessellator.cc.

Referenced by ComputeQuadrantDivisions().

â—† kPrecomputedDivisions

int impeller::kPrecomputedDivisions[kPrecomputedDivisionCount]
static

Definition at line 249 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().

â—† kSelfDependencyDstAccessMask

constexpr auto impeller::kSelfDependencyDstAccessMask
constexpr
Initial value:
=
vk::AccessFlagBits::eInputAttachmentRead

Definition at line 20 of file render_pass_builder_vk.cc.

Referenced by impeller::RenderPassBuilderVK::Build(), and InsertBarrierForInputAttachmentRead().

â—† kSelfDependencyDstStageMask

constexpr auto impeller::kSelfDependencyDstStageMask
constexpr
Initial value:
=
vk::PipelineStageFlagBits::eFragmentShader

Definition at line 18 of file render_pass_builder_vk.cc.

Referenced by impeller::RenderPassBuilderVK::Build(), and InsertBarrierForInputAttachmentRead().

â—† kSelfDependencyFlags

constexpr auto impeller::kSelfDependencyFlags = vk::DependencyFlagBits::eByRegion
constexpr

â—† kSelfDependencySrcAccessMask

constexpr auto impeller::kSelfDependencySrcAccessMask
constexpr
Initial value:
=
vk::AccessFlagBits::eColorAttachmentWrite

Definition at line 15 of file render_pass_builder_vk.cc.

Referenced by impeller::RenderPassBuilderVK::Build(), and InsertBarrierForInputAttachmentRead().

â—† kSelfDependencySrcStageMask

constexpr auto impeller::kSelfDependencySrcStageMask
constexpr
Initial value:
=
vk::PipelineStageFlagBits::eColorAttachmentOutput

Definition at line 13 of file render_pass_builder_vk.cc.

Referenced by impeller::RenderPassBuilderVK::Build(), and InsertBarrierForInputAttachmentRead().

â—† kSkipTests

const std::vector<std::string> impeller::kSkipTests
static
Initial value:
= {
IMP_AIKSTEST(TextRotated),
"impeller_Play_AiksTest_CanRenderClippedRuntimeEffects_Vulkan",
}

Definition at line 64 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 16 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 416 of file formats_vk.h.

Referenced by impeller::RenderPassBuilderVK::Build().

â—† sLastID

std::atomic_size_t impeller::sLastID
static

Definition at line 11 of file comparable.cc.

â—† sValidationLogsAreFatal

â—† sValidationLogsDisabledCount

std::atomic_int32_t impeller::sValidationLogsDisabledCount = 0
static

â—† tess

Tessellator impeller::tess
static

Definition at line 56 of file geometry_benchmarks.cc.

Referenced by BM_Convex(), and BM_Polyline().

â—† tls_command_pool_map

thread_local std::unique_ptr<CommandPoolMap> impeller::tls_command_pool_map
static
impeller::StoreAction::kMultisampleResolve
@ kMultisampleResolve
impeller::PixelFormat::kS8UInt
@ kS8UInt
impeller::TextureType::kTextureExternalOES
@ kTextureExternalOES
impeller::BlendSelectValues::kSaturation
@ kSaturation
impeller::kFloat
@ kFloat
Definition: runtime_types.h:23
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
impeller::ToMTLColorWriteMask
constexpr MTLColorWriteMask ToMTLColorWriteMask(ColorWriteMask type)
Definition: formats_mtl.h:210
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:42
impeller::CompareFunction::kGreater
@ kGreater
Comparison test passes if new_value > current_value.
impeller::PrimitiveType::kLineStrip
@ kLineStrip
impeller::LoadAction::kLoad
@ kLoad
impeller::VKClearValueFromDepthStencil
static vk::ClearDepthStencilValue VKClearValueFromDepthStencil(uint32_t stencil, Scalar depth)
Definition: render_pass_vk.cc:46
impeller::HandleType::kRenderBuffer
@ kRenderBuffer
impeller::ConfigureStencil
void ConfigureStencil(const ProcTableGLES &gl, const PipelineDescriptor &pipeline, uint32_t stencil_reference)
Definition: render_pass_gles.cc:94
impeller::TextureUsage::kShaderWrite
@ kShaderWrite
impeller::BlendModeToString
const char * BlendModeToString(BlendMode blend_mode)
Definition: color.cc:47
impeller::kClipPath
@ kClipPath
Definition: canvas_recorder.h:44
impeller::BlendMode::kDestinationATop
@ kDestinationATop
impeller::ApplyBlendedColor
static constexpr Color ApplyBlendedColor(Color dst, Color src, Vector3 blend_result)
Definition: color.cc:201
impeller::StencilOperation::kDecrementClamp
@ kDecrementClamp
Decrement the current stencil value by 1. Clamp it to zero.
impeller::gHasValidationLayers
static bool gHasValidationLayers
Definition: context_vk.cc:46
polyline
const Path::Polyline & polyline
Definition: stroke_path_geometry.cc:292
impeller::ToVKColorComponentFlags
constexpr vk::ColorComponentFlags ToVKColorComponentFlags(ColorWriteMask type)
Definition: formats_vk.h:79
impeller::StoreAction::kStoreAndMultisampleResolve
@ kStoreAndMultisampleResolve
impeller::ColorToString
std::string ColorToString(const Color &color)
Definition: color.cc:410
impeller::ShaderType::kAtomicCounter
@ kAtomicCounter
impeller::kClipOval
@ kClipOval
Definition: canvas_recorder.h:46
impeller::ConfigureColorAttachment
static bool ConfigureColorAttachment(const ColorAttachment &desc, MTLRenderPassColorAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:73
impeller::IndexType::k16bit
@ k16bit
impeller::PixelFormatToString
constexpr const char * PixelFormatToString(PixelFormat format)
Definition: formats.h:141
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::BlendSelectValues::kColorBurn
@ kColorBurn
impeller::SourceRectConstraint::kFast
@ kFast
Faster, but may sample outside the bounds of the source rectangle.
impeller::ShaderType::kDouble
@ kDouble
impeller::ContentBoundsPromise::kMayClipContents
@ kMayClipContents
The caller claims the bounds are a subset of an estimate of the reasonably tight bounds but likely cl...
impeller::Font
Describes a typeface along with any modifications to its intrinsic properties.
Definition: font.h:22
impeller::DeviceTypeVK::kDiscreteGPU
@ kDiscreteGPU
impeller::DeviceTypeVK::kIntegratedGPU
@ kIntegratedGPU
impeller::sValidationLogsAreFatal
static std::atomic_int32_t sValidationLogsAreFatal
Definition: validation.cc:14
impeller::BlendSelectValues::kMultiply
@ kMultiply
impeller::ToVKSamplerAddressMode
constexpr vk::SamplerAddressMode ToVKSamplerAddressMode(SamplerAddressMode mode)
Definition: formats_vk.h:236
impeller::DeviceSupportsComputeSubgroups
static bool DeviceSupportsComputeSubgroups(id< MTLDevice > device)
Definition: context_mtl.mm:42
impeller::PixelFormat::kB10G10R10A10XR
@ kB10G10R10A10XR
impeller::PixelFormat::kB8G8R8A8UNormIntSRGB
@ kB8G8R8A8UNormIntSRGB
impeller::ConfigureStencilAttachment
static bool ConfigureStencilAttachment(const StencilAttachment &desc, MTLRenderPassStencilAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:93
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:31
impeller::UVMode::kUVRect
@ kUVRect
impeller::DeleteFBO
static void DeleteFBO(const ProcTableGLES &gl, GLuint fbo, GLenum type)
Definition: blit_command_gles.cc:16
impeller::BlendFactor::kSourceAlphaSaturated
@ kSourceAlphaSaturated
impeller::MyMaskBits::kBaz
@ kBaz
impeller::ReportPipelineCreationFeedbackToTrace
static void ReportPipelineCreationFeedbackToTrace(const PipelineDescriptor &desc, const vk::PipelineCreationFeedbackCreateInfoEXT &feedback)
Definition: pipeline_vk.cc:81
impeller::FillType::kOdd
@ kOdd
impeller::NearZero
static bool NearZero(Scalar a)
Definition: path_component.cc:253
impeller::compiler::SourceType::kUnknown
@ kUnknown
impeller::PixelFormat::kR8UNormInt
@ kR8UNormInt
impeller::kSelfDependencyDstAccessMask
constexpr auto kSelfDependencyDstAccessMask
Definition: render_pass_builder_vk.cc:20
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_vk.cc:56
impeller::ToImageFilter
static std::shared_ptr< ImageFilter > ToImageFilter(const flutter::DlImageFilter *filter)
Definition: dl_dispatcher.cc:525
impeller::Color::Unpremultiply
constexpr Color Unpremultiply() const
Definition: color.h:218
impeller::ColorWriteMaskBits::kGreen
@ kGreen
impeller::CompareFunction::kEqual
@ kEqual
Comparison test passes if new_value == current_value.
impeller::ToVKDescriptorType
constexpr vk::DescriptorType ToVKDescriptorType(DescriptorType type)
Definition: formats_vk.h:267
impeller::BlendFactor::kOneMinusSourceAlpha
@ kOneMinusSourceAlpha
impeller::kEhCloseEnough
constexpr float kEhCloseEnough
Definition: constants.h:56
impeller::kSelfDependencySrcStageMask
constexpr auto kSelfDependencySrcStageMask
Definition: render_pass_builder_vk.cc:13
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:254
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:216
impeller::BlendMode::kSource
@ kSource
impeller::PixelFormat::kR8G8B8A8UNormInt
@ kR8G8B8A8UNormInt
impeller::BlendMode::kDestination
@ kDestination
impeller::VendorVK::kPowerVR
@ kPowerVR
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:45
impeller::HandleType::kTexture
@ kTexture
impeller::ConfigureAttachment
static bool ConfigureAttachment(const Attachment &desc, MTLRenderPassAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:56
impeller::UVMode::kUVRectTx
@ kUVRectTx
impeller::ShaderType::kSignedInt64
@ kSignedInt64
impeller::HasSuitableDepthStencilFormat
static bool HasSuitableDepthStencilFormat(const vk::PhysicalDevice &device, vk::Format format)
Definition: capabilities_vk.cc:290
impeller::kRotate
@ kRotate
Definition: canvas_recorder.h:33
impeller::PointStyle::kRound
@ kRound
Points are drawn as squares.
impeller::TRect::Intersection
constexpr std::optional< TRect > Intersection(const TRect &o) const
Definition: rect.h:461
impeller::StencilOperation::kIncrementClamp
@ kIncrementClamp
Increment the current stencil value by 1. Clamp it to the maximum.
impeller::ShaderType::kImage
@ kImage
impeller::tess
static Tessellator tess
Definition: geometry_benchmarks.cc:56
impeller::MTLCommandBufferErrorToString
static NSString * MTLCommandBufferErrorToString(MTLCommandBufferError code)
Definition: command_buffer_mtl.mm:35
impeller::BlendMode::kDestinationOver
@ kDestinationOver
impeller::BlendMode::kPlus
@ kPlus
impeller::BlendSelectValues::kSoftLight
@ kSoftLight
impeller::kSampledImage
@ kSampledImage
Definition: runtime_types.h:24
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::ToVKSamplerMipmapMode
constexpr vk::SamplerMipmapMode ToVKSamplerMipmapMode(MipFilter filter)
Definition: formats_vk.h:225
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:304
impeller::Size
TSize< Scalar > Size
Definition: size.h:137
impeller::BlendSelectValues::kDifference
@ kDifference
impeller::ShaderType::kSignedByte
@ kSignedByte
impeller::IndexType::k32bit
@ k32bit
impeller::TextureUsage::kRenderTarget
@ kRenderTarget
impeller::StorageMode::kHostVisible
@ kHostVisible
impeller::OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback
@ kEXTPipelineCreationFeedback
impeller::ToMTLCompareFunction
constexpr MTLCompareFunction ToMTLCompareFunction(CompareFunction func)
Definition: formats_mtl.h:232
impeller::kSelfDependencyFlags
constexpr auto kSelfDependencyFlags
Definition: render_pass_builder_vk.cc:23
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
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::ShaderType::kUnsignedShort
@ kUnsignedShort
impeller::kSave
@ kSave
Definition: canvas_recorder.h:21
stroke_width
const Scalar stroke_width
Definition: stroke_path_geometry.cc:293
impeller::ToVKStencilOpState
constexpr vk::StencilOpState ToVKStencilOpState(const StencilAttachmentDescriptor &desc)
Definition: formats_vk.h:476
impeller::NormalizeUniformKey
static std::string NormalizeUniformKey(const std::string &key)
Definition: buffer_bindings_gles.cc:57
impeller::ToMTLClearColor
MTLClearColor ToMTLClearColor(const Color &color)
Definition: formats_mtl.h:369
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: dl_dispatcher.cc:36
IMP_AIKSTEST
#define IMP_AIKSTEST(name)
Definition: golden_playground_test_mac.cc:57
impeller::ToTileMode
static Entity::TileMode ToTileMode(flutter::DlTileMode tile_mode)
Definition: dl_dispatcher.cc:111
impeller::BlendMode::kModulate
@ kModulate
impeller::PolygonMode::kFill
@ kFill
impeller::MyMaskBits::kFoo
@ kFoo
impeller::StencilOperation::kSetToReferenceValue
@ kSetToReferenceValue
Reset the stencil value to the reference value.
impeller::ToVKCompareOp
constexpr vk::CompareOp ToVKCompareOp(CompareFunction op)
Definition: formats_vk.h:431
impeller::Join::kMiter
@ kMiter
impeller::BlendFactor::kSourceColor
@ kSourceColor
impeller::ShaderType::kUnsignedInt64
@ kUnsignedInt64
impeller::TRect::Shift
constexpr TRect< T > Shift(T dx, T dy) const
Returns a new rectangle translated by the given offset.
Definition: rect.h:531
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::MyMaskBits::kBar
@ kBar
impeller::VendorVK::kARM
@ kARM
impeller::VendorVK::kGoogle
@ kGoogle
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:40
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::GetShaderClipDepth
static Scalar GetShaderClipDepth(const Entity &entity)
Definition: clip_contents.cc:18
impeller::MinMagFilter::kNearest
@ kNearest
Select nearest to the sample point. Most widely supported.
impeller::ShaderType::kUnsignedByte
@ kUnsignedByte
impeller::ToVKStencilOp
constexpr vk::StencilOp ToVKStencilOp(StencilOperation op)
Definition: formats_vk.h:453
impeller::SamplerDescriptor::mag_filter
MinMagFilter mag_filter
Definition: sampler_descriptor.h:17
impeller::kDefaultStencilConfig
static const constexpr RenderTarget::AttachmentConfig kDefaultStencilConfig
Definition: entity_pass.cc:308
impeller::TextureCoordinateSystem::kUploadFromHost
@ kUploadFromHost
impeller::VS
SolidFillVertexShader VS
Definition: stroke_path_geometry.cc:15
impeller::SamplerDescriptor
Definition: sampler_descriptor.h:15
impeller::kColor
@ kColor
Definition: geometry.h:51
impeller::PrimitiveType::kTriangle
@ kTriangle
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:83
impeller::TextureCoordinateSystem::kRenderToTexture
@ kRenderToTexture
impeller::ToSamplerDescriptor
static impeller::SamplerDescriptor ToSamplerDescriptor(const flutter::DlFilterMode options)
Definition: dl_dispatcher.cc:148
impeller::SourceRectConstraint::kStrict
@ kStrict
Sample only within the source rectangle. May be slower.
impeller::kDrawTextFrame
@ kDrawTextFrame
Definition: canvas_recorder.h:48
impeller::ColorWriteMaskBits::kAll
@ kAll
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:249
impeller::PointStyle::kSquare
@ kSquare
Points are drawn as circles.
impeller::PrimitiveType::kTriangleStrip
@ kTriangleStrip
impeller::RuntimeShaderStage::kFragment
@ kFragment
impeller::RequiredAndroidDeviceExtensionVK::kKHRExternalMemory
@ kKHRExternalMemory
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:316
impeller::CullMode::kBackFace
@ kBackFace
impeller::ToMTLLoadAction
constexpr MTLLoadAction ToMTLLoadAction(LoadAction action)
Definition: formats_mtl.h:276
impeller::VendorVK::kAMD
@ kAMD
impeller::CullMode::kNone
@ kNone
InternalHalf
uint16_t InternalHalf
Definition: half.h:23
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:135
impeller::BlendOperation::kReverseSubtract
@ kReverseSubtract
impeller::ToTextureType
static TextureType ToTextureType(const AHardwareBuffer_Desc &ahb_desc)
Definition: ahb_texture_source_vk.cc:250
IPLR_RELEASE
#define IPLR_RELEASE(...)
Definition: thread_safety.h:42
impeller::ShaderType::kBoolean
@ kBoolean
impeller::Tessellator::TessellateConvex
std::vector< Point > TessellateConvex(const Path &path, Scalar tolerance)
Given a convex path, create a triangle fan structure.
Definition: tessellator.cc:179
impeller::BlendFactor::kBlendAlpha
@ kBlendAlpha
impeller::RequiredAndroidDeviceExtensionVK::kKHRDedicatedAllocation
@ kKHRDedicatedAllocation
impeller::compiler::TargetPlatform::kVulkan
@ kVulkan
impeller::SPrintF
std::string SPrintF(const char *format,...)
Definition: strings.cc:12
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::ContainsFormat
static bool ContainsFormat(const std::vector< vk::SurfaceFormatKHR > &formats, vk::SurfaceFormatKHR format)
Definition: khr_swapchain_impl_vk.cc:74
impeller::gShouldOpenNewPlaygrounds
static std::atomic_bool gShouldOpenNewPlaygrounds
Definition: playground.cc:159
impeller::UVMode::kNoUV
@ kNoUV
impeller::RequiredAndroidDeviceExtensionVK::kANDROIDExternalMemoryAndroidHardwareBuffer
@ kANDROIDExternalMemoryAndroidHardwareBuffer
impeller::ToMTLRenderPipelineColorAttachmentDescriptor
MTLRenderPipelineColorAttachmentDescriptor * ToMTLRenderPipelineColorAttachmentDescriptor(ColorAttachmentDescriptor descriptor)
Definition: formats_mtl.mm:15
impeller::DeviceSupportsFramebufferFetch
static bool DeviceSupportsFramebufferFetch(id< MTLDevice > device)
Definition: context_mtl.mm:22
impeller::YUVColorSpace::kBT601FullRange
@ kBT601FullRange
impeller::ToMode
constexpr GLenum ToMode(PrimitiveType primitive_type)
Definition: formats_gles.h:18
impeller::VendorVK::kMesa
@ kMesa
impeller::BlendOperation::kAdd
@ kAdd
impeller::VendorVK::kApple
@ kApple
impeller::ShaderType::kSampler
@ kSampler
impeller::MinMagFilter::kLinear
@ kLinear
impeller::StorageMode::kDevicePrivate
@ kDevicePrivate
impeller::StorageModeToString
constexpr const char * StorageModeToString(StorageMode mode)
Definition: formats.h:61
impeller::IsDepthStencilFormat
static bool IsDepthStencilFormat(PixelFormat format)
Definition: texture_gles.cc:21
impeller::kSelfDependencyDstStageMask
constexpr auto kSelfDependencyDstStageMask
Definition: render_pass_builder_vk.cc:18
impeller::BlendFactor::kBlendColor
@ kBlendColor
impeller::kDrawRect
@ kDrawRect
Definition: canvas_recorder.h:37
impeller::VendorVK::kImgTec
@ kImgTec
impeller::RequiredAndroidDeviceExtensionVK::kKHRSamplerYcbcrConversion
@ kKHRSamplerYcbcrConversion
impeller::ColorMatrix::array
Scalar array[20]
Definition: color.h:118
impeller::RequiredCommonDeviceExtensionVK::kKHRSwapchain
@ kKHRSwapchain
impeller::PixelFormat::kB10G10R10XR
@ kB10G10R10XR
impeller::CompressionType::kLossless
@ kLossless
impeller::AttachmentToString
std::string AttachmentToString(const Attachment &attachment)
Definition: formats.cc:104
impeller::PixelFormat::kD24UnormS8Uint
@ kD24UnormS8Uint
impeller::kSkew
@ kSkew
Definition: canvas_recorder.h:32
impeller::kClipRRect
@ kClipRRect
Definition: canvas_recorder.h:47
impeller::WindingOrder::kCounterClockwise
@ kCounterClockwise
impeller::BlendFactor::kOneMinusBlendColor
@ kOneMinusBlendColor
impeller::TRect::Scale
constexpr TRect Scale(Type scale) const
Definition: rect.h:188
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:29
impeller::kDrawImageRect
@ kDrawImageRect
Definition: canvas_recorder.h:43
impeller::PixelFormat::kR16G16B16A16Float
@ kR16G16B16A16Float
impeller::ScalarNearlyZero
constexpr bool ScalarNearlyZero(Scalar x, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:25
impeller::VendorVK::kQualcomm
@ kQualcomm
impeller::StoreAction::kStore
@ kStore
impeller::ToVkShaderStage
constexpr vk::ShaderStageFlags ToVkShaderStage(ShaderStage stage)
Definition: formats_vk.h:252
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:661
impeller::DeviceTypeVK::kVirtualGPU
@ kVirtualGPU
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::BlendFactor::kOneMinusBlendAlpha
@ kOneMinusBlendAlpha
impeller::TextureUsageMask
Mask< TextureUsage > TextureUsageMask
Definition: formats.h:309
impeller::CompressionType::kLossy
@ kLossy
impeller::DebugResourceType::kShader
@ kShader
impeller::kStruct
@ kStruct
Definition: runtime_types.h:25
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::FindSwiftShaderICDAtKnownPaths
static void FindSwiftShaderICDAtKnownPaths()
Definition: swiftshader_utilities.cc:20
impeller::kDrawAtlas
@ kDrawAtlas
Definition: canvas_recorder.h:50
impeller::skia_conversions::ToPoint
Point ToPoint(const SkPoint &point)
Definition: skia_conversions.cc:140
impeller::kPadding
constexpr auto kPadding
Definition: typographer_context_skia.cc:30
impeller::YUVColorSpace::kBT601LimitedRange
@ kBT601LimitedRange
impeller::ConfigureResolveTextureAttachment
static bool ConfigureResolveTextureAttachment(const Attachment &desc, MTLRenderPassAttachmentDescriptor *attachment)
Definition: render_pass_mtl.mm:27
impeller::TextureType::kTexture2D
@ kTexture2D
impeller::TSize::width
Type width
Definition: size.h:22
impeller::FillType::kNonZero
@ kNonZero
impeller::PixelFormat::kR32G32B32A32Float
@ kR32G32B32A32Float
impeller::DescriptorType::kUniformBuffer
@ kUniformBuffer
impeller::SamplerDescriptor::mip_filter
MipFilter mip_filter
Definition: sampler_descriptor.h:18
impeller::OptionalDeviceExtensionVK::kVKKHRPortabilitySubset
@ kVKKHRPortabilitySubset
IMPELLER_FOR_EACH_BLEND_MODE
#define IMPELLER_FOR_EACH_BLEND_MODE(V)
Definition: color.h:19
impeller::IRect
TRect< int64_t > IRect
Definition: rect.h:662
impeller::HandleType::kProgram
@ kProgram
impeller::kDrawPaint
@ kDrawPaint
Definition: canvas_recorder.h:35
impeller::TPoint::x
Type x
Definition: point.h:30
impeller::VerifyExistingCache
static bool VerifyExistingCache(const fml::Mapping &mapping, const CapabilitiesVK &caps)
Definition: pipeline_cache_vk.cc:19
impeller::ShaderType::kUnsignedInt
@ kUnsignedInt
impeller::kNew
@ kNew
Definition: canvas_recorder.h:20
impeller::kUV
@ kUV
Definition: geometry.h:52
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::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::NearEqual
static bool NearEqual(Scalar a, Scalar b, Scalar epsilon)
Definition: path_component.cc:249
impeller::BlendMode::kDestinationIn
@ kDestinationIn
impeller::ToMTLTextureType
constexpr MTLTextureType ToMTLTextureType(TextureType type)
Definition: formats_mtl.h:373
impeller::Join::kBevel
@ kBevel
VALIDATION_LOG
#define VALIDATION_LOG
Definition: validation.h:73
impeller::CullMode::kFrontFace
@ kFrontFace
impeller::ColorWriteMaskBits::kAlpha
@ kAlpha
_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:270
impeller::BlendMode::kDestinationOut
@ kDestinationOut
impeller::DeviceTypeVK::kCPU
@ kCPU
impeller::VendorVK::kIntel
@ kIntel
impeller::ShaderType::kSignedShort
@ kSignedShort
impeller::ShaderType::kHalfFloat
@ kHalfFloat
impeller::ClipColor
static constexpr Vector3 ClipColor(Vector3 color)
Definition: color.cc:144
impeller::ToVKSamplerMinMagFilter
constexpr vk::Filter ToVKSamplerMinMagFilter(MinMagFilter filter)
Definition: formats_vk.h:214
impeller::ShaderType::kSignedInt
@ kSignedInt
impeller::MyMaskBits::kBang
@ kBang
impeller::GetExtensionName
static const char * GetExtensionName(OptionalDeviceExtensionVK ext)
Definition: capabilities_vk.cc:184
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::DrawPlaygroundPoint
Point DrawPlaygroundPoint(PlaygroundPoint &point)
Definition: widgets.cc:9
impeller::HasSuitableColorFormat
static bool HasSuitableColorFormat(const vk::PhysicalDevice &device, vk::Format format)
Definition: capabilities_vk.cc:282
impeller::kDrawPoints
@ kDrawPoints
Definition: canvas_recorder.h:41
impeller::BlendSelectValues::kHardLight
@ kHardLight
impeller::ConfigureBlending
void ConfigureBlending(const ProcTableGLES &gl, const ColorAttachmentDescriptor *color)
Definition: render_pass_gles.cc:43
impeller::ImpellerValidationErrorsAreFatal
bool ImpellerValidationErrorsAreFatal()
Definition: validation.cc:63
impeller::LoadAction::kDontCare
@ kDontCare
impeller::BlendSelectValues::kScreen
@ kScreen
impeller::ColorWriteMask
Mask< ColorWriteMaskBits > ColorWriteMask
Definition: formats.h:446
impeller::TPoint< Scalar >
DISABLE_COLOR_FONT_SUPPORT
#define DISABLE_COLOR_FONT_SUPPORT
Definition: typographer_context_stb.cc:18
impeller::saturated::b
SI b
Definition: saturated_math.h:87
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:58
impeller::ToMTLBlendFactor
constexpr MTLBlendFactor ToMTLBlendFactor(BlendFactor type)
Definition: formats_mtl.h:115
impeller::BlendFactor::kOneMinusSourceColor
@ kOneMinusSourceColor
impeller::ColorWriteMaskBits::kRed
@ kRed
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::TextureUsage::kShaderRead
@ kShaderRead
impeller::BlendMode::kSourceIn
@ kSourceIn
impeller::RuntimeShaderStage::kCompute
@ kCompute
impeller::FromMTLPixelFormat
constexpr PixelFormat FromMTLPixelFormat(MTLPixelFormat format)
Definition: formats_mtl.h:23
impeller::ColorWriteMaskBits::kBlue
@ kBlue
scale
const Scalar scale
Definition: stroke_path_geometry.cc:297
impeller::VendorVK::kNvidia
@ kNvidia
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::FromRGB
static constexpr Color FromRGB(Vector3 color, Scalar alpha)
Definition: color.cc:192
impeller::kDrawOval
@ kDrawOval
Definition: canvas_recorder.h:38
impeller::BlendMode::kLast
@ kLast
impeller::SampleCount::kCount1
@ kCount1
impeller::BlendSelectValues::kHue
@ kHue
impeller::SampleCount::kCount4
@ kCount4
impeller::BlendSelectValues::kLuminosity
@ kLuminosity
impeller::TextureDescriptor::storage_mode
StorageMode storage_mode
Definition: texture_descriptor.h:38
impeller::kPrecomputedDivisionCount
static constexpr int kPrecomputedDivisionCount
Definition: tessellator.cc:248
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:227
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::ToVKBlendOp
constexpr vk::BlendOp ToVKBlendOp(BlendOperation op)
Definition: formats_vk.h:67
impeller::BlendMode::kXor
@ kXor
impeller::RequiredAndroidDeviceExtensionVK::kEXTQueueFamilyForeign
@ kEXTQueueFamilyForeign
impeller::kSelfDependencySrcAccessMask
constexpr auto kSelfDependencySrcAccessMask
Definition: render_pass_builder_vk.cc:15
impeller::HandleType::kBuffer
@ kBuffer
impeller::YUVConversionDescriptorVK
vk::StructureChain< vk::SamplerYcbcrConversionCreateInfo > YUVConversionDescriptorVK
Definition: yuv_conversion_vk.h:30
impeller::Convexity::kConvex
@ kConvex
impeller::kDrawVertices
@ kDrawVertices
Definition: canvas_recorder.h:49
impeller::PixelFormat::kB8G8R8A8UNormInt
@ kB8G8R8A8UNormInt
impeller::BlendFactor::kSourceAlpha
@ kSourceAlpha
impeller::AttachmentTypeString
static const char * AttachmentTypeString(GLint type)
Definition: proc_table_gles.cc:229
impeller::kDrawLine
@ kDrawLine
Definition: canvas_recorder.h:36
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:39
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::ContentBoundsPromise::kContainsContents
@ kContainsContents
The caller claims the bounds are a reasonably tight estimate of the coverage of the contents and shou...
impeller::ToVmaAllocationBufferCreateFlags
static VmaAllocationCreateFlags ToVmaAllocationBufferCreateFlags(StorageMode mode, bool readback)
Definition: allocator_vk.cc:32
impeller::TextureUsageToString
constexpr const char * TextureUsageToString(TextureUsage usage)
Definition: formats.h:311
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:50
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:157
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:45
impeller::VKClearValueFromColor
static vk::ClearColorValue VKClearValueFromColor(Color color)
Definition: render_pass_vk.cc:39
impeller::compiler::TargetPlatform::kSkSL
@ kSkSL
impeller::ToPixelFormat
static PixelFormat ToPixelFormat(AHardwareBuffer_Format format)
Definition: ahb_texture_source_vk.cc:216
impeller::DescriptorType::kStorageBuffer
@ kStorageBuffer
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...