| Flutter Impeller |

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
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 `QueueVK`s. 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< Color > | ToColors (const flutter::DlColor colors[], int count)
static std::optional< ColorSource::Type > | ToColorSourceType (flutter::DlColorSourceType type)
static std::shared_ptr< ColorFilter > | ToColorFilter (const flutter::DlColorFilter *filter)
static FilterContents::BlurStyle | ToBlurStyle (flutter::DlBlurStyle blur_style)
static std::shared_ptr< ImageFilter > | ToImageFilter (const flutter::DlImageFilter *filter)
static Entity::ClipOperation | ToClipOperation (flutter::DlCanvas::ClipOp clip_op)
static Rect | ToRect (const SkRect &rect)
static VerticesGeometry::VertexMode | ToVertexMode (flutter::DlVertexMode mode)
std::shared_ptr< impeller::VerticesGeometry > | MakeVertices (const flutter::DlVertices *vertices)
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< BlendMode > | InvertPorterDuffBlend (BlendMode blend_mode)
template<typename TPipeline >
static std::optional< Entity > | AdvancedBlend (const FilterInput::Vector &inputs, const ContentContext &renderer, const Entity &entity, const Rect &coverage, BlendMode blend_mode, std::optional< Color > foreground_color, ColorFilterContents::AbsorbOpacity absorb_opacity, PipelineProc pipeline_proc, std::optional< Scalar > alpha)
static std::optional< Entity > | PipelineBlend (const FilterInput::Vector &inputs, const ContentContext &renderer, const Entity &entity, const Rect &coverage, BlendMode blend_mode, std::optional< Color > foreground_color, ColorFilterContents::AbsorbOpacity absorb_opacity, std::optional< Scalar > alpha)
KernelPipeline::FragmentShader::KernelSamples | GenerateBlurInfo (BlurParameters parameters)
KernelPipeline::FragmentShader::KernelSamples | LerpHackKernelSamples (KernelPipeline::FragmentShader::KernelSamples parameters)
std::shared_ptr< Texture > | CreateGradientTexture (const GradientData &gradient_data, const std::shared_ptr< impeller::Context > &context)
| Create a host visible texture that contains the gradient defined by the provided gradient data. More...
std::vector< StopData > | CreateGradientColors (const std::vector< Color > &colors, const std::vector< Scalar > &stops)
| Populate a vector with the color and stop data for a gradient. More...
static ShaderType | GetShaderType (RuntimeUniformType type)
static std::shared_ptr< ShaderMetadata > | MakeShaderMetadata (const RuntimeUniformDescription &uniform)
static std::optional< SamplerAddressMode > | TileModeToAddressMode (Entity::TileMode tile_mode, const Capabilities &capabilities)
static 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< Texture > | CreateTextureForDecompressedImage (const std::shared_ptr< Context > &context, DecompressedImage &decompressed_image, bool enable_mipmapping)
constexpr RuntimeStageBackend | PlaygroundBackendToRuntimeStageBackend (PlaygroundBackend backend)
Point | DrawPlaygroundPoint (PlaygroundPoint &point)
std::tuple< Point, Point > | DrawPlaygroundLine (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< Version > | DetermineVersion (std::string version)
static GLenum | ToTarget (DeviceBufferGLES::BindingType type)
std::string | DebugToFramebufferError (int status)
constexpr GLenum | ToMode (PrimitiveType primitive_type)
constexpr GLenum | ToIndexType (IndexType type)
constexpr GLenum | ToStencilOp (StencilOperation op)
constexpr GLenum | ToCompareFunction (CompareFunction func)
constexpr GLenum | ToBlendFactor (BlendFactor factor)
constexpr GLenum | ToBlendOperation (BlendOperation op)
constexpr std::optional< GLenum > | ToVertexAttribType (ShaderType type)
constexpr GLenum | ToTextureType (TextureType type)
constexpr std::optional< GLenum > | ToTextureTarget (TextureType type)
std::string | HandleTypeToString (HandleType type)
static std::string | GetShaderInfoLog (const ProcTableGLES &gl, GLuint shader)
static std::string | GetShaderSource (const ProcTableGLES &gl, GLuint shader)
static void | LogShaderCompilationFailure (const ProcTableGLES &gl, GLuint shader, const std::string &name, const fml::Mapping &source_mapping, ShaderStage stage)
static bool | LinkProgram (const ReactorGLES &reactor, const std::shared_ptr< PipelineGLES > &pipeline, const std::shared_ptr< const ShaderFunction > &vert_function, const std::shared_ptr< const ShaderFunction > &frag_function)
const char * | GLErrorToString (GLenum value)
bool | GLErrorIsFatal (GLenum value)
ProcTableGLES::Resolver | WrappedResolver (const ProcTableGLES::Resolver &resolver)
static const char * | FramebufferStatusToString (GLenum status)
static const char * | AttachmentTypeString (GLint type)
static std::string | DescribeFramebufferAttachment (const ProcTableGLES &gl, GLenum attachment)
static std::optional< GLenum > | ToDebugIdentifier (DebugResourceType type)
static bool | ResourceIsLive (const ProcTableGLES &gl, DebugResourceType type, GLint name)
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< Capabilities > | InferMetalCapabilities (id< MTLDevice > device, PixelFormat color_format)
static NSArray< id< MTLLibrary > > * | MTLShaderLibraryFromFilePaths (id< MTLDevice > device, const std::vector< std::string > &libraries_paths)
static NSArray< id< MTLLibrary > > * | MTLShaderLibraryFromFileData (id< MTLDevice > device, const std::vector< std::shared_ptr< fml::Mapping >> &libraries_data, const std::string &label)
static id< MTLDevice > | CreateMetalDevice ()
static id< MTLCommandQueue > | CreateMetalCommandQueue (id< MTLDevice > device)
constexpr PixelFormat | FromMTLPixelFormat (MTLPixelFormat format)
MTLPixelFormat | SafeMTLPixelFormatDepth24Unorm_Stencil8 ()
MTLPixelFormat | SafeMTLPixelFormatBGR10_XR_sRGB ()
MTLPixelFormat | SafeMTLPixelFormatBGR10_XR ()
MTLPixelFormat | SafeMTLPixelFormatBGRA10_XR ()
constexpr MTLPixelFormat | ToMTLPixelFormat (PixelFormat format)
constexpr MTLBlendFactor | ToMTLBlendFactor (BlendFactor type)
constexpr MTLPrimitiveType | ToMTLPrimitiveType (PrimitiveType type)
constexpr MTLTriangleFillMode | ToMTLTriangleFillMode (PolygonMode mode)
constexpr MTLIndexType | ToMTLIndexType (IndexType type)
constexpr MTLCullMode | ToMTLCullMode (CullMode mode)
constexpr MTLBlendOperation | ToMTLBlendOperation (BlendOperation type)
constexpr MTLColorWriteMask | ToMTLColorWriteMask (ColorWriteMask type)
constexpr MTLCompareFunction | ToMTLCompareFunction (CompareFunction func)
constexpr MTLStencilOperation | ToMTLStencilOperation (StencilOperation op)
constexpr MTLLoadAction | ToMTLLoadAction (LoadAction action)
constexpr LoadAction | FromMTLLoadAction (MTLLoadAction action)
constexpr MTLStoreAction | ToMTLStoreAction (StoreAction action)
constexpr StoreAction | FromMTLStoreAction (MTLStoreAction action)
constexpr MTLSamplerMinMagFilter | ToMTLSamplerMinMagFilter (MinMagFilter filter)
constexpr MTLSamplerMipFilter | ToMTLSamplerMipFilter (MipFilter filter)
constexpr MTLSamplerAddressMode | ToMTLSamplerAddressMode (SamplerAddressMode mode)
MTLClearColor | ToMTLClearColor (const Color &color)
constexpr MTLTextureType | ToMTLTextureType (TextureType type)
MTLRenderPipelineColorAttachmentDescriptor * | ToMTLRenderPipelineColorAttachmentDescriptor (ColorAttachmentDescriptor descriptor)
MTLDepthStencilDescriptor * | ToMTLDepthStencilDescriptor (std::optional< DepthAttachmentDescriptor > depth, std::optional< StencilAttachmentDescriptor > front, std::optional< StencilAttachmentDescriptor > back)
MTLTextureDescriptor * | ToMTLTextureDescriptor (const TextureDescriptor &desc)
MTLStencilDescriptor * | ToMTLStencilDescriptor (const StencilAttachmentDescriptor &descriptor)
std::shared_future< id< CAMetalDrawable > > | GetDrawableDeferred (CAMetalLayer *layer)
| Create a deferred drawable from a CAMetalLayer. More...
std::shared_ptr< TextureMTL > | CreateTextureFromDrawableFuture (TextureDescriptor desc, const std::shared_future< id< CAMetalDrawable >> &drawble_future)
| Create a TextureMTL from a deferred drawable. More...
static void | GetMTLRenderPipelineDescriptor (const PipelineDescriptor &desc, const Callback &callback)
static MTLComputePipelineDescriptor * | GetMTLComputePipelineDescriptor (const ComputePipelineDescriptor &desc)
static id< MTLDepthStencilState > | CreateDepthStencilDescriptor (const PipelineDescriptor &desc, id< MTLDevice > device)
static bool | ConfigureResolveTextureAttachment (const Attachment &desc, MTLRenderPassAttachmentDescriptor *attachment)
static bool | ConfigureAttachment (const Attachment &desc, MTLRenderPassAttachmentDescriptor *attachment)
static bool | ConfigureColorAttachment (const ColorAttachment &desc, MTLRenderPassColorAttachmentDescriptor *attachment)
static bool | ConfigureDepthAttachment (const DepthAttachment &desc, MTLRenderPassDepthAttachmentDescriptor *attachment)
static bool | ConfigureStencilAttachment (const StencilAttachment &desc, MTLRenderPassStencilAttachmentDescriptor *attachment)
static MTLRenderPassDescriptor * | ToMTLRenderPassDescriptor (const RenderTarget &desc)
static bool | Bind (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< RenderTarget > | WrapTextureWithRenderTarget (Allocator &allocator, id< MTLTexture > texture, bool requires_blit, std::optional< IRect > clip_rect)
std::shared_ptr< Texture > | WrapperMTL (TextureDescriptor desc, const void *mtl_texture, std::function< void()> deletion_proc)
std::shared_ptr< Texture > | WrapTextureMTL (TextureDescriptor desc, const void *mtl_texture, std::function< void()> deletion_proc=nullptr)
static MTLVertexFormat | ReadStageInputFormat (const ShaderStageIOSlot &input)
static constexpr vk::Flags< vk::MemoryPropertyFlagBits > | ToVKBufferMemoryPropertyFlags (StorageMode mode)
static VmaAllocationCreateFlags | ToVmaAllocationBufferCreateFlags (StorageMode mode, 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< YUVConversionVK > | CreateYUVConversion (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< QueueIndexVK > | PickQueue (const vk::PhysicalDevice &device, vk::QueueFlagBits flags)
static std::string | JoinLabels (const VkDebugUtilsLabelEXT *labels, size_t count)
static std::string | JoinVKDebugUtilsObjectNameInfoEXT (const VkDebugUtilsObjectNameInfoEXT *names, size_t count)
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< DeviceBuffer > | CreateDeviceBuffer (const std::shared_ptr< Context > &context, const std::string &label, StorageMode storage_mode=StorageMode::kDevicePrivate)
PipelineFuture< PipelineDescriptor > | CreatePipelineFuture (const Context &context, std::optional< PipelineDescriptor > desc)
PipelineFuture< ComputePipelineDescriptor > | CreatePipelineFuture (const Context &context, std::optional< ComputePipelineDescriptor > desc)
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< ArchiveShaderType > | InferShaderTypefromFileExtension (const std::filesystem::path &path)
constexpr fb::Stage | ToStage (ArchiveShaderType type)
PathBuilder * | CreatePathBuilder ()
void | DestroyPathBuilder (PathBuilder *builder)
void | MoveTo (PathBuilder *builder, Scalar x, Scalar y)
void | LineTo (PathBuilder *builder, Scalar x, Scalar y)
void | CubicTo (PathBuilder *builder, Scalar x1, Scalar y1, Scalar x2, Scalar y2, Scalar x3, Scalar y3)
void | Close (PathBuilder *builder)
struct Vertices * | Tessellate (PathBuilder *builder, int fill_type, Scalar tolerance)
void | DestroyVertices (Vertices *vertices)
static void * | HeapAlloc (void *userData, unsigned int size)
static void * | HeapRealloc (void *userData, void *ptr, unsigned int size)
static void | HeapFree (void *userData, void *ptr)
static int | ToTessWindingRule (FillType fill_type)
void | DestroyTessellator (TESStesselator *tessellator)
static size_t | ComputeQuadrantDivisions (Scalar pixel_radius)
static Font | ToFont (const SkTextBlobRunIterator &run)
static Rect | ToRect (const SkRect &rect)
std::shared_ptr< TextFrame > | MakeTextFrameFromTextBlobSkia (const sk_sp< SkTextBlob > &blob)
static size_t | PairsFitInAtlasOfSize (const std::vector< FontGlyphPair > &pairs, const ISize &atlas_size, std::vector< Rect > &glyph_positions, const std::shared_ptr< RectanglePacker > &rect_packer)
static bool | CanAppendToExistingAtlas (const std::shared_ptr< GlyphAtlas > &atlas, const std::vector< FontGlyphPair > &extra_pairs, std::vector< Rect > &glyph_positions, ISize atlas_size, const std::shared_ptr< RectanglePacker > &rect_packer)
static ISize | OptimumAtlasSizeForFontGlyphPairs (const std::vector< FontGlyphPair > &pairs, std::vector< Rect > &glyph_positions, const std::shared_ptr< GlyphAtlasContext > &atlas_context, GlyphAtlas::Type type, const ISize &max_texture_size)
static void | DrawGlyph (SkCanvas *canvas, const ScaledFont &scaled_font, const Glyph &glyph, const Rect &location, bool has_color)
static bool | UpdateAtlasBitmap (const GlyphAtlas &atlas, const std::shared_ptr< SkBitmap > &bitmap, const std::vector< FontGlyphPair > &new_pairs)
static std::shared_ptr< SkBitmap > | CreateAtlasBitmap (const GlyphAtlas &atlas, const ISize &atlas_size)
static bool | UpdateGlyphTextureAtlas (std::shared_ptr< SkBitmap > bitmap, const std::shared_ptr< Texture > &texture)
static std::shared_ptr< Texture > | UploadGlyphTextureAtlas (const std::shared_ptr< Allocator > &allocator, std::shared_ptr< SkBitmap > bitmap, const ISize &atlas_size, PixelFormat format)
std::shared_ptr< TextFrame > | MakeTextFrameSTB (const std::shared_ptr< TypefaceSTB > &typeface_stb, Font::Metrics metrics, const std::string &text)
static size_t | PairsFitInAtlasOfSize (const std::vector< FontGlyphPair > &pairs, const ISize &atlas_size, std::vector< Rect > &glyph_positions, const std::shared_ptr< RectanglePacker > &rect_packer)
static bool | CanAppendToExistingAtlas (const std::shared_ptr< GlyphAtlas > &atlas, const std::vector< FontGlyphPair > &extra_pairs, std::vector< Rect > &glyph_positions, ISize atlas_size, const std::shared_ptr< RectanglePacker > &rect_packer)
static ISize | OptimumAtlasSizeForFontGlyphPairs (const std::vector< FontGlyphPair > &pairs, std::vector< Rect > &glyph_positions, const std::shared_ptr< GlyphAtlasContext > &atlas_context, GlyphAtlas::Type type, const ISize &max_texture_size)
static void | DrawGlyph (BitmapSTB *bitmap, const ScaledFont &scaled_font, const Glyph &glyph, const Rect &location, bool has_color)
static bool | UpdateAtlasBitmap (const GlyphAtlas &atlas, const std::shared_ptr< BitmapSTB > &bitmap, const std::vector< FontGlyphPair > &new_pairs)
static std::shared_ptr< BitmapSTB > | CreateAtlasBitmap (const GlyphAtlas &atlas, const ISize &atlas_size)
static bool | UpdateGlyphTextureAtlas (std::shared_ptr< BitmapSTB > &bitmap, const std::shared_ptr< Texture > &texture)
static std::shared_ptr< Texture > | UploadGlyphTextureAtlas (const std::shared_ptr< Allocator > &allocator, std::shared_ptr< BitmapSTB > &bitmap, const ISize &atlas_size, PixelFormat format)

## Variables
static const char * | kElementsWindowName = "Elements"
static const char * | kPropertiesWindowName = "Properties"
static const std::initializer_list< std::string > | kSupportedDocuments
static const auto | kPropertiesProcTable
constexpr ColorMatrix | kColorInversion
| A color matrix which inverts colors. More...
static 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 Sampler > | kNullSampler = nullptr
static const std::unique_ptr< const Sampler > | kNullSampler = nullptr
static constexpr const char * | kInstanceLayer = "ImpellerInstance"
static thread_local std::unique_ptr< CommandPoolMap > | tls_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 Sampler > | kNullSampler = 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< GlyphAtlas > | kNullGlyphAtlas = 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

using impeller::BufferResource = typedef Resource<BufferView>

Definition at line 57 of file command.h.

## ◆ Callback

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

Definition at line 26 of file pipeline_library_mtl.mm.

## ◆ CanvasType

using impeller::CanvasType = typedef Canvas

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

Definition at line 20 of file canvas_type.h.

## ◆ ClipPipeline

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

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

using impeller::ColorWriteMask = typedef Mask<ColorWriteMaskBits>

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

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

Definition at line 28 of file pipeline_library.h.

## ◆ ConicalGradientFillPipeline

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

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

using impeller::EllipticalVertexGenerator = typedef Tessellator::EllipticalVertexGenerator

Definition at line 398 of file tessellator.cc.

## ◆ FontGlyphMap

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

Definition at line 29 of file font_glyph_pair.h.

## ◆ FramebufferBlendColorBurnPipeline

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

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

using impeller::GaussianBlurFragmentShader = typedef KernelPipeline::FragmentShader

Definition at line 23 of file gaussian_blur_filter_contents.cc.

## ◆ GaussianBlurPipeline

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

Definition at line 147 of file content_context.h.

## ◆ GaussianBlurVertexShader

using impeller::GaussianBlurVertexShader = typedef KernelPipeline::VertexShader

Definition at line 22 of file gaussian_blur_filter_contents.cc.

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

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

Definition at line 22 of file pipeline_library.h.

## ◆ PipelineProc

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

Definition at line 68 of file blend_filter_contents.cc.

## ◆ Point

using impeller::Point = typedef TPoint<Scalar>

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

using impeller::TessellatedVertexProc = typedef Tessellator::TessellatedVertexProc

Definition at line 397 of file tessellator.cc.

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

using impeller::TextureUsageMask = typedef Mask<TextureUsage>

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

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

Definition at line 42 of file image.h.

## ◆ UniqueEGLImageKHR

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

Definition at line 73 of file image.h.

## ◆ UniqueGLTexture

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

Definition at line 38 of file texture.h.

## ◆ UniqueImageVMA

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

Definition at line 133 of file vma.h.

## ◆ UniquePoolVMA

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

Definition at line 63 of file vma.h.

## ◆ UvComputeShaderPipeline

using impeller::UvComputeShaderPipeline = typedef ComputePipelineBuilder<UvComputeShader>

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

enum impeller::ArchiveRenderingBackend
| strong

Enumerator
kMetal |
kVulkan |
kOpenGLES |

Definition at line 16 of file shader_archive_types.h.

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

## ◆ ArchiveShaderType

enum impeller::ArchiveShaderType
| strong

Enumerator
kVertex |
kFragment |
kCompute |

Definition at line 10 of file shader_archive_types.h.

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

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

179 {
180 kZero,
181 kOne,
182 kSourceColor,
183 kOneMinusSourceColor,
184 kSourceAlpha,
185 kOneMinusSourceAlpha,
186 kDestinationColor,
187 kOneMinusDestinationColor,
188 kDestinationAlpha,
189 kOneMinusDestinationAlpha,
190 kSourceAlphaSaturated,
191 kBlendColor,
192 kOneMinusBlendColor,
193 kBlendAlpha,
194 kOneMinusBlendAlpha,
195 };

## ◆ BlendMode

enum impeller::BlendMode : uint8_t
| strong

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

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

Definition at line 59 of file color.h.

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

## ◆ BlendOperation

enum impeller::BlendOperation
| strong

Enumerator
kAdd |
kSubtract |
kReverseSubtract |

Definition at line 197 of file formats.h.

197 {
198 kAdd,
199 kSubtract,
200 kReverseSubtract,
201 };

## ◆ BlendSelectValues

enum impeller::BlendSelectValues
| strong

Enumerator
kScreen |
kOverlay |
kDarken |
kLighten |
kColorDodge |
kColorBurn |
kHardLight |
kSoftLight |
kDifference |
kExclusion |
kMultiply |
kHue |
kSaturation |
kColor |
kLuminosity |

Definition at line 15 of file framebuffer_blend_contents.h.

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

## ◆ CanvasRecorderOp

enum impeller::CanvasRecorderOp : uint16_t

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

Enumerator
kNew |
kSave |
kSaveLayer |
kRestore |
kRestoreToCount |
kResetTransform |
kTransform |
kConcat |
kPreConcat |
kTranslate |
kScale2 |
kScale3 |
kSkew |
kRotate |
kDrawPath |
kDrawPaint |
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,
24 kRestoreToCount,
25 kResetTransform,
26 kTransform,
27 kConcat,
28 kPreConcat,
29 kTranslate,
30 kScale2,
31 kScale3,
32 kSkew,
33 kRotate,
34 kDrawPath,
35 kDrawPaint,
36 kDrawLine,
37 kDrawRect,
38 kDrawOval,
39 kDrawRRect,
40 kDrawCircle,
41 kDrawPoints,
42 kDrawImage,
43 kDrawImageRect,
44 kClipPath,
45 kClipRect,
46 kClipOval,
47 kClipRRect,
48 kDrawTextFrame,
49 kDrawVertices,
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.
550 kGreaterEqual,
551 };

## ◆ CompressionType

enum impeller::CompressionType
| strong

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

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

Enumerator
kLossless |
kLossy |

Definition at line 18 of file texture_descriptor.h.

18 {
19 kLossless,
20 kLossy,
21 };

## ◆ ContentBoundsPromise

enum impeller::ContentBoundsPromise
| strong

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.
35 kContainsContents,
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.
40 kMayClipContents,
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

enum impeller::DebugResourceType
| strong

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,
225 kRenderBuffer,
226 kFrameBuffer,
227 };

## ◆ DescriptorType

enum impeller::DescriptorType
| strong

Enumerator
kUniformBuffer |
kStorageBuffer |
kSampledImage |
kImage |
kSampler |
kInputAttachment |

Definition at line 153 of file shader_types.h.

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

## ◆ DeviceTypeVK

enum impeller::DeviceTypeVK
| strong

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 ///
41 kIntegratedGPU,
42 //----------------------------------------------------------------------------
43 /// The device is a discrete GPU. Typically desktop GPUs.
44 ///
45 kDiscreteGPU,
46 //----------------------------------------------------------------------------
47 /// The device is a GPU in a virtualized environment.
48 ///
49 kVirtualGPU,
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

enum impeller::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,
27 kRenderBuffer,
28 kFrameBuffer,
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

enum impeller::MinMagFilter
| strong

Enumerator
kNearest | Select nearest to the sample point. Most widely supported.
kLinear | Select two points and linearly interpolate between them. Some formats may not support this.

Definition at line 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 ///
97 kEXTPipelineCreationFeedback,
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 ///
105 kVKKHRPortabilitySubset,
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,
104 kR8G8UNormInt,
105 kR8G8B8A8UNormInt,
106 kR8G8B8A8UNormIntSRGB,
107 kB8G8R8A8UNormInt,
108 kB8G8R8A8UNormIntSRGB,
109 kR32G32B32A32Float,
110 kR16G16B16A16Float,
111 kB10G10R10XR,
112 kB10G10R10XRSRGB,
113 kB10G10R10A10XR,
114 // Depth and stencil formats.
115 kS8UInt,
116 kD24UnormS8Uint,
117 kD32FloatS8UInt,
118 };

## ◆ PlaygroundBackend

enum impeller::PlaygroundBackend
| strong

Enumerator
kMetal |
kOpenGLES |
kVulkan |

Definition at line 29 of file playground.h.

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

## ◆ PointStyle

enum impeller::PointStyle
| strong

Enumerator
kRound | Points are drawn as squares.
kSquare | Points are drawn as circles.

Definition at line 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].
364 kTriangleStrip,
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

enum impeller::RequiredAndroidDeviceExtensionVK : uint32_t
| strong

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 ///
51 kANDROIDExternalMemoryAndroidHardwareBuffer,
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 ///
58 kKHRSamplerYcbcrConversion,
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 ///
65 kKHRExternalMemory,
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 ///
72 kEXTQueueFamilyForeign,
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 ///
79 kKHRDedicatedAllocation,
80
81 kLast,
82 };

## ◆ RequiredCommonDeviceExtensionVK

enum impeller::RequiredCommonDeviceExtensionVK : uint32_t
| strong

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 ///
32 kKHRSwapchain,
33
34 kLast,
35 };

## ◆ RuntimeShaderStage

enum impeller::RuntimeShaderStage
| strong

Enumerator
kVertex |
kFragment |
kCompute |

Definition at line 28 of file runtime_types.h.

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

## ◆ RuntimeStageBackend

enum impeller::RuntimeStageBackend
| strong

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

enum impeller::RuntimeUniformType

Enumerator
kFloat |
kSampledImage |
kStruct |

Definition at line 22 of file runtime_types.h.

22 {
23 kFloat,
24 kSampledImage,
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

enum impeller::SamplerAddressMode
| strong

Enumerator
kClampToEdge |
kRepeat |
kMirror |
kDecal | decal sampling mode is only supported on devices that pass the `Capabilities.SupportsDecalSamplerAddressMode` check.

Definition at line 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,
45 kSignedByte,
46 kUnsignedByte,
47 kSignedShort,
48 kUnsignedShort,
49 kSignedInt,
50 kUnsignedInt,
51 kSignedInt64,
52 kUnsignedInt64,
53 kAtomicCounter,
54 kHalfFloat,
55 kFloat,
56 kDouble,
57 kStruct,
58 kImage,
59 kSampledImage,
60 kSampler,
61 };

## ◆ SourceRectConstraint

enum impeller::SourceRectConstraint
| strong

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.
559 kSetToReferenceValue,
560 /// Increment the current stencil value by 1. Clamp it to the maximum.
561 kIncrementClamp,
562 /// Decrement the current stencil value by 1. Clamp it to zero.
563 kDecrementClamp,
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.
567 kIncrementWrap,
568 /// Decrement the current stencil value by 1. If at zero, set to maximum.
569 kDecrementWrap,
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 ///
38 kHostVisible,
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 ///
45 kDevicePrivate,
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 ///
58 kDeviceTransient,
59 };

## ◆ StoreAction

enum impeller::StoreAction
| strong

Enumerator
kDontCare |
kStore |
kMultisampleResolve |
kStoreAndMultisampleResolve |

Definition at line 209 of file formats.h.

209 {
210 kDontCare,
211 kStore,
212 kMultisampleResolve,
213 kStoreAndMultisampleResolve,
214 };

## ◆ TextureCoordinateSystem

enum impeller::TextureCoordinateSystem
| strong

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.
332 kUploadFromHost,
333 // Default coordinate system.
334 // (0, 0) is the top-left of the image with +Y going down.
335 kRenderToTexture,
336 };

## ◆ TextureType

enum impeller::TextureType
| strong

Enumerator
kTexture2D |
kTexture2DMultisample |
kTextureCube |
kTextureExternalOES |

Definition at line 263 of file formats.h.

263 {
264 kTexture2D,
265 kTexture2DMultisample,
266 kTextureCube,
267 kTextureExternalOES,
268 };

## ◆ TextureUsage

enum impeller::TextureUsage
| strong

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

enum impeller::WindingOrder
| strong

Enumerator
kClockwise |
kCounterClockwise |

Definition at line 23 of file formats.h.

23 {
24 kClockwise,
25 kCounterClockwise,
26 };

## ◆ YUVColorSpace

enum impeller::YUVColorSpace
| strong

Enumerator
kBT601LimitedRange |
kBT601FullRange |

Definition at line 55 of file color.h.

55 { kBT601LimitedRange, kBT601FullRange };

## Function Documentation

## ◆ _FOR_EACH_CAPTURE_PROPERTY() [1/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY | ( | _CAPTURE_PROPERTY_CAST_DEFINITION |  | ) |

## ◆ _FOR_EACH_CAPTURE_PROPERTY() [2/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY | ( | _CAPTURE_PROPERTY_DECLARATION |  | ) |

## ◆ _FOR_EACH_CAPTURE_PROPERTY() [3/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY | ( | _CAPTURE_PROPERTY_DEFINITION |  | ) |

## ◆ Absolute()

template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>

constexpr T impeller::Absolute | ( | const T & | val | ) |
| constexpr

Definition at line 21 of file scalar.h.

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

Referenced by ScalarNearlyZero().

## ◆ 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
| ) |  |
| inline static constexpr

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=("
108 << TextureDescriptorToString(
109 attachment.texture->GetTextureDescriptor())
110 << "),";
111 }
112 if (attachment.resolve_texture) {
113 stream << "ResolveTexture=("
114 << TextureDescriptorToString(
115 attachment.resolve_texture->GetTextureDescriptor())
116 << "),";
117 }
118 stream << "LoadAction=" << LoadActionToString(attachment.load_action) << ",";
119 stream << "StoreAction=" << StoreActionToString(attachment.store_action);
120 return stream.str();
121 }

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

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

## ◆ AttachmentTypeString()

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

Definition at line 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
223 VALIDATION_LOG
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 | ) |
| inline static constexpr

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
| ) |  |
| inline static constexpr

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_rect | The rectangle to be rendered.
  texture_bounds | The local space bounding box of the geometry.
  effect_transform | The transform to apply to the UV coordinates.
  renderer | The content context to use for allocating buffers.
  entity | The entity to use for the transform.
  pass | The 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 &&
297 !DISABLE_COLOR_FONT_SUPPORT) {
298 bytes_per_pixel = kColorFontBitsPerPixel;
299 }
300 auto bitmap = std::make_shared<BitmapSTB>(atlas_size.width, atlas_size.height,
301 bytes_per_pixel);
302
303 bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
304
305 atlas.IterateGlyphs([&bitmap, has_color](const ScaledFont& scaled_font,
306 const Glyph& glyph,
307 const Rect& location) -> bool {
308 DrawGlyph(bitmap.get(), scaled_font, glyph, location, has_color);
309 return true;
310 });
311
312 return bitmap;
313 }

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

## ◆ 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;
26 texture_descriptor.storage_mode = impeller::StorageMode::kHostVisible;
27 texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
28 texture_descriptor.size = {gradient_data.texture_size, 1};
29 auto texture =
30 context->GetResourceAllocator()->CreateTexture(texture_descriptor);
31 if (!texture) {
32 FML_DLOG(ERROR) << "Could not create Impeller texture.";
33 return nullptr;
34 }
35
36 auto mapping = std::make_shared<fml::DataMapping>(gradient_data.color_bytes);
37 if (!texture->SetContents(mapping)) {
38 FML_DLOG(ERROR) << "Could not copy contents into Impeller texture.";
39 return nullptr;
40 }
41 texture->SetLabel(impeller::SPrintF("Gradient(%p)", texture.get()).c_str());
42 return texture;
43 }

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

## ◆ CreateMappingFromAllocation()

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

Definition at line 99 of file allocation.cc.

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

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

## ◆ CreateMappingWithCopy()

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

Definition at line 83 of file allocation.cc.

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

References CreateMappingFromAllocation().

## ◆ CreateMappingWithString() [1/2]

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

## ◆ CreateMappingWithString() [2/2]

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

Definition at line 111 of file allocation.cc.

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

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

## ◆ CreateMetalCommandQueue()

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

Definition at line 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=*/
347 kDefaultStencilConfig);
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
| ) |  |
| inline static

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
| ) |  |
| inline static

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
| ) |  |
| inline static constexpr

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
| ) |  |
| inline static constexpr

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) {
274 VALIDATION_LOG
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
| ) |  |
| inline static constexpr

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] =
47 ToMTLRenderPipelineColorAttachmentDescriptor(item.second);
48 }
49
50 descriptor.depthAttachmentPixelFormat =
51 ToMTLPixelFormat(desc.GetDepthPixelFormat());
52 descriptor.stencilAttachmentPixelFormat =
53 ToMTLPixelFormat(desc.GetStencilPixelFormat());
54
55 const auto& constants = desc.GetSpecializationConstants();
56 for (const auto& entry : desc.GetStageEntrypoints()) {
57 if (entry.first == ShaderStage::kVertex) {
58 descriptor.vertexFunction =
59 ShaderFunctionMTL::Cast(*entry.second).GetMTLFunction();
60 }
61 if (entry.first == ShaderStage::kFragment) {
62 if (constants.empty()) {
63 descriptor.fragmentFunction =
64 ShaderFunctionMTL::Cast(*entry.second).GetMTLFunction();
65 } else {
66 // This code only expects a single specialized function per pipeline.
67 FML_CHECK(!created_specialized_function);
68 created_specialized_function = true;
69 ShaderFunctionMTL::Cast(*entry.second)
70 .GetMTLFunctionSpecialized(
71 constants, [callback, descriptor](id<MTLFunction> function) {
72 descriptor.fragmentFunction = function;
73 callback(descriptor);
74 });
75 }
76 }
77 }
78
79 if (!created_specialized_function) {
80 callback(descriptor);
81 }
82 }

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

## ◆ GetQueueCreateInfos()

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

Definition at line 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:
47 return ShaderType::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()

bool impeller::HasValidationLayers | ( |  | ) |

Definition at line 48 of file context_vk.cc.

48 {
49 return gHasValidationLayers;
50 }

References gHasValidationLayers.

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

## ◆ HeapAlloc()

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

Definition at line 11 of file tessellator.cc.

11 {
12 return malloc(size);
13 }

## ◆ HeapFree()

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

Definition at line 19 of file tessellator.cc.

19 {
20 free(ptr);
21 }

## ◆ HeapRealloc()

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

Definition at line 15 of file tessellator.cc.

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

## ◆ 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 {
64 return sValidationLogsAreFatal;
65 }

References sValidationLogsAreFatal.

Referenced by TEST().

## ◆ ImpellerValidationErrorsSetFatal()

void impeller::ImpellerValidationErrorsSetFatal | ( | bool | fatal | ) |

Definition at line 16 of file validation.cc.

16 {
17 sValidationLogsAreFatal = fatal;
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] | buffer | The buffer
  [in] | image | The 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, //
180 kSelfDependencyDstStageMask, //
181 kSelfDependencyFlags, //
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
| ) |  |
| inline static

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: "
82 << MTLCommandBufferErrorToString(
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 | ) |
| inline static constexpr

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
| ) |  |
| inline static constexpr

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
| ) |  |
| inline static

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 | ) |
| inline static

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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* | ( | T | value,
|  | const Color & | c
| ) |  |
| inline constexpr

Definition at line 901 of file color.h.

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

## ◆ operator*() [5/7]

template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

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

Definition at line 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* | ( | U | s,
|  | const TSize< T > & | p
| ) |  |
| constexpr

Definition at line 128 of file size.h.

128 {
129 return p * s;
130 }

## ◆ operator*() [7/7]

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

constexpr Vector3 impeller::operator* | ( | U | s,
|  | const Vector3 & | p
| ) |  |
| constexpr

Definition at line 209 of file vector.h.

209 {
210 return p * s;
211 }

## ◆ operator+() [1/5]

template<class F , class I , class = MixedOp<F, I>>

constexpr TPoint<F> impeller::operator+ | ( | const TPoint< F > & | p1,
|  | const TPoint< I > & | p2
| ) |  |
| constexpr

Definition at line 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+ | ( | T | value,
|  | const Color & | c
| ) |  |
| inline constexpr

Definition at line 890 of file color.h.

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

## ◆ operator+() [5/5]

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

constexpr Vector3 impeller::operator+ | ( | U | s,
|  | const Vector3 & | p
| ) |  |
| constexpr

Definition at line 214 of file vector.h.

214 {
215 return p + s;
216 }

## ◆ operator-() [1/5]

template<class F , class I , class = MixedOp<F, I>>

constexpr TPoint<F> impeller::operator- | ( | const TPoint< F > & | p1,
|  | const TPoint< I > & | p2
| ) |  |
| constexpr

Definition at line 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- | ( | T | value,
|  | const Color & | c
| ) |  |
| inline constexpr

Definition at line 895 of file color.h.

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

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

## ◆ operator-() [5/5]

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

constexpr Vector3 impeller::operator- | ( | U | s,
|  | const Vector3 & | p
| ) |  |
| constexpr

Definition at line 219 of file vector.h.

219 {
220 return -p + s;
221 }

## ◆ operator/() [1/7]

template<class F , class I , class = MixedOp<F, I>>

constexpr TPoint<F> impeller::operator/ | ( | const TPoint< F > & | p1,
|  | const TPoint< I > & | p2
| ) |  |
| constexpr

Definition at line 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/ | ( | T | value,
|  | const Color & | c
| ) |  |
| inline constexpr

Definition at line 906 of file color.h.

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

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

## ◆ operator/() [5/7]

template<class T , class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

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

Definition at line 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/ | ( | U | 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/ | ( | U | s,
|  | const Vector3 & | p
| ) |  |
| constexpr

Definition at line 224 of file vector.h.

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

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

## ◆ 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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| ) |  |
| inline constexpr

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 | ) |
| inline constexpr

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

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

Definition at line 37 of file contents.cc.

38 {
39 ContentContextOptions opts = OptionsFromPass(pass);
40 opts.blend_mode = entity.GetBlendMode();
41 return opts;
42 }

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

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

## ◆ PairsFitInAtlasOfSize() [1/2]

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

Definition at line 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 | ) |
| inline constexpr

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)) {
172 gShouldOpenNewPlaygrounds = false;
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
| ) |  |
| inline static

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
| ) |  |
| inline static

Definition at line 25 of file path_component.cc.

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

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

## ◆ ReadStageInputFormat()

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

Definition at line 16 of file vertex_descriptor_mtl.mm.

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

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

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

## ◆ RealizedFuture()

template<class T >

std::future<T> impeller::RealizedFuture | ( | T | t | ) |

Definition at line 13 of file promise.h.

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

## ◆ 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) {
113 ReportPipelineCreationFeedbackToTrace(desc, feedback);
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() << "' ";
63 ReportPipelineCreationFeedbackToLog(stream,
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 << ": ";
71 ReportPipelineCreationFeedbackToLog(
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 | ) |
| inline static constexpr

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`
| ) |  |
| inline constexpr

Definition at line 30 of file scalar.h.

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

References ScalarNearlyZero().

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

## ◆ ScalarNearlyZero()

constexpr bool impeller::ScalarNearlyZero | ( | Scalar | x,
|  | Scalar | tolerance = `kEhCloseEnough`
| ) |  |
| inline constexpr

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 | ) |
| inline constexpr

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
| ) |  |
| inline static constexpr

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
| ) |  |
| inline static constexpr

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_swiftshader | If 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) {
59 FindSwiftShaderICDAtKnownPaths();
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) {
61 return IMPELLER_GL_CLAMP_TO_BORDER;
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:
525 VALIDATION_LOG
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;
103 case flutter::DlBlendMode::kColor:
104 return BlendMode::kColor;
105 case flutter::DlBlendMode::kLuminosity:
106 return BlendMode::kLuminosity;
107 }
108 FML_UNREACHABLE();
109 }

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

Referenced by impeller::DlDispatcher::drawAtlas(), impeller::DlDispatcher::drawColor(), impeller::DlDispatcher::drawVertices(), impeller::DlDispatcher::setBlendMode(), and ToColorFilter().

## ◆ ToBlendOperation()

constexpr GLenum impeller::ToBlendOperation | ( | BlendOperation | op | ) |
| constexpr

Definition at line 127 of file formats_gles.h.

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

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ConfigureBlending().

## ◆ ToBlurStyle()

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

Definition at line 492 of file dl_dispatcher.cc.

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

References impeller::FilterContents::kInner, impeller::FilterContents::kNormal, impeller::FilterContents::kOuter, and impeller::FilterContents::kSolid.

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

## ◆ ToClipOperation()

static Entity::ClipOperation impeller::ToClipOperation | ( | flutter::DlCanvas::ClipOp | clip_op | ) |
| static

Definition at line 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) {
264 case flutter::DlColorSourceType::kColor:
265 return ColorSource::Type::kColor;
266 case flutter::DlColorSourceType::kImage:
267 return ColorSource::Type::kImage;
268 case flutter::DlColorSourceType::kLinearGradient:
269 return ColorSource::Type::kLinearGradient;
270 case flutter::DlColorSourceType::kRadialGradient:
271 return ColorSource::Type::kRadialGradient;
272 case flutter::DlColorSourceType::kConicalGradient:
273 return ColorSource::Type::kConicalGradient;
274 case flutter::DlColorSourceType::kSweepGradient:
275 return ColorSource::Type::kSweepGradient;
276 case flutter::DlColorSourceType::kRuntimeEffect:
277 return ColorSource::Type::kRuntimeEffect;
278 #ifdef IMPELLER_ENABLE_3D
279 case flutter::DlColorSourceType::kScene:
280 return ColorSource::Type::kScene;
281 #endif // IMPELLER_ENABLE_3D
282 }
283 }

References impeller::ColorSource::kColor, kColor, impeller::ColorSource::kConicalGradient, impeller::ColorSource::kImage, impeller::ColorSource::kLinearGradient, impeller::ColorSource::kRadialGradient, impeller::ColorSource::kRuntimeEffect, impeller::ColorSource::kScene, and impeller::ColorSource::kSweepGradient.

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

## ◆ 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:
102 return SafeMTLPixelFormatDepth24Unorm_Stencil8();
103 case PixelFormat::kD32FloatS8UInt:
104 return MTLPixelFormatDepth32Float_Stencil8;
105 case PixelFormat::kB10G10R10XRSRGB:
106 return SafeMTLPixelFormatBGR10_XR_sRGB();
107 case PixelFormat::kB10G10R10XR:
108 return SafeMTLPixelFormatBGR10_XR();
109 case PixelFormat::kB10G10R10A10XR:
110 return SafeMTLPixelFormatBGRA10_XR();
111 }
112 return MTLPixelFormatInvalid;
113 };

References kA8UNormInt, kB10G10R10A10XR, kB10G10R10XR, kB10G10R10XRSRGB, kB8G8R8A8UNormInt, kB8G8R8A8UNormIntSRGB, kD24UnormS8Uint, kD32FloatS8UInt, kR16G16B16A16Float, kR32G32B32A32Float, kR8G8B8A8UNormInt, kR8G8B8A8UNormIntSRGB, kR8G8UNormInt, kR8UNormInt, kS8UInt, kUnknown, SafeMTLPixelFormatBGR10_XR(), SafeMTLPixelFormatBGR10_XR_sRGB(), SafeMTLPixelFormatBGRA10_XR(), and SafeMTLPixelFormatDepth24Unorm_Stencil8().

Referenced by GetMTLRenderPipelineDescriptor(), impeller::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:
382 VALIDATION_LOG
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 | ) |
| inline static constexpr

Definition at line 188 of file color.cc.

188 {
189 return {color.red, color.green, color.blue};
190 }

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

Referenced by DoColorBlend().

## ◆ ToSamplerDescriptor() [1/2]

static impeller::SamplerDescriptor impeller::ToSamplerDescriptor | ( | const flutter::DlFilterMode | options | ) |
| static

Definition at line 148 of file dl_dispatcher.cc.

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

References kLinear, kNearest, impeller::SamplerDescriptor::label, impeller::SamplerDescriptor::mag_filter, and impeller::SamplerDescriptor::min_filter.

## ◆ ToSamplerDescriptor() [2/2]

static impeller::SamplerDescriptor impeller::ToSamplerDescriptor | ( | const flutter::DlImageSampling | options | ) |
| static

Definition at line 124 of file dl_dispatcher.cc.

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

References kLinear, kNearest, impeller::SamplerDescriptor::label, impeller::SamplerDescriptor::mag_filter, impeller::SamplerDescriptor::min_filter, and impeller::SamplerDescriptor::mip_filter.

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

## ◆ ToShaderStage() [1/4]

static ShaderStage impeller::ToShaderStage | ( | ArchiveShaderType | type | ) |
| static

Definition at line 18 of file shader_library_gles.cc.

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

References kCompute, kFragment, and kVertex.

## ◆ ToShaderStage() [2/4]

static ShaderStage impeller::ToShaderStage | ( | ArchiveShaderType | type | ) |
| static

Definition at line 18 of file shader_library_vk.cc.

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

References kCompute, kFragment, and kVertex.

## ◆ ToShaderStage() [3/4]

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

Definition at line 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:
189 UNIMPLEMENTED;
190 break;
191 }
192 return Paint::Style::kFill;
193 }

References impeller::Paint::kFill, impeller::Paint::kStroke, and UNIMPLEMENTED.

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

## ◆ ToTarget()

static GLenum impeller::ToTarget | ( | DeviceBufferGLES::BindingType | type | ) |
| static

Definition at line 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) {
20 case fb::UniformDataType::kFloat:
21 return RuntimeUniformType::kFloat;
22 case fb::UniformDataType::kSampledImage:
23 return RuntimeUniformType::kSampledImage;
24 case fb::UniformDataType::kStruct:
25 return RuntimeUniformType::kStruct;
26 }
27 FML_UNREACHABLE();
28 }

References kFloat, kSampledImage, and kStruct.

Referenced by impeller::RuntimeStage::RuntimeStage().

## ◆ ToVector()

constexpr Vector4 impeller::ToVector | ( | Color | color | ) |
| inline constexpr

Definition at line 185 of file shader_types.h.

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

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

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

## ◆ ToVertexAttribType()

constexpr std::optional<GLenum> impeller::ToVertexAttribType | ( | ShaderType | type | ) |
| constexpr

Definition at line 139 of file formats_gles.h.

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

References kAtomicCounter, kBoolean, kDouble, kFloat, kHalfFloat, kImage, kSampledImage, kSampler, kSignedByte, kSignedInt, kSignedInt64, kSignedShort, kStruct, kUnknown, kUnsignedByte, kUnsignedInt, kUnsignedInt64, kUnsignedShort, and kVoid.

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

## ◆ ToVertexDescriptorFormat()

vk::Format impeller::ToVertexDescriptorFormat | ( | const ShaderStageIOSlot & | input | ) |

Definition at line 11 of file vertex_descriptor_vk.cc.

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

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

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 | ) |
| static constexpr

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) {
269 case DescriptorType::kSampledImage:
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:
553 VALIDATION_LOG
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:
539 VALIDATION_LOG
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
| ) |  |
| static constexpr

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

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 | ( |  | ) |
| inline static constexpr

Definition at line 28 of file color.cc.

28 {
29 std::underlying_type_t<BlendMode> i = 0;
30 // Ensure the order of the blend modes match.
31 IMPELLER_FOR_EACH_BLEND_MODE(_IMPELLER_ASSERT_BLEND_MODE)
32 // Ensure the total number of blend modes match.
33 if (i - 1 !=
34 static_cast<std::underlying_type_t<BlendMode>>(BlendMode::kLast)) {
35 return false;
36 }
37 return true;
38 }

References _IMPELLER_ASSERT_BLEND_MODE, IMPELLER_FOR_EACH_BLEND_MODE, and kLast.

## ◆ VerifyExistingCache()

static bool impeller::VerifyExistingCache | ( | const fml::Mapping & | mapping,
|  | const CapabilitiesVK & | caps
| ) |  |
| static

Definition at line 19 of file pipeline_cache_vk.cc.

20 {
21 return true;
22 }

Referenced by OpenCacheFile().

## ◆ VKClearValueFromColor()

static vk::ClearColorValue impeller::VKClearValueFromColor | ( | Color | color | ) |
| static

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

Definition at line 174 of file command_pool_vk.cc.

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

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

Definition at line 159 of file playground.cc.

Referenced by PlaygroundKeyCallback(), and impeller::Playground::ShouldOpenNewPlaygrounds().

## ◆ k1OverPi

constexpr float impeller::k1OverPi = 0.31830988618379067154f
| constexpr

Definition at line 38 of file constants.h.

## ◆ k1OverSqrt2

constexpr float impeller::k1OverSqrt2 = 0.70710678118654752440f
| constexpr

Definition at line 50 of file constants.h.

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

## ◆ k2OverPi

constexpr float impeller::k2OverPi = 0.63661977236758134308f
| constexpr

Definition at line 41 of file constants.h.

## ◆ k2OverSqrtPi

constexpr float impeller::k2OverSqrtPi = 1.12837916709551257390f
| constexpr

Definition at line 44 of file constants.h.

## ◆ k2Pi

constexpr float impeller::k2Pi = 6.28318530717958647693f
| constexpr

Definition at line 29 of file constants.h.

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

## ◆ kAlloc

const TESSalloc impeller::kAlloc
| static

Initial value:
= {
HeapAlloc, HeapRealloc, HeapFree, 0,
16,
16,
16,
16,
16,
0
}

Definition at line 24 of file tessellator.cc.

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

## ◆ kAllocatorBlockSize

constexpr size_t impeller::kAllocatorBlockSize = 1024000
| constexpr

Definition at line 18 of file host_buffer.cc.

## ◆ kAngleInputAttachmentPrefix

constexpr std::string_view impeller::kAngleInputAttachmentPrefix
| static constexpr

Initial value:
=
"ANGLEInputAttachment"

Definition at line 21 of file buffer_bindings_gles.cc.

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

## ◆ kBlendModeNames

constexpr const char* impeller::kBlendModeNames[]
| static constexpr

Initial value:
= {
IMPELLER_FOR_EACH_BLEND_MODE(_IMPELLER_BLEND_MODE_NAME_LIST)}

Definition at line 44 of file color.cc.

Referenced by BlendModeToString().

## ◆ kColorInversion

constexpr ColorMatrix impeller::kColorInversion
| constexpr

Initial value:
= {
.array = {
-1.0, 0, 0, 1.0, 0,
0, -1.0, 0, 1.0, 0,
0, 0, -1.0, 1.0, 0,
1.0, 1.0, 1.0, 1.0, 0
}
}

A color matrix which inverts colors.

Definition at line 20 of file paint.cc.

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

## ◆ kDefaultBindingSize

const constexpr DescriptorPoolSize impeller::kDefaultBindingSize
| static constexpr

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
| static constexpr

Definition at line 27 of file path_component.h.

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

## ◆ kDefaultStencilConfig

const constexpr RenderTarget::AttachmentConfig impeller::kDefaultStencilConfig
| static constexpr

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

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

Definition at line 56 of file constants.h.

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

## ◆ kElementsWindowName

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

Definition at line 17 of file aiks_playground_inspector.cc.

## ◆ kEmptyResult

const GeometryResult impeller::kEmptyResult
| static

Initial value:
= {
.vertex_buffer =
{
.index_type = IndexType::kNone,
},
}

Definition at line 42 of file geometry.h.

## ◆ kFramebufferFetchExt

const constexpr char* impeller::kFramebufferFetchExt
| static constexpr

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
| static constexpr

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"
| static constexpr

Definition at line 15 of file capabilities_vk.cc.

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

## ◆ kKernelRadiusPerSigma

constexpr static float impeller::kKernelRadiusPerSigma = 1.73205080757
| static constexpr

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
| static constexpr

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
| static constexpr

Definition at line 26 of file pipeline_vk.h.

## ◆ kMaxFramesInFlight

constexpr size_t impeller::kMaxFramesInFlight = 3u
| static constexpr

Definition at line 22 of file khr_swapchain_impl_vk.cc.

## ◆ kMultisampledRenderToTextureExt

const constexpr char* impeller::kMultisampledRenderToTextureExt
| static constexpr

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
| static constexpr

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

Definition at line 30 of file typographer_context_skia.cc.

Referenced by CanAppendToExistingAtlas(), DrawGlyph(), and PairsFitInAtlasOfSize().

## ◆ kPhi

constexpr float impeller::kPhi = 1.61803398874989484820f
| constexpr

Definition at line 53 of file constants.h.

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

## ◆ kPi

constexpr float impeller::kPi = 3.14159265358979323846f
| constexpr

Definition at line 26 of file constants.h.

Referenced by impeller::testing::MaskBlurVariantTest(), impeller::Degrees::operator Radians(), impeller::testing::TEST(), and impeller::testing::TEST_P().

## ◆ kPiOver2

constexpr float impeller::kPiOver2 = 1.57079632679489661923f
| constexpr

Definition at line 32 of file constants.h.

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

## ◆ kPiOver4

constexpr float impeller::kPiOver4 = 0.78539816339744830962f
| constexpr

Definition at line 35 of file constants.h.

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

## ◆ kPipelineCacheFileName

constexpr const char* impeller::kPipelineCacheFileName
| static constexpr

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
| static constexpr

Definition at line 27 of file khr_swapchain_impl_vk.cc.

## ◆ kPoolSize

constexpr uint32_t impeller::kPoolSize = 128u
| static constexpr

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
| static constexpr

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
| static constexpr

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

Definition at line 23 of file render_pass_builder_vk.cc.

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

## ◆ 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
| static constexpr

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
| static constexpr

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

std::atomic_int32_t impeller::sValidationLogsAreFatal = 0
| static

Definition at line 14 of file validation.cc.

Referenced by ImpellerValidationBreak(), ImpellerValidationErrorsAreFatal(), ImpellerValidationErrorsSetFatal(), impeller::ScopedValidationFatal::ScopedValidationFatal(), and impeller::ScopedValidationFatal::~ScopedValidationFatal().

## ◆ sValidationLogsDisabledCount

std::atomic_int32_t impeller::sValidationLogsDisabledCount = 0
| static

Definition at line 13 of file validation.cc.

Referenced by impeller::ScopedValidationDisable::ScopedValidationDisable(), impeller::ScopedValidationDisable::~ScopedValidationDisable(), and impeller::ValidationLog::~ValidationLog().

## ◆ tess

Tessellator impeller::tess
| static

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

Definition at line 170 of file command_pool_vk.cc.

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

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