impeller Namespace Reference

Namespaces
	allocation_size_literals
	android
	compiler
	egl
	glvk
	interop
	saturated
	skia_conversions
	testing

Classes
class	Allocation
	Describes an allocation on the heap. More...
class	AllocationSize
	Represents the size of an allocation in different units. More...
class	BackendCast
struct	UniqueID
class	ComparableBase
class	Comparable
struct	ComparableHash
struct	ComparableEqual
struct	Flags
struct	MaskTraits
struct	Mask
	A mask of typed enums. More...
class	NoExceptionPromise
class	Lock
class	ReaderLock
class	WriterLock
class	ConditionVariable
	A condition variable exactly similar to the one in libcxx with two major differences: More...
class	ValidationLog
struct	ScopedValidationDisable
struct	ScopedValidationFatal
struct	Version
class	Allocator
	An object that allocates device memory. More...
struct	BufferView
class	DeviceBuffer
struct	DeviceBufferDescriptor
struct	DepthRange
struct	Viewport
struct	ColorAttachmentDescriptor
	Describe the color attachment that will be used with this pipeline. More...
struct	DepthAttachmentDescriptor
struct	StencilAttachmentDescriptor
struct	Attachment
struct	ColorAttachment
struct	DepthAttachment
struct	StencilAttachment
class	HostBuffer
class	IdleWaiter
struct	Range
class	raw_ptr
	A wrapper around a raw ptr that adds additional unopt mode only checks. More...
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...
struct	RuntimeUniformDimensions
struct	RuntimeUniformDescription
class	Sampler
struct	SamplerDescriptor
struct	ShaderStructMemberMetadata
struct	ShaderMetadata
struct	ShaderUniformSlot
	Metadata required to bind a buffer. More...
struct	SampledImageSlot
	Metadata required to bind a combined texture and sampler. More...
struct	ShaderStageIOSlot
struct	ShaderStageBufferLayout
struct	DescriptorSetLayout
struct	Padding
struct	Padded
	Struct used for padding uniform buffer array elements. More...
class	Texture
struct	TextureDescriptor
	A lightweight object that describes the attributes of a texture that can then used an allocator to create that texture. More...
struct	VertexBuffer
class	AiksContext
class	AiksPlayground
struct	BackdropData
struct	CanvasStackEntry
struct	LazyRenderingConfig
class	Canvas
class	DlAtlasGeometry
	A wrapper around data provided by a drawAtlas call. More...
class	DlDispatcherBase
class	CanvasDlDispatcher
class	FirstPassDispatcher
class	DlImageImpeller
class	DlPlayground
class	DlVerticesGeometry
	A geometry that is created from a DlVertices object. More...
class	NinePatchConverter
struct	Paint
class	AnonymousContents
class	AtlasGeometry
class	DrawImageRectAtlasGeometry
	An atlas geometry that adapts for drawImageRect. More...
class	AtlasContents
class	ColorFilterAtlasContents
struct	ClipCoverage
class	ClipContents
class	ColorSourceContents
class	ConicalGradientContents
struct	ContentContextOptions
class	ContentContext
class	Contents
class	BlendFilterContents
class	BorderMaskBlurFilterContents
class	ColorFilterContents
class	ColorMatrixFilterContents
class	FilterContents
struct	BlurParameters
struct	KernelSample
struct	KernelSamples
class	GaussianBlurFilterContents
class	ContentsFilterInput
class	FilterContentsFilterInput
class	FilterInput
class	PlaceholderFilterInput
class	TextureFilterInput
class	LinearToSrgbFilterContents
class	LocalMatrixFilterContents
class	MatrixFilterContents
class	DirectionalMorphologyFilterContents
class	RuntimeEffectFilterContents
	A filter that applies a runtime effect shader. More...
class	SrgbToLinearFilterContents
class	YUVToRGBFilterContents
class	FramebufferBlendContents
struct	StopData
class	LineContents
class	LinearGradientContents
class	RadialGradientContents
class	RuntimeEffectContents
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	SolidRRectLikeBlurContents
	A base class for SolidRRectBlurContents and SolidRSuperellipseBlurContents. More...
class	SolidRSuperellipseBlurContents
	Draws a fast solid color blur of an rounded superellipse. Only supports RSuperellipses with fully symmetrical radii. Also produces correct results for rectangles (corner_radius=0) and circles (corner_radius=width/2=height/2). More...
class	SweepGradientContents
class	TextContents
class	TextShadowCache
	A cache for blurred text that re-uses these across frames. More...
class	TextureContents
class	TiledTextureContents
class	VerticesSimpleBlendContents
class	DrawOrderResolver
class	Entity
struct	ClipCoverageLayer
class	EntityPassClipStack
	A class that tracks all clips that have been recorded in the current entity pass stencil. More...
class	EntityPassTarget
class	EntityPlayground
class	ArcGeometry
class	CircleGeometry
class	CoverGeometry
	A geometry that implements "drawPaint" like behavior by covering the entire render pass area. More...
class	EllipseGeometry
	A Geometry class that can directly generate vertices (with or without texture coordinates) for filled ellipses. More...
class	StrokeEllipseGeometry
	A Geometry class that produces fillable vertices representing the stroked outline of an ellipse with the given bounds. More...
class	FillPathSourceGeometry
	An abstract Geometry base class that produces fillable vertices for the interior of any |PathSource| provided by the type-specific subclass. More...
class	FillPathGeometry
	A Geometry that produces fillable vertices from a |DlPath| object using the |FillPathSourceGeometry| base class and the inherent ability for a |DlPath| object to perform path iteration. More...
class	FillDiffRoundRectGeometry
	A Geometry that produces fillable vertices for the gap between a pair of |RoundRect| objects using the |FillPathSourceGeometry| base class. More...
struct	GeometryResult
class	Geometry
class	ImpellerEntityUnitTestAccessor
class	LineGeometry
class	PointFieldGeometry
	A geometry class specialized for Canvas::DrawPoints. More...
class	FillRectGeometry
class	StrokeRectGeometry
class	RoundRectGeometry
	A Geometry class that generates fillable vertices (with or without texture coordinates) directly from a round rect object with uniform radii at every corner. More...
class	FillRoundRectGeometry
	A Geometry class that produces fillable vertices from any |RoundRect| object regardless of radii uniformity. More...
class	StrokeRoundRectGeometry
	A Geometry class that produces fillable vertices representing the stroked outline of any |Roundrect| object regardless of radii uniformity. More...
class	RoundSuperellipseGeometry
	A Geometry class that generates fillable vertices (with or without texture coordinates) directly from a round superellipse object regardless of radii uniformity. More...
class	StrokeRoundSuperellipseGeometry
	A Geometry class that produces fillable vertices representing the stroked outline of any |RoundSuperellipse| object regardless of radii uniformity. More...
class	StrokePathSegmentReceiver
class	PathAndArcSegmentReceiver
	A |SegmentReceiver| that also accepts Arc segments for optimal handling. A path or |PathSource| will typically represent such curves using Conic segments which are harder to iterate. More...
class	StrokeSegmentsGeometry
	An abstract Geometry base class that produces fillable vertices representing the stroked outline of the segments provided by the subclass in the virtual |Dispatch| method. More...
class	StrokePathSourceGeometry
	An abstract Geometry base class that produces fillable vertices representing the stroked outline from any |PathSource| provided by the subclass. More...
class	StrokePathGeometry
	A Geometry that produces fillable vertices representing the stroked outline of a |DlPath| object using the |StrokePathSourceGeometry| base class and a |DlPath| object to perform path iteration. More...
class	ArcStrokeGeometry
	A Geometry that produces fillable vertices representing the stroked outline of an |Arc| object using the base class |StrokeSegmentsGeometry| and utilizing the special |RecordArc| extension method provided by the |PathAndArcSegmentReceiver|. More...
class	StrokeDiffRoundRectGeometry
	A Geometry that produces fillable vertices representing the stroked outline of a pair of nested |RoundRect| objects using the |StrokePathSourceGeometry| base class. More...
class	StrokeDashedLineGeometry
	A Geometry that produces fillable vertices representing the stroked outline of a |DlPath| object using the |StrokePathSourceGeometry| base class and a |DlPath| object to perform path iteration. More...
class	SuperellipseGeometry
class	VerticesGeometry
	A geometry that is created from a vertices object. More...
class	InlinePassContext
class	RenderTargetCache
	An implementation of the [RenderTargetAllocator] that caches all allocated texture data for one frame. More...
struct	Arc
struct	ColorMatrix
struct	Color
class	DashedLinePathSource
	A PathSource that generates the various segments of a dashed line. More...
class	ImpellerBenchmarkAccessor
struct	GradientData
struct	Half
	A storage only class for half precision floating point. More...
struct	HalfVector4
	A storage only class for half precision floating point vector 4. More...
struct	HalfVector3
	A storage only class for half precision floating point vector 3. More...
struct	HalfVector2
	A storage only class for half precision floating point vector 2. More...
struct	Matrix
	A 4x4 matrix using column-major storage. More...
struct	MatrixDecomposition
class	PathReceiver
	Collection of functions to receive path segments from the underlying path representation via the DlPath::Dispatch method. More...
class	PathSource
class	RectPathSource
	A PathSource object that provides path iteration for any TRect. More...
class	EllipsePathSource
	A PathSource object that provides path iteration for any ellipse inscribed within a Rect bounds. More...
struct	TPoint
struct	Quaternion
class	Rational
struct	TRect
struct	RoundRect
class	RoundRectPathSource
class	DiffRoundRectPathSource
struct	RoundSuperellipse
class	RoundSuperellipsePathSource
struct	RoundSuperellipseParam
struct	RoundingRadii
struct	RSTransform
struct	Radians
struct	Degrees
struct	SeparatedVector2
	A Vector2, broken down as a separate magnitude and direction. Assumes that the direction given is normalized. More...
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...
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	TSize
struct	StrokeParameters
	A structure to store all of the parameters related to stroking a path or basic geometry object. More...
struct	Trig
	A structure to store the sine and cosine of an angle. More...
struct	MixedOp_
struct	Vector3
struct	Vector4
class	GoldenPlaygroundTest
class	PlaygroundImplGLES
class	PlaygroundImplMTL
class	PlaygroundImplVK
class	ComputePlaygroundTest
class	CompressedImageSkia
class	CompressedImage
class	DecompressedImage
class	Playground
class	PlaygroundImpl
class	PlaygroundTest
struct	PlaygroundSwitches
struct	PlaygroundPoint
class	AllocatorGLES
struct	BlitEncodeGLES
	Mixin for dispatching GLES commands. More...
struct	BlitCopyBufferToTextureCommandGLES
struct	BlitCopyTextureToTextureCommandGLES
struct	BlitCopyTextureToBufferCommandGLES
struct	BlitGenerateMipmapCommandGLES
struct	BlitResizeTextureCommandGLES
class	BlitPassGLES
class	BufferBindingsGLES
	Sets up stage bindings for single draw call in the OpenGLES backend. More...
class	CapabilitiesGLES
	The Vulkan layers and extensions wrangler. More...
class	CommandBufferGLES
class	ContextGLES
class	DescriptionGLES
class	DeviceBufferGLES
class	GPUTracerGLES
	Trace GPU execution times using GL_EXT_disjoint_timer_query on GLES. More...
class	HandleGLES
	Represents a handle to an underlying OpenGL object. Unlike OpenGL object handles, these handles can be collected on any thread as long as their destruction is scheduled in a reactor. More...
class	PipelineGLES
class	PipelineLibraryGLES
struct	AutoErrorCheck
struct	GLProc
class	ProcTableGLES
class	ReactorGLES
	The reactor attempts to make thread-safe usage of OpenGL ES easier to reason about. More...
struct	RenderPassData
	Encapsulates data that will be needed in the reactor for the encoding of commands for this render pass. More...
class	RenderPassGLES
class	SamplerGLES
class	SamplerLibraryGLES
class	ShaderFunctionGLES
class	ShaderLibraryGLES
class	SurfaceGLES
class	TextureGLES
class	UniqueHandleGLES
	A unique handle to an OpenGL object. The collection of this handle scheduled the destruction of the associated OpenGL object in the reactor. More...
class	DebugAllocatorStats
class	AllocatorMTL
class	BlitPassMTL
class	CommandBufferMTL
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	ComputePipelineMTL
class	ImpellerMetalCaptureManager
	Creates and manages a Metal capture scope that supports frame capture when using the FlutterMetalLayer backed drawable. More...
class	ContextMTL
class	DeviceBufferMTL
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...
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	PipelineLibraryMTL
class	PipelineMTL
class	RenderPassMTL
class	SamplerLibraryMTL
class	SamplerMTL
class	ShaderFunctionMTL
class	ShaderLibraryMTL
class	SurfaceMTL
class	SwapchainTransientsMTL
	A cache for the onscreen texture attachments used in surface_mtl. More...
class	TextureMTL
class	VertexDescriptorMTL
class	AllocatedTextureSourceVK
class	AllocatorVK
class	AHBTextureSourceVK
	A texture source that wraps an instance of AHardwareBuffer. More...
struct	BarrierVK
	Defines an operations and memory access barrier on a resource. More...
class	BlitPassVK
struct	FRCFormatDescriptor
	A pixel format and usage that is sufficient to check if images of that format and usage are suitable for use with fixed-rate compression. More...
class	CapabilitiesVK
	The Vulkan layers and extensions wrangler. More...
class	CommandBufferVK
class	BackgroundCommandPoolVK
class	CommandPoolVK
	Manages the lifecycle of a single |vk::CommandPool|. More...
class	CommandPoolRecyclerVK
	Creates and manages the lifecycle of |vk::CommandPool| objects. More...
class	CommandQueueVK
class	ComputePassVK
class	ComputePipelineVK
class	IdleWaiterVK
class	ContextVK
class	DebugReportVK
struct	DescriptorPoolSize
struct	DescriptorCache
	Used and un-used descriptor sets. More...
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...
class	DescriptorPoolRecyclerVK
	Creates and manages the lifecycle of |vk::DescriptorPoolVK| objects. More...
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	DriverInfoVK
	Get information about the Vulkan driver. More...
class	WaitSetEntry
class	FenceWaiterVK
class	GPUTracerVK
	A class that uses timestamp queries to record the approximate GPU execution time. More...
class	GPUProbe
struct	PipelineCacheHeaderVK
	An Impeller specific header prepended to all pipeline cache information that is persisted on disk. This information is used to perform additional integrity checks that may have been missed by the Vulkan driver. More...
class	PipelineCacheVK
class	PipelineLibraryVK
class	PipelineVK
struct	QueueIndexVK
class	QueueVK
	A thread safe object that can be used to access device queues. If multiple objects are created with the same underlying queue, then the external synchronization guarantees of Vulkan queues cannot be met. So care must be taken the same device queue doesn't form the basis of multiple QueueVKs. More...
struct	QueuesVK
	The collection of queues used by the context. The queues may all be the same. More...
class	RenderPassBuilderVK
class	RenderPassVK
class	ResourceVK
	A resource that may be reclaimed by a |ResourceManagerVK|. More...
class	ResourceManagerVK
	A resource manager controls how resources are allocated and reclaimed. More...
class	ResourceVKT
	An internal type that is used to move a resource reference. More...
class	UniqueResourceVKT
	A unique handle to a resource which will be reclaimed by the specified resource manager. More...
class	SamplerLibraryVK
class	SamplerVK
class	ShaderFunctionVK
class	ShaderLibraryVK
class	SharedObjectVK
class	SharedObjectVKT
class	SurfaceContextVK
struct	AHBFrameSynchronizerVK
class	AHBSwapchainImplVK
	The implementation of a swapchain at a specific size. Resizes to the surface will cause the instance of the swapchain impl at that size to be discarded along with all its caches and transients. More...
class	AHBSwapchainVK
	The implementation of a swapchain that uses hardware buffers presented to a given surface control on Android. More...
class	AHBTexturePoolVK
	Maintains a bounded pool of hardware buffer backed texture sources that can be used as swapchain images. More...
class	ExternalSemaphoreVK
	A Vulkan semaphore that can be exported as a platform specific file descriptor. More...
class	KHRSwapchainImageVK
struct	KHRFrameSynchronizerVK
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 implemented backed by VK_KHR_swapchain and VK_KHR_surface. More...
class	SurfaceVK
class	SwapchainTransientsVK
	Resources, meant to be memoized by the texture descriptor of the wrapped swapchain images, that are intuitively cheap to create but have been observed to be time consuming to construct on some Vulkan drivers. This includes the device-transient MSAA and depth-stencil textures. More...
class	SwapchainVK
	A swapchain that adapts to the underlying surface going out of date. If the caller cannot acquire the next drawable, it is due to an unrecoverable error and the swapchain must be recreated with a new surface. More...
struct	FramebufferAndRenderPass
class	TextureSourceVK
	Abstract base class that represents a vkImage and an vkImageView. More...
class	TextureVK
class	TrackedObjectsVK
	A per-frame object used to track resource lifetimes and allocate command buffers and descriptor sets. More...
struct	AllocatorVMATraits
struct	PoolVMA
struct	PoolVMATraits
struct	BufferVMA
struct	BufferVMATraits
struct	ImageVMA
struct	ImageVMATraits
struct	WorkaroundsVK
	A non-exhaustive set of driver specific workarounds. More...
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...
struct	YUVConversionDescriptorVKHash
struct	YUVConversionDescriptorVKEqual
struct	ImmutableSamplerKeyVK
struct	BlitCommand
struct	BlitCopyTextureToTextureCommand
struct	BlitResizeTextureCommand
struct	BlitCopyTextureToBufferCommand
struct	BlitCopyBufferToTextureCommand
struct	BlitGenerateMipmapCommand
class	BlitPass
	Blit passes encode blit into the underlying command buffer. More...
class	StandardCapabilities
class	Capabilities
class	CapabilitiesBuilder
class	Resource
struct	TextureAndSampler
	combines the texture, sampler and sampler slot information. More...
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	CommandQueue
	An interface for submitting command buffers to the GPU for encoding and execution. More...
class	ComputePass
	Compute passes encode compute shader into the underlying command buffer. More...
struct	ComputePipelineBuilder
	An optional (but highly recommended) utility for creating pipelines from reflected shader information. More...
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...
class	ComputePipelineDescriptor
class	ImpellerContextFuture
class	Context
	To do anything rendering related with Impeller, you need a context. More...
struct	PipelineFuture
class	GenericRenderPipelineHandle
class	RenderPipelineHandle
class	ComputePipelineHandle
struct	PipelineBuilder
	An optional (but highly recommended) utility for creating pipelines from reflected shader information. More...
class	PipelineDescriptor
class	PipelineLibrary
class	Pool
	A thread-safe pool with a limited byte size. More...
class	RenderPass
	Render passes encode render commands directed as one specific render target into an underlying command buffer. More...
struct	RenderTargetConfig
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	SamplerLibrary
class	ShaderFunction
struct	ShaderKey
class	ShaderLibrary
class	ShaderStageCompatibilityChecker
	Checks, at C++ compile-time, if the two pipeline stages are compatible. More...
struct	Snapshot
	Represents a texture and its intended draw transform/sampler configuration. More...
class	Surface
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	RuntimeStage
class	RuntimeStagePlayground
class	ShaderArchive
class	ShaderArchiveWriter
struct	Vertices
class	PathTessellator
class	Tessellator
	A utility that generates triangles of the specified fill type given a polyline. This happens on the CPU. More...
class	TessellatorLibtess
	An extended tessellator that offers arbitrary/concave tessellation via the libtess2 library. More...
struct	EGLImageWithDisplay
struct	EGLImageWithDisplayTraits
struct	EGLImageKHRWithDisplay
struct	EGLImageKHRWithDisplayTraits
struct	GLTexture
struct	GLTextureTraits
class	TypefaceSkia
class	TypographerContextSkia
class	Font
	Describes a typeface along with any modifications to its intrinsic properties. More...
struct	GlyphProperties
struct	ScaledFont
	A font and a scale. Used as a key that represents a typeface within a glyph atlas. More...
struct	SubpixelGlyph
	A glyph and its subpixel position. More...
struct	FontGlyphPair
	A font along with a glyph in that font rendered at a particular scale and subpixel position. More...
struct	Glyph
	The glyph index in the typeface. More...
struct	AbslHashAdapterCombiner
	Helper for AbslHashAdapter. Tallies a hash value with fml::HashCombine. More...
struct	AbslHashAdapter
struct	FrameBounds
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	FontGlyphAtlas
	An object that can look up glyph locations within the GlyphAtlas for a particular typeface. More...
class	LazyGlyphAtlas
class	SkylineRectanglePacker
struct	IPoint16
class	RectanglePacker
	Packs rectangles into a specified area without rotating them. More...
class	TextFrame
	Represents a collection of shaped text runs. More...
class	TextRun
	Represents a collection of positioned glyphs from a specific font. More...
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	TypographerContext
	The graphics context necessary to render text. More...

Typedefs
using	Bytes = AllocationSize< 1u >
using	KiloBytes = AllocationSize< 1 '000u >
using	MegaBytes = AllocationSize< 1 '000u *1 '000u >
using	GigaBytes = AllocationSize< 1 '000u *1 '000u *1 '000u >
using	KibiBytes = AllocationSize< 1 '024u >
using	MebiBytes = AllocationSize< 1 '024u *1 '024u >
using	GibiBytes = AllocationSize< 1 '024u *1 '024u *1 '024u >
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	ValidationFailureCallback = std::function< bool(const char *message, const char *file, int line)>
using	TextureUsageMask = Mask< TextureUsage >
using	ColorWriteMask = Mask< ColorWriteMaskBits >
using	ColorFilterProc = std::function< Color(Color)>
using	DlScalar = flutter::DlScalar
using	DlPoint = flutter::DlPoint
using	DlRect = flutter::DlRect
using	DlIRect = flutter::DlIRect
using	DlRoundRect = flutter::DlRoundRect
using	DlRoundSuperellipse = flutter::DlRoundSuperellipse
using	DlPath = flutter::DlPath
using	PipelineProc = PipelineRef(ContentContext::*)(ContentContextOptions) const
using	GaussianBlurVertexShader = GaussianBlurPipeline::VertexShader
using	GaussianBlurFragmentShader = GaussianBlurPipeline::FragmentShader
using	VS = LinePipeline::VertexShader
using	FS = LinePipeline::FragmentShader
template<typename T >
using	GradientPipelineHandle = RenderPipelineHandle< GradientFillVertexShader, T >
using	AdvancedBlendPipelineHandle = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >
using	FramebufferBlendPipelineHandle = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >
using	BlendColorBurnPipeline = AdvancedBlendPipelineHandle
using	BlendColorDodgePipeline = AdvancedBlendPipelineHandle
using	BlendColorPipeline = AdvancedBlendPipelineHandle
using	BlendDarkenPipeline = AdvancedBlendPipelineHandle
using	BlendDifferencePipeline = AdvancedBlendPipelineHandle
using	BlendExclusionPipeline = AdvancedBlendPipelineHandle
using	BlendHardLightPipeline = AdvancedBlendPipelineHandle
using	BlendHuePipeline = AdvancedBlendPipelineHandle
using	BlendLightenPipeline = AdvancedBlendPipelineHandle
using	BlendLuminosityPipeline = AdvancedBlendPipelineHandle
using	BlendMultiplyPipeline = AdvancedBlendPipelineHandle
using	BlendOverlayPipeline = AdvancedBlendPipelineHandle
using	BlendSaturationPipeline = AdvancedBlendPipelineHandle
using	BlendScreenPipeline = AdvancedBlendPipelineHandle
using	BlendSoftLightPipeline = AdvancedBlendPipelineHandle
using	BorderMaskBlurPipeline = RenderPipelineHandle< FilterPositionUvVertexShader, BorderMaskBlurFragmentShader >
using	ClipPipeline = RenderPipelineHandle< ClipVertexShader, ClipFragmentShader >
using	ColorMatrixColorFilterPipeline = RenderPipelineHandle< FilterPositionUvVertexShader, ColorMatrixColorFilterFragmentShader >
using	ConicalGradientFillConicalPipeline = GradientPipelineHandle< ConicalGradientFillConicalFragmentShader >
using	ConicalGradientFillRadialPipeline = GradientPipelineHandle< ConicalGradientFillRadialFragmentShader >
using	ConicalGradientFillStripPipeline = GradientPipelineHandle< ConicalGradientFillStripFragmentShader >
using	ConicalGradientFillStripRadialPipeline = GradientPipelineHandle< ConicalGradientFillStripRadialFragmentShader >
using	ConicalGradientSSBOFillPipeline = GradientPipelineHandle< ConicalGradientSsboFillFragmentShader >
using	ConicalGradientUniformFillConicalPipeline = GradientPipelineHandle< ConicalGradientUniformFillConicalFragmentShader >
using	ConicalGradientUniformFillRadialPipeline = GradientPipelineHandle< ConicalGradientUniformFillRadialFragmentShader >
using	ConicalGradientUniformFillStripPipeline = GradientPipelineHandle< ConicalGradientUniformFillStripFragmentShader >
using	ConicalGradientUniformFillStripRadialPipeline = GradientPipelineHandle< ConicalGradientUniformFillStripRadialFragmentShader >
using	FastGradientPipeline = RenderPipelineHandle< FastGradientVertexShader, FastGradientFragmentShader >
using	FramebufferBlendColorBurnPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendColorDodgePipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendColorPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendDarkenPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendDifferencePipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendExclusionPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendHardLightPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendHuePipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendLightenPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendLuminosityPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendMultiplyPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendOverlayPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendSaturationPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendScreenPipeline = FramebufferBlendPipelineHandle
using	FramebufferBlendSoftLightPipeline = FramebufferBlendPipelineHandle
using	GaussianBlurPipeline = RenderPipelineHandle< FilterPositionUvVertexShader, GaussianFragmentShader >
using	GlyphAtlasPipeline = RenderPipelineHandle< GlyphAtlasVertexShader, GlyphAtlasFragmentShader >
using	LinePipeline = RenderPipelineHandle< LineVertexShader, LineFragmentShader >
using	LinearGradientFillPipeline = GradientPipelineHandle< LinearGradientFillFragmentShader >
using	LinearGradientSSBOFillPipeline = GradientPipelineHandle< LinearGradientSsboFillFragmentShader >
using	LinearGradientUniformFillPipeline = GradientPipelineHandle< LinearGradientUniformFillFragmentShader >
using	LinearToSrgbFilterPipeline = RenderPipelineHandle< FilterPositionVertexShader, LinearToSrgbFilterFragmentShader >
using	MorphologyFilterPipeline = RenderPipelineHandle< FilterPositionUvVertexShader, MorphologyFilterFragmentShader >
using	PorterDuffBlendPipeline = RenderPipelineHandle< PorterDuffBlendVertexShader, PorterDuffBlendFragmentShader >
using	RadialGradientFillPipeline = GradientPipelineHandle< RadialGradientFillFragmentShader >
using	RadialGradientSSBOFillPipeline = GradientPipelineHandle< RadialGradientSsboFillFragmentShader >
using	RadialGradientUniformFillPipeline = GradientPipelineHandle< RadialGradientUniformFillFragmentShader >
using	RRectBlurPipeline = RenderPipelineHandle< RrectLikeBlurVertexShader, RrectBlurFragmentShader >
using	RSuperellipseBlurPipeline = RenderPipelineHandle< RrectLikeBlurVertexShader, RsuperellipseBlurFragmentShader >
using	SolidFillPipeline = RenderPipelineHandle< SolidFillVertexShader, SolidFillFragmentShader >
using	SrgbToLinearFilterPipeline = RenderPipelineHandle< FilterPositionVertexShader, SrgbToLinearFilterFragmentShader >
using	SweepGradientFillPipeline = GradientPipelineHandle< SweepGradientFillFragmentShader >
using	SweepGradientSSBOFillPipeline = GradientPipelineHandle< SweepGradientSsboFillFragmentShader >
using	SweepGradientUniformFillPipeline = GradientPipelineHandle< SweepGradientUniformFillFragmentShader >
using	TextureDownsamplePipeline = RenderPipelineHandle< TextureFillVertexShader, TextureDownsampleFragmentShader >
using	TexturePipeline = RenderPipelineHandle< TextureFillVertexShader, TextureFillFragmentShader >
using	TextureStrictSrcPipeline = RenderPipelineHandle< TextureFillVertexShader, TextureFillStrictSrcFragmentShader >
using	TiledTexturePipeline = RenderPipelineHandle< TextureUvFillVertexShader, TiledTextureFillFragmentShader >
using	VerticesUber1Shader = RenderPipelineHandle< PorterDuffBlendVertexShader, VerticesUber1FragmentShader >
using	VerticesUber2Shader = RenderPipelineHandle< PorterDuffBlendVertexShader, VerticesUber2FragmentShader >
using	YUVToRGBFilterPipeline = RenderPipelineHandle< FilterPositionVertexShader, YuvToRgbFilterFragmentShader >
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	IRect32 = TRect< int32_t >
using	IRect64 = TRect< int64_t >
using	IRect = IRect64
using	Scalar = float
using	Size = TSize< Scalar >
using	ISize32 = TSize< int32_t >
using	ISize64 = TSize< int64_t >
using	ISize = ISize64
template<class F , class I >
using	MixedOp = typename MixedOp_< F, I >::type
using	Callback = std::function< void(MTLRenderPipelineDescriptor *)>
using	CommandPoolMap = std::unordered_map< uint64_t, std::shared_ptr< CommandPoolVK > >
using	DescriptorCacheMap = std::unordered_map< PipelineKey, DescriptorCache >
using	WaitSet = std::vector< std::shared_ptr< WaitSetEntry > >
template<class T >
using	SharedHandleVK = std::shared_ptr< SharedObjectVKT< T > >
using	CreateTransactionCB = std::function< android::SurfaceTransaction()>
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	PipelineKey = int64_t
using	PipelineRef = raw_ptr< Pipeline< PipelineDescriptor > >
	A raw ptr to a pipeline object. More...
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	PathBuilder = flutter::DlPathBuilder
using	TessellatedVertexProc = Tessellator::TessellatedVertexProc
using	EllipticalVertexGenerator = Tessellator::EllipticalVertexGenerator
using	ArcVertexGenerator = Tessellator::ArcVertexGenerator
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	PathCreator = std::function< fml::StatusOr< flutter::DlPath >()>

Enumerations
enum class	FromBytesTag { kFromBytes }
enum class	MyMaskBits : uint32_t {   kFoo = 0 ,   kBar = 1 << 0 ,   kBaz = 1 << 1 ,   kBang = 1 << 2 }
enum class	WindingOrder {   kClockwise ,   kCounterClockwise }
enum class	StorageMode {   kHostVisible ,   kDevicePrivate ,   kDeviceTransient }
	Specified where the allocation resides and how it is used. More...
enum class	PixelFormat : uint8_t {   kUnknown ,   kA8UNormInt ,   kR8UNormInt ,   kR8G8UNormInt ,   kR8G8B8A8UNormInt ,   kR8G8B8A8UNormIntSRGB ,   kB8G8R8A8UNormInt ,   kB8G8R8A8UNormIntSRGB ,   kR32G32B32A32Float ,   kR16G16B16A16Float ,   kB10G10R10XR ,   kB10G10R10XRSRGB ,   kB10G10R10A10XR ,   kS8UInt ,   kD24UnormS8Uint ,   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 class	BlendFactor {   kZero ,   kOne ,   kSourceColor ,   kOneMinusSourceColor ,   kSourceAlpha ,   kOneMinusSourceAlpha ,   kDestinationColor ,   kOneMinusDestinationColor ,   kDestinationAlpha ,   kOneMinusDestinationAlpha ,   kSourceAlphaSaturated ,   kBlendColor ,   kOneMinusBlendColor ,   kBlendAlpha ,   kOneMinusBlendAlpha }
enum class	BlendOperation {   kAdd ,   kSubtract ,   kReverseSubtract }
enum class	LoadAction {   kDontCare ,   kLoad ,   kClear }
enum class	StoreAction {   kDontCare ,   kStore ,   kMultisampleResolve ,   kStoreAndMultisampleResolve }
enum class	TextureType {   kTexture2D ,   kTexture2DMultisample ,   kTextureCube ,   kTextureExternalOES }
enum class	SampleCount : uint8_t {   kCount1 = 1 ,   kCount4 = 4 }
enum class	TextureUsage {   kUnknown = 0 ,   kShaderRead = 1 << 0 ,   kShaderWrite = 1 << 1 ,   kRenderTarget = 1 << 2 }
enum class	TextureCoordinateSystem {   kUploadFromHost ,   kRenderToTexture }
enum class	CullMode {   kNone ,   kFrontFace ,   kBackFace }
enum class	IndexType {   kUnknown ,   k16bit ,   k32bit ,   kNone }
enum class	PrimitiveType : uint8_t {   kTriangle ,   kTriangleStrip ,   kLine ,   kLineStrip ,   kPoint ,   kTriangleFan }
	Decides how backend draws pixels based on input vertices. More...
enum class	PolygonMode {   kFill ,   kLine }
enum class	MinMagFilter : uint8_t {   kNearest ,   kLinear }
	Describes how the texture should be sampled when the texture is being shrunk (minified) or expanded (magnified) to fit to the sample point. More...
enum class	MipFilter : uint8_t {   kBase ,   kNearest ,   kLinear }
	Options for selecting and filtering between mipmap levels. More...
enum class	SamplerAddressMode : uint8_t {   kClampToEdge ,   kRepeat ,   kMirror ,   kDecal }
enum class	ColorWriteMaskBits : uint64_t {   kNone = 0 ,   kRed = 1 << 0 ,   kGreen = 1 << 1 ,   kBlue = 1 << 2 ,   kAlpha = 1 << 3 ,   kAll = kRed | kGreen | kBlue | kAlpha }
enum class	CompareFunction : uint8_t {   kNever ,   kAlways ,   kLess ,   kEqual ,   kLessEqual ,   kGreater ,   kNotEqual ,   kGreaterEqual }
enum class	StencilOperation : uint8_t {   kKeep ,   kZero ,   kSetToReferenceValue ,   kIncrementClamp ,   kDecrementClamp ,   kInvert ,   kIncrementWrap ,   kDecrementWrap }
enum class	RuntimeStageBackend {   kSkSL ,   kMetal ,   kOpenGLES ,   kOpenGLES3 ,   kVulkan }
enum	RuntimeUniformType {   kFloat ,   kSampledImage ,   kStruct }
enum class	RuntimeShaderStage {   kVertex ,   kFragment ,   kCompute }
enum class	ShaderStage {   kUnknown ,   kVertex ,   kFragment ,   kCompute }
enum class	ShaderType {   kUnknown ,   kVoid ,   kBoolean ,   kSignedByte ,   kUnsignedByte ,   kSignedShort ,   kUnsignedShort ,   kSignedInt ,   kUnsignedInt ,   kSignedInt64 ,   kUnsignedInt64 ,   kAtomicCounter ,   kHalfFloat ,   kFloat ,   kDouble ,   kStruct ,   kImage ,   kSampledImage ,   kSampler }
enum class	DescriptorType {   kSampler = 0 ,   kSampledImage = 1 ,   kImage = 2 ,   kUniformBuffer = 6 ,   kStorageBuffer = 7 ,   kInputAttachment = 10 }
enum class	CompressionType {   kLossless ,   kLossy }
	Additional compression to apply to a texture. This value is ignored on platforms which do not support it. More...
enum class	PointStyle {   kRound ,   kSquare }
enum class	SourceRectConstraint {   kFast ,   kStrict }
	Controls the behavior of the source rectangle given to DrawImageRect. More...
enum class	ContentBoundsPromise {   kUnknown ,   kContainsContents ,   kMayClipContents }
enum	ConicalKind {   kConical ,   kRadial ,   kStrip ,   kStripAndRadial }
enum class	BlendSelectValues {   kScreen = 0 ,   kOverlay ,   kDarken ,   kLighten ,   kColorDodge ,   kColorBurn ,   kHardLight ,   kSoftLight ,   kDifference ,   kExclusion ,   kMultiply ,   kHue ,   kSaturation ,   kColor ,   kLuminosity }
enum class	YUVColorSpace {   kBT601LimitedRange ,   kBT601FullRange }
enum class	BlendMode : uint8_t {   kClear = 0 ,   kSrc ,   kDst ,   kSrcOver ,   kDstOver ,   kSrcIn ,   kDstIn ,   kSrcOut ,   kDstOut ,   kSrcATop ,   kDstATop ,   kXor ,   kPlus ,   kModulate ,   kScreen ,   kOverlay ,   kDarken ,   kLighten ,   kColorDodge ,   kColorBurn ,   kHardLight ,   kSoftLight ,   kDifference ,   kExclusion ,   kMultiply ,   kHue ,   kSaturation ,   kColor ,   kLuminosity ,   kLastMode = kLuminosity ,   kDefaultMode = kSrcOver }
enum class	FillType {   kNonZero ,   kOdd }
enum class	Convexity {   kUnknown ,   kConvex }
enum class	Cap {   kButt ,   kRound ,   kSquare }
	An enum that describes ways to decorate the end of a path contour. More...
enum class	Join {   kMiter ,   kRound ,   kBevel }
	An enum that describes ways to join two segments of a path. More...
enum class	PlaygroundBackend {   kMetal ,   kOpenGLES ,   kVulkan }
enum class	HandleType {   kUnknown ,   kTexture ,   kBuffer ,   kProgram ,   kRenderBuffer ,   kFrameBuffer ,   kFence }
enum class	DebugResourceType {   kTexture ,   kBuffer ,   kProgram ,   kShader ,   kRenderBuffer ,   kFrameBuffer ,   kFence }
enum class	RequiredCommonDeviceExtensionVK : uint32_t {   kKHRSwapchain ,   kLast }
	A device extension available on all platforms. Without the presence of these extensions, context creation will fail. More...
enum class	RequiredAndroidDeviceExtensionVK : uint32_t {   kANDROIDExternalMemoryAndroidHardwareBuffer ,   kKHRSamplerYcbcrConversion ,   kKHRExternalMemory ,   kEXTQueueFamilyForeign ,   kKHRDedicatedAllocation ,   kLast }
	A device extension available on all Android platforms. Without the presence of these extensions on Android, context creation will fail. More...
enum class	OptionalAndroidDeviceExtensionVK : uint32_t {   kKHRExternalFenceFd ,   kKHRExternalFence ,   kKHRExternalSemaphoreFd ,   kKHRExternalSemaphore ,   kLast }
	A device extension available on some Android platforms. More...
enum class	OptionalDeviceExtensionVK : uint32_t {   kEXTPipelineCreationFeedback ,   kVKKHRPortabilitySubset ,   kEXTImageCompressionControl ,   kLast }
	A device extension enabled if available. Subsystems cannot assume availability and must check if these extensions are available. More...
enum class	AdrenoGPU {   kAdreno504 ,   kAdreno505 ,   kAdreno506 ,   kAdreno508 ,   kAdreno509 ,   kAdreno510 ,   kAdreno512 ,   kAdreno530 ,   kAdreno540 ,   kAdreno605 ,   kAdreno608 ,   kAdreno610 ,   kAdreno612 ,   kAdreno613 ,   kAdreno615 ,   kAdreno616 ,   kAdreno618 ,   kAdreno619L ,   kAdreno619 ,   kAdreno620 ,   kAdreno630 ,   kAdreno640 ,   kAdreno642L ,   kAdreno642 ,   kAdreno643L ,   kAdreno644 ,   kAdreno650 ,   kAdreno660 ,   kAdreno663 ,   kAdreno675 ,   kAdreno680 ,   kAdreno685 ,   kAdreno690 ,   kAdreno695 ,   kAdreno702 ,   kAdreno710 ,   kAdreno720 ,   kAdreno725 ,   kAdreno730 ,   kAdreno732 ,   kAdreno735 ,   kAdreno740 ,   kAdreno750 ,   kAdrenoX145 ,   kAdrenoX185 ,   kUnknown }
enum class	MaliGPU {   kT760 ,   kT820 ,   kT830 ,   kT860 ,   kT880 ,   kG31 ,   kG51 ,   kG71 ,   kG52 ,   kG72 ,   kG76 ,   kG57 ,   kG77 ,   kG68 ,   kG78 ,   kG310 ,   kG510 ,   kG610 ,   kG710 ,   kG615 ,   kG715 ,   kG620 ,   kG720 ,   kG625 ,   kG725 ,   kG925 ,   kUnknown }
enum class	PowerVRGPU {   kUnknown ,   kRogue ,   kAXE ,   kAXM ,   kAXT ,   kBXE ,   kBXM ,   kBXS ,   kBXT ,   kCXT ,   kDXT }
enum class	VendorVK {   kUnknown ,   kGoogle ,   kQualcomm ,   kARM ,   kImgTec ,   kPowerVR = kImgTec ,   kAMD ,   kNvidia ,   kIntel ,   kHuawei ,   kSamsung ,   kMesa ,   kApple }
enum class	DeviceTypeVK {   kUnknown ,   kIntegratedGPU ,   kDiscreteGPU ,   kVirtualGPU ,   kCPU }
enum class	ArchiveShaderType {   kVertex ,   kFragment ,   kCompute }
enum class	AxisAlignment : uint8_t {   kNone ,   kX ,   kY ,   kAll }
	Determines the axis along which there is subpixel positioning. More...
enum	SubpixelPosition : uint8_t {   kSubpixel00 = 0x0 ,   kSubpixel10 = 0x1 ,   kSubpixel20 = 0x2 ,   kSubpixel30 = 0x3 ,   kSubpixel01 = kSubpixel10 << 2 ,   kSubpixel02 = kSubpixel20 << 2 ,   kSubpixel03 = kSubpixel30 << 2 ,   kSubpixel11 = kSubpixel10 | kSubpixel01 ,   kSubpixel12 = kSubpixel10 | kSubpixel02 ,   kSubpixel13 = kSubpixel10 | kSubpixel03 ,   kSubpixel21 = kSubpixel20 | kSubpixel01 ,   kSubpixel22 = kSubpixel20 | kSubpixel02 ,   kSubpixel23 = kSubpixel20 | kSubpixel03 ,   kSubpixel31 = kSubpixel30 | kSubpixel01 ,   kSubpixel32 = kSubpixel30 | kSubpixel02 ,   kSubpixel33 = kSubpixel30 | kSubpixel03 }

Functions
std::shared_ptr< fml::Mapping >	CreateMappingWithCopy (const uint8_t *contents, Bytes length)
	Creates a mapping with copy of the bytes. More...
std::shared_ptr< fml::Mapping >	CreateMappingFromAllocation (const std::shared_ptr< Allocation > &allocation)
	Creates a mapping from allocation. More...
std::shared_ptr< fml::Mapping >	CreateMappingWithString (std::string string)
	Creates a mapping with string data. More...
std::shared_ptr< fml::Mapping >	CreateMappingWithString (std::shared_ptr< const std::string > string)
	Creates a mapping with string data. More...
constexpr Bytes	operator""_bytes (unsigned long long int size)
constexpr KiloBytes	operator""_kb (unsigned long long int size)
constexpr MegaBytes	operator""_mb (unsigned long long int size)
constexpr GigaBytes	operator""_gb (unsigned long long int size)
constexpr KibiBytes	operator""_kib (unsigned long long int size)
constexpr MebiBytes	operator""_mib (unsigned long long int size)
constexpr GibiBytes	operator""_gib (unsigned long long int size)
	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	ImpellerValidationErrorsSetCallback (ValidationFailureCallback callback)
	Sets a callback that callers (usually tests) can set to intercept validation failures. More...
void	ImpellerValidationBreak (const char *message, const char *file, int line)
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...
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 ShaderStage	ToShaderStage (RuntimeShaderStage stage)
constexpr Vector4	ToVector (Color color)
std::string	TextureDescriptorToString (const TextureDescriptor &desc)
constexpr const char *	CompressionTypeToString (CompressionType type)
std::shared_ptr< ColorFilterContents >	WrapWithInvertColors (const std::shared_ptr< FilterInput > &input, ColorFilterContents::AbsorbOpacity absorb_opacity)
std::shared_ptr< ColorFilterContents >	WrapWithGPUColorFilter (const flutter::DlColorFilter *filter, const std::shared_ptr< FilterInput > &input, ColorFilterContents::AbsorbOpacity absorb_opacity)
ColorFilterProc	GetCPUColorFilterProc (const flutter::DlColorFilter *filter)
static impeller::SamplerDescriptor	ToSamplerDescriptor (const flutter::DlFilterMode options)
static std::optional< const Rect >	ToOptRect (const flutter::DlRect *rect)
static Paint::Style	ToStyle (flutter::DlDrawStyle style)
static FilterContents::BlurStyle	ToBlurStyle (flutter::DlBlurStyle blur_style)
static Entity::ClipOperation	ToClipOperation (flutter::DlClipOp clip_op)
static bool	RequiresReadbackForBlends (const ContentContext &renderer, flutter::DlBlendMode max_root_blend_mode)
	Subclasses. More...
std::shared_ptr< Texture >	DisplayListToTexture (const sk_sp< flutter::DisplayList > &display_list, ISize size, AiksContext &context, bool reset_host_buffer=true, bool generate_mips=false)
	Render the provided display list to a texture with the given size. More...
bool	RenderToTarget (ContentContext &context, RenderTarget render_target, const sk_sp< flutter::DisplayList > &display_list, Rect cull_rect, bool reset_host_buffer, bool is_onscreen=true)
	Render the provided display list to the render target. More...
std::shared_ptr< FilterContents >	WrapInput (const flutter::DlImageFilter *filter, const FilterInput::Ref &input)
	Generate a new FilterContents using this filter's configuration. More...
static Scalar	GetShaderClipDepth (uint32_t clip_depth)
bool	RenderClipRestore (const ContentContext &renderer, RenderPass &pass, uint32_t clip_depth, std::optional< Rect > restore_coverage)
	Render a restore clip. More...
std::array< std::vector< Scalar >, 15 >	GetPorterDuffSpecConstants (bool supports_decal)
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)
KernelSamples	GenerateBlurInfo (BlurParameters parameters)
GaussianBlurPipeline::FragmentShader::KernelSamples	LerpHackKernelSamples (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...
int	PopulateUniformGradientColors (const std::vector< Color > &colors, const std::vector< Scalar > &stops, Vector4 frag_info_colors[kMaxUniformGradientStops], Vector4 frag_info_stop_pairs[kMaxUniformGradientStops/2])
	Populate 2 arrays with the colors and stop data for a gradient. More...
static ShaderType	GetShaderType (RuntimeUniformType type)
static std::unique_ptr< ShaderMetadata >	MakeShaderMetadata (const RuntimeUniformDescription &uniform)
static Point	eccentricity (Point v, double sInverse)
static Scalar	computeErf7 (Scalar x)
static Point	NegPos (Scalar v)
Point	SizeToPoint (Size size)
static std::optional< SamplerAddressMode >	TileModeToAddressMode (Entity::TileMode tile_mode, const Capabilities &capabilities)
std::optional< Rect >	ComputeSaveLayerCoverage (const Rect &content_coverage, const Matrix &effect_transform, const Rect &coverage_limit, const std::shared_ptr< FilterContents > &image_filter, bool flood_output_coverage=false, bool flood_input_coverage=false)
	Compute the coverage of a subpass in the global coordinate space. More...
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 Color	DoColorBlend (Color dst, Color src, const std::function< Vector3(Vector3, Vector3)> &blend_rgb_func)
static 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_StrokePath (benchmark::State &state, Args &&... args)
template<class... Args>
static void	BM_Convex (benchmark::State &state, Args &&... args)
	MAKE_STROKE_BENCHMARK_CAPTURE_ALL_CAPS_JOINS (Cubic, false)
	MAKE_STROKE_BENCHMARK_CAPTURE_ALL_CAPS_JOINS (Quadratic, false)
	BENCHMARK_CAPTURE (BM_Convex, rrect_convex, CreateRRect(), true)
	MAKE_STROKE_PATH_BENCHMARK_CAPTURE (RRect, Butt, Bevel,)
	MAKE_STROKE_PATH_BENCHMARK_CAPTURE (RRect, Butt, Miter,)
	MAKE_STROKE_PATH_BENCHMARK_CAPTURE (RRect, Butt, Round,)
	BENCHMARK_CAPTURE (BM_Convex, rse_convex, CreateRSuperellipse(), true)
	MAKE_STROKE_PATH_BENCHMARK_CAPTURE (RSuperellipse, Butt, Bevel,)
	MAKE_STROKE_PATH_BENCHMARK_CAPTURE (RSuperellipse, Butt, Miter,)
	MAKE_STROKE_PATH_BENCHMARK_CAPTURE (RSuperellipse, Butt, Round,)
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...
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 >
constexpr TPoint< T >	operator- (const TPoint< T > &p, T v)
	TEST (RationalTest, Make)
	TEST (RationalTest, EqualsSameDen)
	TEST (RationalTest, NotEqualsSameDen)
	TEST (RationalTest, EqualsDifferentDen)
	TEST (RationalTest, NegationNotEquals)
	TEST (RationalTest, LessThanSameDen)
	TEST (RationalTest, LessThanNegation)
	TEST (RationalTest, LessThanDifferentDen)
	TEST (RationalTest, NotLessThanDifferentDen)
	TEST (RationalTest, SameHashes)
	TEST (RationalTest, DifferentHashes)
static bool	CornerContains (const Point &p, const Point &corner, const Point &direction, const Size &radii)
static constexpr Point	kUpperLeftDirection (-1.0f, -1.0f)
static constexpr Point	kUpperRightDirection (1.0f, -1.0f)
static constexpr Point	kLowerLeftDirection (-1.0f, 1.0f)
static constexpr Point	kLowerRightDirection (1.0f, 1.0f)
static void	NormalizeEmptyToZero (Size &radii)
static void	AdjustScale (Scalar &radius1, Scalar &radius2, Scalar dimension, Scalar &scale)
template<class T , class = std::enable_if_t<std::is_arithmetic_v<T>>>
constexpr T	Absolute (const T &val)
template<>
constexpr Scalar	Absolute< Scalar > (const float &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)
Scalar	ComputeCubicSubdivisions (Scalar scale_factor, Point p0, Point p1, Point p2, Point p3)
Scalar	ComputeQuadradicSubdivisions (Scalar scale_factor, Point p0, Point p1, Point p2)
Scalar	ComputeConicSubdivisions (Scalar scale_factor, Point p0, Point p1, Point p2, Scalar w)
	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 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, std::string_view 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)
template<class Type >
void	BuildGLArgumentsStream (std::stringstream &stream, Type arg)
constexpr void	BuildGLArgumentsStream (std::stringstream &stream)
template<class Type , class... Rest>
void	BuildGLArgumentsStream (std::stringstream &stream, Type arg, Rest... other_args)
template<class... Type>
std::string	BuildGLArguments (Type... args)
void()	glClearDepthf (GLfloat depth)
void()	glDepthRangef (GLfloat n, GLfloat f)
void()	glClearDepth (GLdouble depth)
void()	glDepthRange (GLdouble n, GLdouble f)
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)
static bool	BindVertexBuffer (const ProcTableGLES &gl, BufferBindingsGLES *vertex_desc_gles, const BufferView &vertex_buffer_view, size_t buffer_index)
bool	EncodeCommandsInReactor (const RenderPassData &pass_data, const ReactorGLES &reactor, const std::vector< Command > &commands, const std::vector< BufferView > &vertex_buffers, const std::vector< TextureAndSampler > &bound_textures, const std::vector< BufferResource > &bound_buffers, const std::shared_ptr< GPUTracerGLES > &tracer)
static GLint	ToParam (MinMagFilter minmag_filter)
static GLint	ToParam (MinMagFilter minmag_filter, MipFilter mip_filter)
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)
HandleType	ToHandleType (TextureGLES::Type type)
static std::optional< GLenum >	ToRenderBufferFormat (PixelFormat format)
static GLenum	ToAttachmentType (TextureGLES::AttachmentType point)
ISize	DeviceMaxTextureSizeSupported (id< MTLDevice > device)
static bool	DeviceSupportsDeviceTransientTargets (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 bool	DeviceSupportsExtendedRangeFormats (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)
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, raw_ptr< const Sampler > sampler, const Texture &texture)
static MTLFunctionType	ToMTLFunctionType (ShaderStage stage)
static std::optional< RenderTarget >	WrapTextureWithRenderTarget (const std::shared_ptr< SwapchainTransientsMTL > &transients, 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 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 (OptionalAndroidDeviceExtensionVK 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< uint64_t, std::unordered_map< std::thread::id, 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 vk::DebugUtilsLabelEXT *labels, size_t count)
static std::string	JoinVKDebugUtilsObjectNameInfoEXT (const vk::DebugUtilsObjectNameInfoEXT *names, size_t count)
AdrenoGPU	GetAdrenoVersion (std::string_view version)
PowerVRGPU	GetPowerVRVersion (std::string_view version)
MaliGPU	GetMaliVersion (std::string_view version)
constexpr VendorVK	IdentifyVendor (uint32_t vendor)
constexpr const char *	VendorToString (VendorVK vendor)
constexpr const char *	DeviceTypeToString (DeviceTypeVK type)
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 std::optional< PixelFormat >	VkFormatToImpellerFormat (vk::Format format)
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 bool	PrimitiveTopologySupportsPrimitiveRestart (PrimitiveType primitive)
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)
bool	PipelineCacheDataPersist (const fml::UniqueFD &cache_directory, const VkPhysicalDeviceProperties &props, const vk::UniquePipelineCache &cache)
	Persist the pipeline cache to a file in the given cache directory. This function performs integrity checks the Vulkan driver may have missed. More...
std::unique_ptr< fml::Mapping >	PipelineCacheDataRetrieve (const fml::UniqueFD &cache_directory, const VkPhysicalDeviceProperties &props)
	Retrieve the previously persisted pipeline cache data. This function provides integrity checks the Vulkan driver may have missed. More...
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 size_t	GetVKClearValues (const RenderTarget &target, std::array< vk::ClearValue, kMaxAttachments > &values)
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)
constexpr PixelFormat	ToPixelFormat (android::HardwareBufferFormat format)
static TextureDescriptor	ToSwapchainTextureDescriptor (const android::HardwareBufferDescriptor &ahb_desc)
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)
WorkaroundsVK	GetWorkaroundsFromDriverInfo (DriverInfoVK &driver_info)
PipelineFuture< PipelineDescriptor >	CreatePipelineFuture (const Context &context, std::optional< PipelineDescriptor > desc, bool async=true)
	Create a pipeline for the given descriptor. More...
PipelineFuture< ComputePipelineDescriptor >	CreatePipelineFuture (const Context &context, std::optional< ComputePipelineDescriptor > desc)
std::shared_ptr< Texture >	CreateTexture (const TextureDescriptor &texture_descriptor, const std::vector< uint8_t > &data, const std::shared_ptr< impeller::Context > &context, std::string_view debug_label)
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...
template<class VertexType , size_t size>
VertexBuffer	CreateVertexBuffer (std::array< VertexType, size > input, HostBuffer &host_buffer)
	Create an index-less vertex buffer from a fixed size array. More...
static RuntimeUniformType	ToType (fb::UniformDataType type)
static RuntimeShaderStage	ToShaderStage (fb::Stage stage)
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)
	IMPELLER_ENUM_IS_MASK (android::HardwareBufferUsageFlags)
static Font	ToFont (const SkTextBlobRunIterator &run, AxisAlignment alignment)
static Rect	ToRect (const SkRect &rect)
std::shared_ptr< TextFrame >	MakeTextFrameFromTextBlobSkia (const sk_sp< SkTextBlob > &blob)
static SkImageInfo	GetImageInfo (const GlyphAtlas &atlas, Size size)
static size_t	AppendToExistingAtlas (const std::shared_ptr< GlyphAtlas > &atlas, const std::vector< FontGlyphPair > &extra_pairs, std::vector< Rect > &glyph_positions, const std::vector< Rect > &glyph_sizes, ISize atlas_size, int64_t height_adjustment, const std::shared_ptr< RectanglePacker > &rect_packer)
static size_t	PairsFitInAtlasOfSize (const std::vector< FontGlyphPair > &pairs, const ISize &atlas_size, std::vector< Rect > &glyph_positions, const std::vector< Rect > &glyph_sizes, int64_t height_adjustment, const std::shared_ptr< RectanglePacker > &rect_packer, size_t start_index)
static ISize	ComputeNextAtlasSize (const std::shared_ptr< GlyphAtlasContext > &atlas_context, const std::vector< FontGlyphPair > &extra_pairs, std::vector< Rect > &glyph_positions, const std::vector< Rect > &glyph_sizes, size_t glyph_index_start, int64_t max_texture_height)
static Point	SubpixelPositionToPoint (SubpixelPosition pos)
static void	DrawGlyph (SkCanvas *canvas, const SkPoint position, const ScaledFont &scaled_font, const SubpixelGlyph &glyph, const Rect &scaled_bounds, const std::optional< GlyphProperties > &prop, bool has_color)
static bool	BulkUpdateAtlasBitmap (const GlyphAtlas &atlas, std::shared_ptr< BlitPass > &blit_pass, HostBuffer &host_buffer, const std::shared_ptr< Texture > &texture, const std::vector< FontGlyphPair > &new_pairs, size_t start_index, size_t end_index)
	Batch render to a single surface. More...
static bool	UpdateAtlasBitmap (const GlyphAtlas &atlas, std::shared_ptr< BlitPass > &blit_pass, HostBuffer &host_buffer, const std::shared_ptr< Texture > &texture, const std::vector< FontGlyphPair > &new_pairs, size_t start_index, size_t end_index)
static Rect	ComputeGlyphSize (const SkFont &font, const SubpixelGlyph &glyph, Scalar scale)
static constexpr SubpixelPosition	ComputeFractionalPosition (Scalar value)

Variables
static std::atomic_size_t	sLastID
static std::atomic_int32_t	sValidationLogsDisabledCount = 0
static std::atomic_int32_t	sValidationLogsAreFatal = 0
static ValidationFailureCallback	sValidationFailureCallback
constexpr size_t	kAllocatorBlockSize = 1024000
static constexpr const size_t	kHostBufferArenaSize = 4u
	Approximately the same size as the max frames in flight. More...
constexpr size_t	kMaxVertexBuffers = 16
static constexpr Scalar	kMaxTextScale = 250
static constexpr const ColorMatrix	kColorInversion
	A color matrix which inverts colors. More...
constexpr std::array< std::array< Scalar, 5 >, 15 >	kPorterDuffCoefficients
static constexpr int32_t	kGaussianBlurMaxKernelSize = 50
constexpr Matrix	kMatrixBT601LimitedRange
constexpr Matrix	kMatrixBT601FullRange
static constexpr uint32_t	kMaxUniformGradientStops = 256u
static Scalar	kTwoOverSqrtPi = 2.0 / std::sqrt(kPi)
static constexpr int32_t	kMaxSigmaDenominator = 10
static constexpr Scalar	kMinStrokeSize = 1.0f
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	kSqrt2Over2 = 0.70710678118654752440f
constexpr float	kPhi = 1.61803398874989484820f
constexpr float	kEhCloseEnough = 1e-3f
static TessellatorLibtess	tess
static constexpr impeller::Vector2	kQuadrantAxes [4]
constexpr static float	kKernelRadiusPerSigma = 1.73205080757f
static const std::vector< std::string >	kSkipTests
static std::atomic_bool	gShouldOpenNewPlaygrounds = true
static constexpr std::string_view	kAngleInputAttachmentPrefix
static constexpr const char *	kFramebufferFetchExt
static constexpr const char *	kTextureBorderClampExt
static constexpr const char *	kNvidiaTextureBorderClampExt
static constexpr const char *	kMultisampledRenderToTextureExt
static constexpr const char *	kMultisampledRenderToTexture2Ext
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 constexpr const DescriptorPoolSize	kDefaultBindingSize
	Descriptor pools are always allocated with the following sizes. More...
const std::unordered_map< std::string_view, AdrenoGPU >	kAdrenoVersions
const std::unordered_map< std::string_view, MaliGPU >	kMaliVersions
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	kMaxColorAttachments = 16
static constexpr size_t	kMaxAttachments
static constexpr size_t	kMagicSubpassInputBinding = 64u
static constexpr const size_t	kMaxPendingPresents = 2u
static constexpr size_t	kMaxFramesInFlight = 2u
static constexpr size_t	kPointArenaSize = 4096u
	The size of the point arena buffer stored on the tessellator. More...
static const TESSalloc	kAlloc
constexpr auto	kPadding = 2
static const std::shared_ptr< GlyphAtlas >	kNullGlyphAtlas = nullptr

Typedef Documentation

AdvancedBlendPipelineHandle

using impeller::AdvancedBlendPipelineHandle = typedef RenderPipelineHandle<AdvancedBlendVertexShader, AdvancedBlendFragmentShader>

Definition at line 77 of file pipelines.h.

ArcVertexGenerator

using impeller::ArcVertexGenerator = typedef Tessellator::ArcVertexGenerator

Definition at line 439 of file tessellator.cc.

BlendColorBurnPipeline

using impeller::BlendColorBurnPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 86 of file pipelines.h.

BlendColorDodgePipeline

using impeller::BlendColorDodgePipeline = typedef AdvancedBlendPipelineHandle

Definition at line 87 of file pipelines.h.

BlendColorPipeline

using impeller::BlendColorPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 88 of file pipelines.h.

BlendDarkenPipeline

using impeller::BlendDarkenPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 89 of file pipelines.h.

BlendDifferencePipeline

using impeller::BlendDifferencePipeline = typedef AdvancedBlendPipelineHandle

Definition at line 90 of file pipelines.h.

BlendExclusionPipeline

using impeller::BlendExclusionPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 91 of file pipelines.h.

BlendHardLightPipeline

using impeller::BlendHardLightPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 92 of file pipelines.h.

BlendHuePipeline

using impeller::BlendHuePipeline = typedef AdvancedBlendPipelineHandle

Definition at line 93 of file pipelines.h.

BlendLightenPipeline

using impeller::BlendLightenPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 94 of file pipelines.h.

BlendLuminosityPipeline

using impeller::BlendLuminosityPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 95 of file pipelines.h.

BlendMultiplyPipeline

using impeller::BlendMultiplyPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 96 of file pipelines.h.

BlendOverlayPipeline

using impeller::BlendOverlayPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 97 of file pipelines.h.

BlendSaturationPipeline

using impeller::BlendSaturationPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 98 of file pipelines.h.

BlendScreenPipeline

using impeller::BlendScreenPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 99 of file pipelines.h.

BlendSoftLightPipeline

using impeller::BlendSoftLightPipeline = typedef AdvancedBlendPipelineHandle

Definition at line 100 of file pipelines.h.

BorderMaskBlurPipeline

using impeller::BorderMaskBlurPipeline = typedef RenderPipelineHandle<FilterPositionUvVertexShader, BorderMaskBlurFragmentShader>

Definition at line 101 of file pipelines.h.

BufferResource

using impeller::BufferResource = typedef Resource<BufferView>

Definition at line 54 of file command.h.

Bytes

using impeller::Bytes = typedef AllocationSize<1u>

Definition at line 151 of file allocation_size.h.

Callback

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

Definition at line 30 of file pipeline_library_mtl.mm.

ClipPipeline

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

Definition at line 102 of file pipelines.h.

Clock

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

Definition at line 14 of file timing.h.

ColorFilterProc

using impeller::ColorFilterProc = typedef std::function<Color(Color)>

A procedure that filters a given unpremultiplied color to produce a new unpremultiplied color.

Definition at line 36 of file color_filter.h.

ColorMatrixColorFilterPipeline

using impeller::ColorMatrixColorFilterPipeline = typedef RenderPipelineHandle<FilterPositionUvVertexShader, ColorMatrixColorFilterFragmentShader>

Definition at line 103 of file pipelines.h.

ColorWriteMask

using impeller::ColorWriteMask = typedef Mask<ColorWriteMaskBits>

Definition at line 464 of file formats.h.

CommandPoolMap

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

Definition at line 157 of file command_pool_vk.cc.

ComputePipelineMap

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

Definition at line 24 of file pipeline_library.h.

ConicalGradientFillConicalPipeline

using impeller::ConicalGradientFillConicalPipeline = typedef GradientPipelineHandle<ConicalGradientFillConicalFragmentShader>

Definition at line 104 of file pipelines.h.

ConicalGradientFillRadialPipeline

using impeller::ConicalGradientFillRadialPipeline = typedef GradientPipelineHandle<ConicalGradientFillRadialFragmentShader>

Definition at line 105 of file pipelines.h.

ConicalGradientFillStripPipeline

using impeller::ConicalGradientFillStripPipeline = typedef GradientPipelineHandle<ConicalGradientFillStripFragmentShader>

Definition at line 106 of file pipelines.h.

ConicalGradientFillStripRadialPipeline

using impeller::ConicalGradientFillStripRadialPipeline = typedef GradientPipelineHandle<ConicalGradientFillStripRadialFragmentShader>

Definition at line 107 of file pipelines.h.

ConicalGradientSSBOFillPipeline

using impeller::ConicalGradientSSBOFillPipeline = typedef GradientPipelineHandle<ConicalGradientSsboFillFragmentShader>

Definition at line 108 of file pipelines.h.

ConicalGradientUniformFillConicalPipeline

using impeller::ConicalGradientUniformFillConicalPipeline = typedef GradientPipelineHandle<ConicalGradientUniformFillConicalFragmentShader>

Definition at line 109 of file pipelines.h.

ConicalGradientUniformFillRadialPipeline

using impeller::ConicalGradientUniformFillRadialPipeline = typedef GradientPipelineHandle<ConicalGradientUniformFillRadialFragmentShader>

Definition at line 110 of file pipelines.h.

ConicalGradientUniformFillStripPipeline

using impeller::ConicalGradientUniformFillStripPipeline = typedef GradientPipelineHandle<ConicalGradientUniformFillStripFragmentShader>

Definition at line 111 of file pipelines.h.

ConicalGradientUniformFillStripRadialPipeline

using impeller::ConicalGradientUniformFillStripRadialPipeline = typedef GradientPipelineHandle<ConicalGradientUniformFillStripRadialFragmentShader>

Definition at line 112 of file pipelines.h.

CreateTransactionCB

typedef std::function< android::SurfaceTransaction()> impeller::CreateTransactionCB

Definition at line 24 of file ahb_swapchain_impl_vk.h.

CTessellator

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

Definition at line 19 of file tessellator_libtess.h.

DescriptorCacheMap

using impeller::DescriptorCacheMap = typedef std::unordered_map<PipelineKey, DescriptorCache>

Definition at line 23 of file descriptor_pool_vk.h.

DlIRect

typedef flutter::DlIRect impeller::DlIRect

Definition at line 26 of file dl_dispatcher.h.

DlPath

typedef flutter::DlPath impeller::DlPath

Definition at line 29 of file dl_dispatcher.h.

DlPoint

typedef flutter::DlPoint impeller::DlPoint

Definition at line 24 of file dl_dispatcher.h.

DlRect

typedef flutter::DlRect impeller::DlRect

Definition at line 25 of file dl_dispatcher.h.

DlRoundRect

using impeller::DlRoundRect = typedef flutter::DlRoundRect

Definition at line 27 of file dl_dispatcher.h.

DlRoundSuperellipse

using impeller::DlRoundSuperellipse = typedef flutter::DlRoundSuperellipse

Definition at line 28 of file dl_dispatcher.h.

DlScalar

typedef flutter::DlScalar impeller::DlScalar

Definition at line 23 of file dl_dispatcher.h.

EllipticalVertexGenerator

using impeller::EllipticalVertexGenerator = typedef Tessellator::EllipticalVertexGenerator

Definition at line 438 of file tessellator.cc.

FastGradientPipeline

using impeller::FastGradientPipeline = typedef RenderPipelineHandle<FastGradientVertexShader, FastGradientFragmentShader>

Definition at line 113 of file pipelines.h.

FramebufferBlendColorBurnPipeline

using impeller::FramebufferBlendColorBurnPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 114 of file pipelines.h.

FramebufferBlendColorDodgePipeline

using impeller::FramebufferBlendColorDodgePipeline = typedef FramebufferBlendPipelineHandle

Definition at line 115 of file pipelines.h.

FramebufferBlendColorPipeline

using impeller::FramebufferBlendColorPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 116 of file pipelines.h.

FramebufferBlendDarkenPipeline

using impeller::FramebufferBlendDarkenPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 117 of file pipelines.h.

FramebufferBlendDifferencePipeline

using impeller::FramebufferBlendDifferencePipeline = typedef FramebufferBlendPipelineHandle

Definition at line 118 of file pipelines.h.

FramebufferBlendExclusionPipeline

using impeller::FramebufferBlendExclusionPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 119 of file pipelines.h.

FramebufferBlendHardLightPipeline

using impeller::FramebufferBlendHardLightPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 120 of file pipelines.h.

FramebufferBlendHuePipeline

using impeller::FramebufferBlendHuePipeline = typedef FramebufferBlendPipelineHandle

Definition at line 121 of file pipelines.h.

FramebufferBlendLightenPipeline

using impeller::FramebufferBlendLightenPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 122 of file pipelines.h.

FramebufferBlendLuminosityPipeline

using impeller::FramebufferBlendLuminosityPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 123 of file pipelines.h.

FramebufferBlendMultiplyPipeline

using impeller::FramebufferBlendMultiplyPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 124 of file pipelines.h.

FramebufferBlendOverlayPipeline

using impeller::FramebufferBlendOverlayPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 125 of file pipelines.h.

FramebufferBlendPipelineHandle

using impeller::FramebufferBlendPipelineHandle = typedef RenderPipelineHandle<FramebufferBlendVertexShader, FramebufferBlendFragmentShader>

Definition at line 81 of file pipelines.h.

FramebufferBlendSaturationPipeline

using impeller::FramebufferBlendSaturationPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 126 of file pipelines.h.

FramebufferBlendScreenPipeline

using impeller::FramebufferBlendScreenPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 127 of file pipelines.h.

FramebufferBlendSoftLightPipeline

using impeller::FramebufferBlendSoftLightPipeline = typedef FramebufferBlendPipelineHandle

Definition at line 128 of file pipelines.h.

FS

typedef GlyphAtlasPipeline::FragmentShader impeller::FS

Definition at line 14 of file line_contents.cc.

GaussianBlurFragmentShader

using impeller::GaussianBlurFragmentShader = typedef GaussianBlurPipeline::FragmentShader

Definition at line 23 of file gaussian_blur_filter_contents.cc.

GaussianBlurPipeline

using impeller::GaussianBlurPipeline = typedef RenderPipelineHandle<FilterPositionUvVertexShader, GaussianFragmentShader>

Definition at line 129 of file pipelines.h.

GaussianBlurVertexShader

using impeller::GaussianBlurVertexShader = typedef GaussianBlurPipeline::VertexShader

Definition at line 22 of file gaussian_blur_filter_contents.cc.

GibiBytes

using impeller::GibiBytes = typedef AllocationSize<1'024u * 1'024u * 1'024u>

Definition at line 159 of file allocation_size.h.

GigaBytes

using impeller::GigaBytes = typedef AllocationSize<1'000u * 1'000u * 1'000u>

Definition at line 155 of file allocation_size.h.

GlyphAtlasPipeline

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

Definition at line 130 of file pipelines.h.

GradientPipelineHandle

template<typename T >

using impeller::GradientPipelineHandle = typedef RenderPipelineHandle<GradientFillVertexShader, T>

Definition at line 74 of file pipelines.h.

IPoint

using impeller::IPoint = typedef TPoint<int64_t>

Definition at line 328 of file point.h.

IPoint32

using impeller::IPoint32 = typedef TPoint<int32_t>

Definition at line 329 of file point.h.

IRect

using impeller::IRect = typedef IRect64

Definition at line 795 of file rect.h.

IRect32

using impeller::IRect32 = typedef TRect<int32_t>

Definition at line 793 of file rect.h.

IRect64

using impeller::IRect64 = typedef TRect<int64_t>

Definition at line 794 of file rect.h.

ISize

using impeller::ISize = typedef ISize64

Definition at line 162 of file size.h.

ISize32

using impeller::ISize32 = typedef TSize<int32_t>

Definition at line 160 of file size.h.

ISize64

using impeller::ISize64 = typedef TSize<int64_t>

Definition at line 161 of file size.h.

KibiBytes

using impeller::KibiBytes = typedef AllocationSize<1'024u>

Definition at line 157 of file allocation_size.h.

KiloBytes

using impeller::KiloBytes = typedef AllocationSize<1'000u>

Definition at line 153 of file allocation_size.h.

LinearGradientFillPipeline

using impeller::LinearGradientFillPipeline = typedef GradientPipelineHandle<LinearGradientFillFragmentShader>

Definition at line 132 of file pipelines.h.

LinearGradientSSBOFillPipeline

using impeller::LinearGradientSSBOFillPipeline = typedef GradientPipelineHandle<LinearGradientSsboFillFragmentShader>

Definition at line 133 of file pipelines.h.

LinearGradientUniformFillPipeline

using impeller::LinearGradientUniformFillPipeline = typedef GradientPipelineHandle<LinearGradientUniformFillFragmentShader>

Definition at line 134 of file pipelines.h.

LinearToSrgbFilterPipeline

using impeller::LinearToSrgbFilterPipeline = typedef RenderPipelineHandle<FilterPositionVertexShader, LinearToSrgbFilterFragmentShader>

Definition at line 135 of file pipelines.h.

LinePipeline

using impeller::LinePipeline = typedef RenderPipelineHandle<LineVertexShader, LineFragmentShader>

Definition at line 131 of file pipelines.h.

MebiBytes

using impeller::MebiBytes = typedef AllocationSize<1'024u * 1'024u>

Definition at line 158 of file allocation_size.h.

MegaBytes

using impeller::MegaBytes = typedef AllocationSize<1'000u * 1'000u>

Definition at line 154 of file allocation_size.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 RenderPipelineHandle<FilterPositionUvVertexShader, MorphologyFilterFragmentShader>

Definition at line 136 of file pipelines.h.

MyMask

using impeller::MyMask = typedef Mask<MyMaskBits>

Definition at line 20 of file base_unittests.cc.

PathBuilder

using impeller::PathBuilder = typedef flutter::DlPathBuilder

Definition at line 22 of file tessellator.h.

PathCreator

using impeller::PathCreator = typedef std::function<fml::StatusOr<flutter::DlPath>()>

Definition at line 19 of file text_frame.h.

PipelineKey

using impeller::PipelineKey = typedef int64_t

Definition at line 21 of file pipeline.h.

PipelineMap

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

Definition at line 19 of file pipeline_library.h.

PipelineProc

using impeller::PipelineProc = typedef PipelineRef (ContentContext::*)(ContentContextOptions) const

Definition at line 92 of file blend_filter_contents.cc.

PipelineRef

using impeller::PipelineRef = typedef raw_ptr<Pipeline<PipelineDescriptor> >

A raw ptr to a pipeline object.

These pipeline refs are safe to use as the context will keep the pipelines alive throughout rendering.

Definition at line 88 of file pipeline.h.

Point

using impeller::Point = typedef TPoint<Scalar>

Definition at line 327 of file point.h.

PorterDuffBlendPipeline

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

Definition at line 137 of file pipelines.h.

Quad

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

Definition at line 332 of file point.h.

RadialGradientFillPipeline

using impeller::RadialGradientFillPipeline = typedef GradientPipelineHandle<RadialGradientFillFragmentShader>

Definition at line 138 of file pipelines.h.

RadialGradientSSBOFillPipeline

using impeller::RadialGradientSSBOFillPipeline = typedef GradientPipelineHandle<RadialGradientSsboFillFragmentShader>

Definition at line 139 of file pipelines.h.

RadialGradientUniformFillPipeline

using impeller::RadialGradientUniformFillPipeline = typedef GradientPipelineHandle<RadialGradientUniformFillFragmentShader>

Definition at line 140 of file pipelines.h.

Rect

using impeller::Rect = typedef TRect<Scalar>

Definition at line 792 of file rect.h.

RRectBlurPipeline

using impeller::RRectBlurPipeline = typedef RenderPipelineHandle<RrectLikeBlurVertexShader, RrectBlurFragmentShader>

Definition at line 141 of file pipelines.h.

RSuperellipseBlurPipeline

using impeller::RSuperellipseBlurPipeline = typedef RenderPipelineHandle<RrectLikeBlurVertexShader, RsuperellipseBlurFragmentShader>

Definition at line 142 of file pipelines.h.

Scalar

using impeller::Scalar = typedef float

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

SharedHandleVK

template<class T >

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

Definition at line 53 of file shared_object_vk.h.

Size

using impeller::Size = typedef TSize<Scalar>

Definition at line 159 of file size.h.

SolidFillPipeline

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

Definition at line 143 of file pipelines.h.

SrgbToLinearFilterPipeline

using impeller::SrgbToLinearFilterPipeline = typedef RenderPipelineHandle<FilterPositionVertexShader, SrgbToLinearFilterFragmentShader>

Definition at line 144 of file pipelines.h.

SweepGradientFillPipeline

using impeller::SweepGradientFillPipeline = typedef GradientPipelineHandle<SweepGradientFillFragmentShader>

Definition at line 145 of file pipelines.h.

SweepGradientSSBOFillPipeline

using impeller::SweepGradientSSBOFillPipeline = typedef GradientPipelineHandle<SweepGradientSsboFillFragmentShader>

Definition at line 146 of file pipelines.h.

SweepGradientUniformFillPipeline

using impeller::SweepGradientUniformFillPipeline = typedef GradientPipelineHandle<SweepGradientUniformFillFragmentShader>

Definition at line 147 of file pipelines.h.

TessellatedVertexProc

using impeller::TessellatedVertexProc = typedef Tessellator::TessellatedVertexProc

Definition at line 437 of file tessellator.cc.

TextureDownsamplePipeline

using impeller::TextureDownsamplePipeline = typedef RenderPipelineHandle<TextureFillVertexShader, TextureDownsampleFragmentShader>

Definition at line 148 of file pipelines.h.

TexturePipeline

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

Definition at line 149 of file pipelines.h.

TextureResource

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

Definition at line 55 of file command.h.

TextureStrictSrcPipeline

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

Definition at line 150 of file pipelines.h.

TextureUsageMask

using impeller::TextureUsageMask = typedef Mask<TextureUsage>

Definition at line 308 of file formats.h.

TiledTexturePipeline

using impeller::TiledTexturePipeline = typedef RenderPipelineHandle<TextureUvFillVertexShader, TiledTextureFillFragmentShader>

Definition at line 151 of file pipelines.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 330 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 41 of file image.h.

UniqueEGLImageKHR

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

Definition at line 72 of file image.h.

UniqueGLTexture

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

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

ValidationFailureCallback

using impeller::ValidationFailureCallback = typedef std::function<bool(const char* message, const char* file, int line)>

Definition at line 41 of file validation.h.

Vector2

using impeller::Vector2 = typedef Point

Definition at line 331 of file point.h.

VerticesUber1Shader

using impeller::VerticesUber1Shader = typedef RenderPipelineHandle<PorterDuffBlendVertexShader, VerticesUber1FragmentShader>

Definition at line 152 of file pipelines.h.

VerticesUber2Shader

using impeller::VerticesUber2Shader = typedef RenderPipelineHandle<PorterDuffBlendVertexShader, VerticesUber2FragmentShader>

Definition at line 153 of file pipelines.h.

VS

typedef GlyphAtlasPipeline::VertexShader impeller::VS

Definition at line 13 of file line_contents.cc.

WaitSet

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

Definition at line 21 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 23 of file yuv_conversion_vk.h.

YUVToRGBFilterPipeline

using impeller::YUVToRGBFilterPipeline = typedef RenderPipelineHandle<FilterPositionVertexShader, YuvToRgbFilterFragmentShader>

Definition at line 154 of file pipelines.h.

Enumeration Type Documentation

AdrenoGPU

enum impeller::AdrenoGPU

strong

Enumerator
kAdreno504
kAdreno505
kAdreno506
kAdreno508
kAdreno509
kAdreno510
kAdreno512
kAdreno530
kAdreno540
kAdreno605
kAdreno608
kAdreno610
kAdreno612
kAdreno613
kAdreno615
kAdreno616
kAdreno618
kAdreno619L
kAdreno619
kAdreno620
kAdreno630
kAdreno640
kAdreno642L
kAdreno642
kAdreno643L
kAdreno644
kAdreno650
kAdreno660
kAdreno663
kAdreno675
kAdreno680
kAdreno685
kAdreno690
kAdreno695
kAdreno702
kAdreno710
kAdreno720
kAdreno725
kAdreno730
kAdreno732
kAdreno735
kAdreno740
kAdreno750
kAdrenoX145
kAdrenoX185
kUnknown

Definition at line 14 of file driver_info_vk.h.

                     {
  // I don't think the 400 series will ever run Vulkan, but if some show up we
  // can add them here.
  // 500s
  kAdreno504,
  kAdreno505,
  kAdreno506,
  kAdreno508,
  kAdreno509,
  kAdreno510,
  kAdreno512,
  kAdreno530,
  kAdreno540,
  // 600s
  kAdreno605,
  kAdreno608,
  kAdreno610,
  kAdreno612,
  kAdreno613,
  kAdreno615,
  kAdreno616,
  kAdreno618,
  kAdreno619L,
  kAdreno619,
  kAdreno620,
  kAdreno630,
  // The 640 is the first GPU inside an Android device with upgradable drivers.
  // Anything before this point exhibiting broken behavior is broken forever.
  kAdreno640,
  kAdreno642L,
  kAdreno642,
  kAdreno643L,
  kAdreno644,
  kAdreno650,
  kAdreno660,
  kAdreno663,
  kAdreno675,
  kAdreno680,
  kAdreno685,
  kAdreno690,
  kAdreno695,
  // 700s
  kAdreno702,
  kAdreno710,
  kAdreno720,
  kAdreno725,
  kAdreno730,
  kAdreno732,
  kAdreno735,
  kAdreno740,
  kAdreno750,
  // X
  kAdrenoX145,
  kAdrenoX185,
  // Unknown GPU, likely newer model.
  kUnknown,
};

ArchiveShaderType

enum impeller::ArchiveShaderType

strong

Enumerator
kVertex
kFragment
kCompute

Definition at line 10 of file shader_archive_types.h.

                             {
  kVertex,
  kFragment,
  kCompute,
};

AxisAlignment

enum impeller::AxisAlignment : uint8_t

strong

Determines the axis along which there is subpixel positioning.

Enumerator
kNone
kX
kY
kAll

Definition at line 20 of file font.h.

                         : uint8_t {
  // No subpixel positioning.
  kNone,
  // Subpixel positioning in the X axis only.
  kX,
  // Subpixel positioning in the Y axis only.
  kY,
  // No specific axis, subpixel positioning in each direction.
  kAll,
};

BlendFactor

enum impeller::BlendFactor

strong

Enumerator
kZero
kOne
kSourceColor
kOneMinusSourceColor
kSourceAlpha
kOneMinusSourceAlpha
kDestinationColor
kOneMinusDestinationColor
kDestinationAlpha
kOneMinusDestinationAlpha
kSourceAlphaSaturated
kBlendColor
kOneMinusBlendColor
kBlendAlpha
kOneMinusBlendAlpha

Definition at line 178 of file formats.h.

                       {
  kZero,
  kOne,
  kSourceColor,
  kOneMinusSourceColor,
  kSourceAlpha,
  kOneMinusSourceAlpha,
  kDestinationColor,
  kOneMinusDestinationColor,
  kDestinationAlpha,
  kOneMinusDestinationAlpha,
  kSourceAlphaSaturated,
  kBlendColor,
  kOneMinusBlendColor,
  kBlendAlpha,
  kOneMinusBlendAlpha,
};

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
kSrc
kDst
kSrcOver
kDstOver
kSrcIn
kDstIn
kSrcOut
kDstOut
kSrcATop
kDstATop
kXor
kPlus
kModulate
kScreen
kOverlay
kDarken
kLighten
kColorDodge
kColorBurn
kHardLight
kSoftLight
kDifference
kExclusion
kMultiply
kHue
kSaturation
kColor
kLuminosity
kLastMode
kDefaultMode

Definition at line 58 of file color.h.

                     : uint8_t {
  // The following blend modes are able to be used as pipeline blend modes or
  // via `BlendFilterContents`.
  kClear = 0,
  kSrc,
  kDst,
  kSrcOver,
  kDstOver,
  kSrcIn,
  kDstIn,
  kSrcOut,
  kDstOut,
  kSrcATop,
  kDstATop,
  kXor,
  kPlus,
  kModulate,
 
  // The following blend modes use equations that are not available for
  // pipelines on most graphics devices without extensions, and so they are
  // only able to be used via `BlendFilterContents`.
  kScreen,
  kOverlay,
  kDarken,
  kLighten,
  kColorDodge,
  kColorBurn,
  kHardLight,
  kSoftLight,
  kDifference,
  kExclusion,
  kMultiply,
  kHue,
  kSaturation,
  kColor,
  kLuminosity,
 
  kLastMode = kLuminosity,
  kDefaultMode = kSrcOver,
};

BlendOperation

enum impeller::BlendOperation

strong

Enumerator
kAdd
kSubtract
kReverseSubtract

Definition at line 196 of file formats.h.

                          {
  kAdd,
  kSubtract,
  kReverseSubtract,
};

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.

                             {
  kScreen = 0,
  kOverlay,
  kDarken,
  kLighten,
  kColorDodge,
  kColorBurn,
  kHardLight,
  kSoftLight,
  kDifference,
  kExclusion,
  kMultiply,
  kHue,
  kSaturation,
  kColor,
  kLuminosity,
};

Cap

enum impeller::Cap

strong

An enum that describes ways to decorate the end of a path contour.

Enumerator
kButt
kRound
kSquare

Definition at line 13 of file stroke_parameters.h.

               {
  kButt,
  kRound,
  kSquare,
};

ColorWriteMaskBits

enum impeller::ColorWriteMaskBits : uint64_t

strong

Enumerator
kNone
kRed
kGreen
kBlue
kAlpha
kAll

Definition at line 454 of file formats.h.

                              : uint64_t {
  kNone = 0,
  kRed = 1 << 0,
  kGreen = 1 << 1,
  kBlue = 1 << 2,
  kAlpha = 1 << 3,
  kAll = kRed | kGreen | kBlue | kAlpha,
};

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

                           : uint8_t {
  /// Comparison test never passes.
  kNever,
  /// Comparison test passes always passes.
  kAlways,
  /// Comparison test passes if new_value < current_value.
  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,
};

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

                           {
  kLossless,
  kLossy,
};

ConicalKind

enum impeller::ConicalKind

Enumerator
kConical
kRadial
kStrip
kStripAndRadial

Definition at line 128 of file content_context.h.

                 {
  kConical,
  kRadial,
  kStrip,
  kStripAndRadial,
};

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

                                {
  /// @brief The caller makes no claims related to the size of the bounds.
  kUnknown,
 
  /// @brief The caller claims the bounds are a reasonably tight estimate
  ///        of the coverage of the contents and should contain all of the
  ///        contents.
  kContainsContents,
 
  /// @brief The caller claims the bounds are a subset of an estimate of
  ///        the reasonably tight bounds but likely clips off some of the
  ///        contents.
  kMayClipContents,
};

Convexity

enum impeller::Convexity

strong

Enumerator
kUnknown
kConvex

Definition at line 18 of file path_source.h.

                     {
  kUnknown,
  kConvex,
};

CullMode

enum impeller::CullMode

strong

Enumerator
kNone
kFrontFace
kBackFace

Definition at line 337 of file formats.h.

                    {
  kNone,
  kFrontFace,
  kBackFace,
};

DebugResourceType

enum impeller::DebugResourceType

strong

Enumerator
kTexture
kBuffer
kProgram
kShader
kRenderBuffer
kFrameBuffer
kFence

Definition at line 272 of file proc_table_gles.h.

                             {
  kTexture,
  kBuffer,
  kProgram,
  kShader,
  kRenderBuffer,
  kFrameBuffer,
  kFence,
};

DescriptorType

enum impeller::DescriptorType

strong

Enumerator
kSampler
kSampledImage
kImage
kUniformBuffer
kStorageBuffer
kInputAttachment

Definition at line 158 of file shader_types.h.

                          {
  kSampler = 0,
  kSampledImage = 1,
  kImage = 2,
  kUniformBuffer = 6,
  kStorageBuffer = 7,
  kInputAttachment = 10,
};

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 156 of file driver_info_vk.h.

                        {
  kUnknown,
  //----------------------------------------------------------------------------
  /// The device is an integrated GPU. Typically mobile GPUs.
  ///
  kIntegratedGPU,
  //----------------------------------------------------------------------------
  /// The device is a discrete GPU. Typically desktop GPUs.
  ///
  kDiscreteGPU,
  //----------------------------------------------------------------------------
  /// The device is a GPU in a virtualized environment.
  ///
  kVirtualGPU,
  //----------------------------------------------------------------------------
  /// There is no GPU. Vulkan is implemented on the CPU. This is typically
  /// emulators like SwiftShader and LLVMPipe.
  ///
  kCPU,
};

FillType

enum impeller::FillType

strong

Enumerator
kNonZero
kOdd

Definition at line 13 of file path_source.h.

                    {
  kNonZero,  // The default winding order.
  kOdd,
};

FromBytesTag

enum impeller::FromBytesTag

strong

Enumerator
kFromBytes

Definition at line 15 of file allocation_size.h.

{ kFromBytes };

HandleType

enum impeller::HandleType

strong

Enumerator
kUnknown
kTexture
kBuffer
kProgram
kRenderBuffer
kFrameBuffer
kFence

Definition at line 18 of file handle_gles.h.

                      {
  kUnknown,
  kTexture,
  kBuffer,
  kProgram,
  kRenderBuffer,
  kFrameBuffer,
  kFence,
};

IndexType

enum impeller::IndexType

strong

Enumerator
kUnknown
k16bit
k32bit
kNone	Does not use the index buffer.

Definition at line 343 of file formats.h.

                     {
  kUnknown,
  k16bit,
  k32bit,
  /// Does not use the index buffer.
  kNone,
};

Join

enum impeller::Join

strong

An enum that describes ways to join two segments of a path.

Enumerator
kMiter
kRound
kBevel

Definition at line 20 of file stroke_parameters.h.

                {
  kMiter,
  kRound,
  kBevel,
};

LoadAction

enum impeller::LoadAction

strong

Enumerator
kDontCare
kLoad
kClear

Definition at line 202 of file formats.h.

                      {
  kDontCare,
  kLoad,
  kClear,
};

MaliGPU

enum impeller::MaliGPU

strong

Enumerator
kT760
kT820
kT830
kT860
kT880
kG31
kG51
kG71
kG52
kG72
kG76
kG57
kG77
kG68
kG78
kG310
kG510
kG610
kG710
kG615
kG715
kG620
kG720
kG625
kG725
kG925
kUnknown

Definition at line 73 of file driver_info_vk.h.

                   {
  // These might be Vulkan 1.0 Only.
  kT760,
  kT820,
  kT830,
  kT860,
  kT880,
 
  // Bifrost
  kG31,
  kG51,
  kG71,
  kG52,
  kG72,
  kG76,
 
  // Valhall
  // Note: there is an Immortalis-G715 a Mali-G715
  kG57,
  kG77,
  kG68,
  kG78,
  kG310,
  kG510,
  kG610,
  kG710,
  kG615,
  kG715,
 
  // 5th Gen
  kG620,
  kG720,
  kG625,
  kG725,
  kG925,
  kUnknown,
};

MinMagFilter

enum impeller::MinMagFilter : uint8_t

strong

Describes how the texture should be sampled when the texture is being shrunk (minified) or expanded (magnified) to fit to the sample point.

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

                        : uint8_t {
  /// Select nearest to the sample point. Most widely supported.
  kNearest,
 
  /// Select two points and linearly interpolate between them. Some formats
  /// may not support this.
  kLinear,
};

MipFilter

enum impeller::MipFilter : uint8_t

strong

Options for selecting and filtering between mipmap levels.

Enumerator
kBase	The texture is sampled as if it only had a single mipmap level. All samples are read from level 0.
kNearest	The nearst mipmap level is selected.
kLinear	Sample from the two nearest mip levels and linearly interpolate. If the filter falls between levels, both levels are sampled, and their results linearly interpolated between levels.

Definition at line 425 of file formats.h.

                     : uint8_t {
  /// @brief    The texture is sampled as if it only had a single mipmap level.
  ///
  ///           All samples are read from level 0.
  kBase,
 
  /// @brief    The nearst mipmap level is selected.
  kNearest,
 
  /// @brief    Sample from the two nearest mip levels and linearly interpolate.
  ///
  ///           If the filter falls between levels, both levels are sampled, and
  ///           their results linearly interpolated between levels.
  kLinear,
};

MyMaskBits

enum impeller::MyMaskBits : uint32_t

strong

Enumerator
kFoo
kBar
kBaz
kBang

Definition at line 13 of file base_unittests.cc.

                      : uint32_t {
  kFoo = 0,
  kBar = 1 << 0,
  kBaz = 1 << 1,
  kBang = 1 << 2,
};

OptionalAndroidDeviceExtensionVK

enum impeller::OptionalAndroidDeviceExtensionVK : uint32_t

strong

A device extension available on some Android platforms.

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

Enumerator
kKHRExternalFenceFd	For exporting file descriptors from fences to interact with platform APIs. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_fence_fd.html
kKHRExternalFence	Dependency of kKHRExternalFenceFd. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_fence.html
kKHRExternalSemaphoreFd	For importing sync file descriptors as semaphores so the GPU can wait for semaphore to be signaled. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_semaphore_fd.html
kKHRExternalSemaphore	Dependency of kKHRExternalSemaphoreFd https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_semaphore.html
kLast

Definition at line 93 of file capabilities_vk.h.

                                            : uint32_t {
  //----------------------------------------------------------------------------
  /// For exporting file descriptors from fences to interact with platform APIs.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_fence_fd.html
  ///
  kKHRExternalFenceFd,
 
  //----------------------------------------------------------------------------
  /// Dependency of kKHRExternalFenceFd.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_fence.html
  ///
  kKHRExternalFence,
 
  //----------------------------------------------------------------------------
  /// For importing sync file descriptors as semaphores so the GPU can wait for
  /// semaphore to be signaled.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_semaphore_fd.html
  kKHRExternalSemaphoreFd,
 
  //----------------------------------------------------------------------------
  /// Dependency of kKHRExternalSemaphoreFd
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_semaphore.html
  kKHRExternalSemaphore,
 
  kLast,
};

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
kEXTImageCompressionControl	For fixed-rate compression of images. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_image_compression_control.html
kLast

Definition at line 131 of file capabilities_vk.h.

                                     : uint32_t {
  //----------------------------------------------------------------------------
  /// To instrument and profile PSO creation.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_pipeline_creation_feedback.html
  ///
  kEXTPipelineCreationFeedback,
 
  //----------------------------------------------------------------------------
  /// 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
  ///
  kVKKHRPortabilitySubset,
 
  //----------------------------------------------------------------------------
  /// For fixed-rate compression of images.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_image_compression_control.html
  ///
  kEXTImageCompressionControl,
 
  kLast,
};

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

                       : uint8_t {
  kUnknown,
  kA8UNormInt,
  kR8UNormInt,
  kR8G8UNormInt,
  kR8G8B8A8UNormInt,
  kR8G8B8A8UNormIntSRGB,
  kB8G8R8A8UNormInt,
  kB8G8R8A8UNormIntSRGB,
  kR32G32B32A32Float,
  kR16G16B16A16Float,
  kB10G10R10XR,
  kB10G10R10XRSRGB,
  kB10G10R10A10XR,
  // Depth and stencil formats.
  kS8UInt,
  kD24UnormS8Uint,
  kD32FloatS8UInt,
};

PlaygroundBackend

enum impeller::PlaygroundBackend

strong

Enumerator
kMetal
kOpenGLES
kVulkan

Definition at line 27 of file playground.h.

                             {
  kMetal,
  kOpenGLES,
  kVulkan,
};

PointStyle

enum impeller::PointStyle

strong

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

Definition at line 65 of file canvas.h.

                      {
  /// @brief Points are drawn as squares.
  kRound,
 
  /// @brief Points are drawn as circles.
  kSquare,
};

PolygonMode

enum impeller::PolygonMode

strong

Enumerator
kFill
kLine

Definition at line 389 of file formats.h.

                       {
  kFill,
  kLine,
};

PowerVRGPU

enum impeller::PowerVRGPU

strong

Enumerator
kUnknown
kRogue
kAXE
kAXM
kAXT
kBXE
kBXM
kBXS
kBXT
kCXT
kDXT

Definition at line 114 of file driver_info_vk.h.

                      {
  kUnknown,
  // Not good.
  kRogue,
  // Vulkan may work, but not tested.
  kAXE,
  kAXM,
  kAXT,
  kBXE,
  kBXM,
  kBXS,
  kBXT,
  // First good vulkan drivers.
  kCXT,
  kDXT,
};

PrimitiveType

enum impeller::PrimitiveType : uint8_t

strong

Decides how backend draws pixels based on input vertices.

Enumerator
kTriangle	Draws a triangle for each separate set of three vertices. Vertices [A, B, C, D, E, F] will produce triangles [ABC, DEF].
kTriangleStrip	Draws a triangle for every adjacent three vertices. Vertices [A, B, C, D, E, F] will produce triangles [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.
kTriangleFan	Draws a triangle for every two vertices, after the first. The first vertex acts as the hub, all following vertices connect with this hub to "fan" out from the first vertex. Triangle fans are not supported in Metal and need a capability check.

Definition at line 352 of file formats.h.

                         : uint8_t {
  /// Draws a triangle for each separate set of three vertices.
  ///
  /// Vertices [A, B, C, D, E, F] will produce triangles
  /// [ABC, DEF].
  kTriangle,
 
  /// Draws a triangle for every adjacent three vertices.
  ///
  /// Vertices [A, B, C, D, E, F] will produce triangles
  /// [ABC, BCD, CDE, DEF].
  kTriangleStrip,
 
  /// Draws a line for each separate set of two vertices.
  ///
  /// Vertices [A, B, C] will produce discontinued line
  /// [AB, BC].
  kLine,
 
  /// Draws a continuous line that connect every input vertices
  ///
  /// Vertices [A, B, C] will produce one continuous line
  /// [ABC].
  kLineStrip,
 
  /// Draws a point at each input vertex.
  kPoint,
 
  /// Draws a triangle for every two vertices, after the first.
  ///
  /// The first vertex acts as the hub, all following vertices connect with
  /// this hub to "fan" out from the first vertex.
  ///
  /// Triangle fans are not supported in Metal and need a capability check.
  kTriangleFan,
};

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 48 of file capabilities_vk.h.

                                            : uint32_t {
  //----------------------------------------------------------------------------
  /// 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
  ///
  kANDROIDExternalMemoryAndroidHardwareBuffer,
 
  //----------------------------------------------------------------------------
  /// Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_sampler_ycbcr_conversion.html
  ///
  kKHRSamplerYcbcrConversion,
 
  //----------------------------------------------------------------------------
  /// Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_memory.html
  ///
  kKHRExternalMemory,
 
  //----------------------------------------------------------------------------
  /// Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_queue_family_foreign.html
  ///
  kEXTQueueFamilyForeign,
 
  //----------------------------------------------------------------------------
  /// Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_dedicated_allocation.html
  ///
  kKHRDedicatedAllocation,
 
  kLast,
};

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 29 of file capabilities_vk.h.

                                           : uint32_t {
  //----------------------------------------------------------------------------
  /// For displaying content in the window system.
  ///
  /// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html
  ///
  kKHRSwapchain,
 
  kLast,
};

RuntimeShaderStage

enum impeller::RuntimeShaderStage

strong

Enumerator
kVertex
kFragment
kCompute

Definition at line 30 of file runtime_types.h.

                              {
  kVertex,
  kFragment,
  kCompute,
};

RuntimeStageBackend

enum impeller::RuntimeStageBackend

strong

Enumerator
kSkSL
kMetal
kOpenGLES
kOpenGLES3
kVulkan

Definition at line 16 of file runtime_types.h.

                               {
  kSkSL,
  kMetal,
  kOpenGLES,
  kOpenGLES3,
  kVulkan,
};

RuntimeUniformType

enum impeller::RuntimeUniformType

Enumerator
kFloat
kSampledImage
kStruct

Definition at line 24 of file runtime_types.h.

                        {
  kFloat,
  kSampledImage,
  kStruct,
};

SampleCount

enum impeller::SampleCount : uint8_t

strong

Enumerator
kCount1
kCount4

Definition at line 295 of file formats.h.

                       : uint8_t {
  kCount1 = 1,
  kCount4 = 4,
};

SamplerAddressMode

enum impeller::SamplerAddressMode : uint8_t

strong

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

Definition at line 441 of file formats.h.

                              : uint8_t {
  kClampToEdge,
  kRepeat,
  kMirror,
  // More modes are almost always supported but they are usually behind
  // extensions checks. The ones current in these structs are safe (always
  // supported) defaults.
 
  /// @brief decal sampling mode is only supported on devices that pass
  ///        the `Capabilities.SupportsDecalSamplerAddressMode` check.
  kDecal,
};

ShaderStage

enum impeller::ShaderStage

strong

Enumerator
kUnknown
kVertex
kFragment
kCompute

Definition at line 22 of file shader_types.h.

                       {
  kUnknown,
  kVertex,
  kFragment,
  kCompute,
};

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.

                      {
  kUnknown,
  kVoid,
  kBoolean,
  kSignedByte,
  kUnsignedByte,
  kSignedShort,
  kUnsignedShort,
  kSignedInt,
  kUnsignedInt,
  kSignedInt64,
  kUnsignedInt64,
  kAtomicCounter,
  kHalfFloat,
  kFloat,
  kDouble,
  kStruct,
  kImage,
  kSampledImage,
  kSampler,
};

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

                                {
  /// @brief Faster, but may sample outside the bounds of the source rectangle.
  kFast,
 
  /// @brief Sample only within the source rectangle. May be slower.
  kStrict,
};

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

                            : uint8_t {
  /// Don't modify the current stencil value.
  kKeep,
  /// Reset the stencil value to zero.
  kZero,
  /// Reset the stencil value to the reference value.
  kSetToReferenceValue,
  /// Increment the current stencil value by 1. Clamp it to the maximum.
  kIncrementClamp,
  /// Decrement the current stencil value by 1. Clamp it to zero.
  kDecrementClamp,
  /// Perform a logical bitwise invert on the current stencil value.
  kInvert,
  /// Increment the current stencil value by 1. If at maximum, set to zero.
  kIncrementWrap,
  /// Decrement the current stencil value by 1. If at zero, set to maximum.
  kDecrementWrap,
};

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

                       {
  //----------------------------------------------------------------------------
  /// Allocations can be mapped onto the hosts address space and also be used by
  /// the device.
  ///
  kHostVisible,
  //----------------------------------------------------------------------------
  /// 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.
  ///
  kDevicePrivate,
  //----------------------------------------------------------------------------
  /// 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.
  ///
  kDeviceTransient,
};

StoreAction

enum impeller::StoreAction

strong

Enumerator
kDontCare
kStore
kMultisampleResolve
kStoreAndMultisampleResolve

Definition at line 208 of file formats.h.

                       {
  kDontCare,
  kStore,
  kMultisampleResolve,
  kStoreAndMultisampleResolve,
};

SubpixelPosition

enum impeller::SubpixelPosition : uint8_t

All possible positions for a subpixel alignment. The name is in the format kSubpixelXY where X and Y are numerators to 1/4 fractions in their respective directions.

Enumerator
kSubpixel00
kSubpixel10
kSubpixel20
kSubpixel30
kSubpixel01
kSubpixel02
kSubpixel03
kSubpixel11
kSubpixel12
kSubpixel13
kSubpixel21
kSubpixel22
kSubpixel23
kSubpixel31
kSubpixel32
kSubpixel33

Definition at line 56 of file font_glyph_pair.h.

                      : uint8_t {
  // Subpixel at {0, 0}.
  kSubpixel00 = 0x0,
  // Subpixel at {0.25, 0}.
  kSubpixel10 = 0x1,
  // Subpixel at {0.5, 0}.
  kSubpixel20 = 0x2,
  // Subpixel at {0.75, 0}.
  kSubpixel30 = 0x3,
  // Subpixel at {0, 0.25}.
  kSubpixel01 = kSubpixel10 << 2,
  // Subpixel at {0, 0.5}.
  kSubpixel02 = kSubpixel20 << 2,
  // Subpixel at {0, 0.75}.
  kSubpixel03 = kSubpixel30 << 2,
  kSubpixel11 = kSubpixel10 | kSubpixel01,
  kSubpixel12 = kSubpixel10 | kSubpixel02,
  kSubpixel13 = kSubpixel10 | kSubpixel03,
  kSubpixel21 = kSubpixel20 | kSubpixel01,
  kSubpixel22 = kSubpixel20 | kSubpixel02,
  kSubpixel23 = kSubpixel20 | kSubpixel03,
  kSubpixel31 = kSubpixel30 | kSubpixel01,
  kSubpixel32 = kSubpixel30 | kSubpixel02,
  kSubpixel33 = kSubpixel30 | kSubpixel03,
};

TextureCoordinateSystem

enum impeller::TextureCoordinateSystem

strong

Enumerator
kUploadFromHost
kRenderToTexture

Definition at line 327 of file formats.h.

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

TextureType

enum impeller::TextureType

strong

Enumerator
kTexture2D
kTexture2DMultisample
kTextureCube
kTextureExternalOES

Definition at line 262 of file formats.h.

                       {
  kTexture2D,
  kTexture2DMultisample,
  kTextureCube,
  kTextureExternalOES,
};

TextureUsage

enum impeller::TextureUsage

strong

Enumerator
kUnknown
kShaderRead
kShaderWrite
kRenderTarget

Definition at line 300 of file formats.h.

                        {
  kUnknown = 0,
  kShaderRead = 1 << 0,
  kShaderWrite = 1 << 1,
  kRenderTarget = 1 << 2,
};

VendorVK

enum impeller::VendorVK

strong

Enumerator
kUnknown
kGoogle	Includes the SwiftShader CPU implementation.
kQualcomm
kARM
kImgTec
kPowerVR
kAMD
kNvidia
kIntel
kHuawei
kSamsung
kMesa	Includes the LLVM Pipe CPU implementation.
kApple	Includes Vulkan on Metal via MoltenVK.

Definition at line 131 of file driver_info_vk.h.

                    {
  kUnknown,
  //----------------------------------------------------------------------------
  /// Includes the SwiftShader CPU implementation.
  ///
  kGoogle,
  kQualcomm,
  kARM,
  kImgTec,
  kPowerVR = kImgTec,
  kAMD,
  kNvidia,
  kIntel,
  kHuawei,
  kSamsung,
  //----------------------------------------------------------------------------
  /// Includes the LLVM Pipe CPU implementation.
  ///
  kMesa,
  //----------------------------------------------------------------------------
  /// Includes Vulkan on Metal via MoltenVK.
  ///
  kApple,
};

WindingOrder

enum impeller::WindingOrder

strong

Enumerator
kClockwise
kCounterClockwise

Definition at line 22 of file formats.h.

                        {
  kClockwise,
  kCounterClockwise,
};

YUVColorSpace

enum impeller::YUVColorSpace

strong

Enumerator
kBT601LimitedRange
kBT601FullRange

Definition at line 54 of file color.h.

{ kBT601LimitedRange, kBT601FullRange };

Function Documentation

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

                                   {
  return val >= T{} ? val : -val;
}

Referenced by ScalarNearlyZero().

Absolute< Scalar >()

template<>

constexpr Scalar impeller::Absolute< Scalar > ( const float &  val )

constexpr

Definition at line 27 of file scalar.h.

                                                    {
  return fabsf(val);
}

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 37 of file texture_util.cc.

                                           {
  std::shared_ptr<BlitPass> blit_pass = command_buffer->CreateBlitPass();
  bool success = blit_pass->GenerateMipmap(texture);
  if (!success) {
    return fml::Status(fml::StatusCode::kUnknown, "");
  }
  success = blit_pass->EncodeCommands();
  if (!success) {
    return fml::Status(fml::StatusCode::kUnknown, "");
  }
  return fml::Status();
}

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

AdjustScale()

static void impeller::AdjustScale ( Scalar &  radius1, Scalar &  radius2, Scalar  dimension, Scalar &  scale  )

inlinestatic

Definition at line 15 of file rounding_radii.cc.

                                              {
  FML_DCHECK(radius1 >= 0.0f && radius2 >= 0.0f);
  FML_DCHECK(dimension > 0.0f);
  if (radius1 + radius2 > dimension) {
    scale = std::min(scale, dimension / (radius1 + radius2));
  }
}

Referenced by impeller::RoundingRadii::Scaled().

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

                               {
  using VS = typename TPipeline::VertexShader;
  using FS = typename TPipeline::FragmentShader;
 
  //----------------------------------------------------------------------------
  /// Handle inputs.
  ///
 
  const size_t total_inputs =
      inputs.size() + (foreground_color.has_value() ? 1 : 0);
  if (total_inputs < 2) {
    return std::nullopt;
  }
 
  auto dst_snapshot =
      inputs[0]->GetSnapshot("AdvancedBlend(Dst)", renderer, entity);
  if (!dst_snapshot.has_value()) {
    return std::nullopt;
  }
  auto maybe_dst_uvs = dst_snapshot->GetCoverageUVs(coverage);
  if (!maybe_dst_uvs.has_value()) {
    return std::nullopt;
  }
  auto dst_uvs = maybe_dst_uvs.value();
 
  std::optional<Snapshot> src_snapshot;
  std::array<Point, 4> src_uvs;
  if (!foreground_color.has_value()) {
    src_snapshot =
        inputs[1]->GetSnapshot("AdvancedBlend(Src)", renderer, entity);
    if (!src_snapshot.has_value()) {
      if (!dst_snapshot.has_value()) {
        return std::nullopt;
      }
      return Entity::FromSnapshot(dst_snapshot.value(), entity.GetBlendMode());
    }
    auto maybe_src_uvs = src_snapshot->GetCoverageUVs(coverage);
    if (!maybe_src_uvs.has_value()) {
      if (!dst_snapshot.has_value()) {
        return std::nullopt;
      }
      return Entity::FromSnapshot(dst_snapshot.value(), entity.GetBlendMode());
    }
    src_uvs = maybe_src_uvs.value();
  }
 
  Rect subpass_coverage = coverage;
  if (entity.GetContents()) {
    auto coverage_hint = entity.GetContents()->GetCoverageHint();
 
    if (coverage_hint.has_value()) {
      auto maybe_subpass_coverage =
          subpass_coverage.Intersection(*coverage_hint);
      if (!maybe_subpass_coverage.has_value()) {
        return std::nullopt;  // Nothing to render.
      }
 
      subpass_coverage = *maybe_subpass_coverage;
    }
  }
 
  //----------------------------------------------------------------------------
  /// Render to texture.
  ///
 
  ContentContext::SubpassCallback callback = [&](const ContentContext& renderer,
                                                 RenderPass& pass) {
    auto& host_buffer = renderer.GetTransientsBuffer();
 
    auto size = pass.GetRenderTargetSize();
 
    std::array<typename VS::PerVertexData, 4> vertices = {
        typename VS::PerVertexData{Point(0, 0), dst_uvs[0], src_uvs[0]},
        typename VS::PerVertexData{Point(size.width, 0), dst_uvs[1],
                                   src_uvs[1]},
        typename VS::PerVertexData{Point(0, size.height), dst_uvs[2],
                                   src_uvs[2]},
        typename VS::PerVertexData{Point(size.width, size.height), dst_uvs[3],
                                   src_uvs[3]},
    };
    auto vtx_buffer =
        CreateVertexBuffer(vertices, renderer.GetTransientsBuffer());
 
    auto options = OptionsFromPass(pass);
    options.primitive_type = PrimitiveType::kTriangleStrip;
    options.blend_mode = BlendMode::kSrc;
    PipelineRef pipeline = std::invoke(pipeline_proc, renderer, options);
 
#ifdef IMPELLER_DEBUG
    pass.SetCommandLabel(BlendModeToFilterString(blend_mode));
#endif  // IMPELLER_DEBUG
    pass.SetVertexBuffer(std::move(vtx_buffer));
    pass.SetPipeline(pipeline);
 
    typename FS::BlendInfo blend_info;
    typename VS::FrameInfo frame_info;
 
    raw_ptr<const Sampler> dst_sampler =
        renderer.GetContext()->GetSamplerLibrary()->GetSampler(
            dst_snapshot->sampler_descriptor);
    FS::BindTextureSamplerDst(pass, dst_snapshot->texture, dst_sampler);
    frame_info.dst_y_coord_scale = dst_snapshot->texture->GetYCoordScale();
    blend_info.dst_input_alpha =
        absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
            ? dst_snapshot->opacity
            : 1.0;
 
    if (foreground_color.has_value()) {
      blend_info.color_factor = 1;
      blend_info.color = foreground_color.value();
      // This texture will not be sampled from due to the color factor. But
      // this is present so that validation doesn't trip on a missing
      // binding.
      FS::BindTextureSamplerSrc(pass, dst_snapshot->texture, dst_sampler);
    } else {
      raw_ptr<const Sampler> src_sampler =
          renderer.GetContext()->GetSamplerLibrary()->GetSampler(
              src_snapshot->sampler_descriptor);
      blend_info.color_factor = 0;
      blend_info.src_input_alpha = src_snapshot->opacity;
      FS::BindTextureSamplerSrc(pass, src_snapshot->texture, src_sampler);
      frame_info.src_y_coord_scale = src_snapshot->texture->GetYCoordScale();
    }
    auto blend_uniform = host_buffer.EmplaceUniform(blend_info);
    FS::BindBlendInfo(pass, blend_uniform);
 
    frame_info.mvp = pass.GetOrthographicTransform() *
                     Matrix::MakeTranslation(coverage.GetOrigin() -
                                             subpass_coverage.GetOrigin());
 
    auto uniform_view = host_buffer.EmplaceUniform(frame_info);
    VS::BindFrameInfo(pass, uniform_view);
 
    return pass.Draw().ok();
  };
 
  std::shared_ptr<CommandBuffer> command_buffer =
      renderer.GetContext()->CreateCommandBuffer();
  if (!command_buffer) {
    return std::nullopt;
  }
  fml::StatusOr<RenderTarget> render_target =
      renderer.MakeSubpass("Advanced Blend Filter",            //
                           ISize(subpass_coverage.GetSize()),  //
                           command_buffer,                     //
                           callback,                           //
                           /*msaa_enabled=*/false,             //
                           /*depth_stencil_enabled=*/false     //
      );
  if (!render_target.ok()) {
    return std::nullopt;
  }
  if (!renderer.GetContext()->EnqueueCommandBuffer(std::move(command_buffer))) {
    return std::nullopt;
  }
 
  return Entity::FromSnapshot(
      Snapshot{
          .texture = render_target.value().GetRenderTargetTexture(),
          .transform = Matrix::MakeTranslation(subpass_coverage.GetOrigin()),
          // Since we absorbed the transform of the inputs and used the
          // respective snapshot sampling modes when blending, pass on
          // the default NN clamp sampler.
          .sampler_descriptor = {},
          .opacity = (absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
                          ? 1.0f
                          : dst_snapshot->opacity) *
                     alpha.value_or(1.0)},
      entity.GetBlendMode());
}

References CreateVertexBuffer(), impeller::Entity::FromSnapshot(), impeller::Entity::GetBlendMode(), impeller::Entity::GetContents(), impeller::ContentContext::GetContext(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), impeller::ContentContext::GetTransientsBuffer(), impeller::TRect< T >::Intersection(), kSrc, kTriangleStrip, impeller::ColorFilterContents::kYes, impeller::ContentContext::MakeSubpass(), impeller::Matrix::MakeTranslation(), OptionsFromPass(), impeller::Snapshot::texture, and transform.

API_AVAILABLE()

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

Definition at line 17 of file command_buffer_mtl.mm.

                                       {
  switch (state) {
    case MTLCommandEncoderErrorStateUnknown:
      return @"unknown";
    case MTLCommandEncoderErrorStateCompleted:
      return @"completed";
    case MTLCommandEncoderErrorStateAffected:
      return @"affected";
    case MTLCommandEncoderErrorStatePending:
      return @"pending";
    case MTLCommandEncoderErrorStateFaulted:
      return @"faulted";
  }
  return @"unknown";
}

AppendColor()

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

static

Definition at line 12 of file gradient.cc.

                                                                {
  auto converted = color.ToR8G8B8A8();
  data->color_bytes.push_back(converted[0]);
  data->color_bytes.push_back(converted[1]);
  data->color_bytes.push_back(converted[2]);
  data->color_bytes.push_back(converted[3]);
}

References data, and impeller::Color::ToR8G8B8A8().

Referenced by CreateGradientBuffer().

AppendToExistingAtlas()

static size_t impeller::AppendToExistingAtlas ( const std::shared_ptr< GlyphAtlas > &  atlas, const std::vector< FontGlyphPair > &  extra_pairs, std::vector< Rect > &  glyph_positions, const std::vector< Rect > &  glyph_sizes, ISize  atlas_size, int64_t  height_adjustment, const std::shared_ptr< RectanglePacker > &  rect_packer  )

static

Append as many glyphs to the texture as will fit, and return the first index of [extra_pairs] that did not fit.

Definition at line 102 of file typographer_context_skia.cc.

                                                       {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!rect_packer || atlas_size.IsEmpty()) {
    return 0;
  }
 
  for (size_t i = 0; i < extra_pairs.size(); i++) {
    ISize glyph_size = ISize::Ceil(glyph_sizes[i].GetSize());
    IPoint16 location_in_atlas;
    if (!rect_packer->AddRect(glyph_size.width + kPadding,   //
                              glyph_size.height + kPadding,  //
                              &location_in_atlas             //
                              )) {
      return i;
    }
    // Position the glyph in the center of the 1px padding.
    glyph_positions.push_back(Rect::MakeXYWH(
        location_in_atlas.x() + 1,                      //
        location_in_atlas.y() + height_adjustment + 1,  //
        glyph_size.width,                               //
        glyph_size.height                               //
        ));
  }
 
  return extra_pairs.size();
}

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

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas().

ApplyBlendedColor()

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

inlinestaticconstexpr

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

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

Definition at line 124 of file color.cc.

                                                                      {
  dst = dst.Premultiply();
  src =
      // Use the blended color for areas where the source and destination
      // colors overlap.
      FromRGB(blend_result, src.alpha * dst.alpha).Premultiply() +
      // Use the original source color for any remaining non-overlapping areas.
      src.Premultiply() * (1.0f - dst.alpha);
 
  // Source-over composite the blended source color atop the destination.
  return src + dst * (1.0f - src.alpha);
}

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

Referenced by DoColorBlend(), and DoColorBlendComponents().

AttachmentToString()

std::string impeller::AttachmentToString

(

const Attachment &

attachment

)

Definition at line 104 of file formats.cc.

                                                           {
  std::stringstream stream;
  if (attachment.texture) {
    stream << "Texture=("
           << TextureDescriptorToString(
                  attachment.texture->GetTextureDescriptor())
           << "),";
  }
  if (attachment.resolve_texture) {
    stream << "ResolveTexture=("
           << TextureDescriptorToString(
                  attachment.resolve_texture->GetTextureDescriptor())
           << "),";
  }
  stream << "LoadAction=" << LoadActionToString(attachment.load_action) << ",";
  stream << "StoreAction=" << StoreActionToString(attachment.store_action);
  return stream.str();
}

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

                                                    {
  switch (type) {
    case GL_RENDERBUFFER:
      return "GL_RENDERBUFFER";
    case GL_TEXTURE:
      return "GL_TEXTURE";
    case GL_NONE:
      return "GL_NONE";
  }
 
  return "Unknown Type";
}

References type.

Referenced by DescribeFramebufferAttachment().

BENCHMARK_CAPTURE() [1/2]

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

BENCHMARK_CAPTURE() [2/2]

impeller::BENCHMARK_CAPTURE	(	BM_Convex	,
		rse_convex	,
		CreateRSuperellipse()	,
		true
	)

Bind() [1/2]

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

static

Definition at line 188 of file render_pass_mtl.mm.

                                         {
  if (!view.GetBuffer()) {
    return false;
  }
 
  const DeviceBuffer* device_buffer = view.GetBuffer();
  if (!device_buffer) {
    return false;
  }
 
  auto buffer = DeviceBufferMTL::Cast(*device_buffer).GetMTLBuffer();
  // The Metal call is a void return and we don't want to make it on nil.
  if (!buffer) {
    return false;
  }
 
  return pass.SetBuffer(stage, bind_index, view.GetRange().offset, buffer);
}

References impeller::BufferView::GetBuffer(), impeller::BufferView::GetRange(), impeller::Range::offset, and impeller::PassBindingsCacheMTL::SetBuffer().

Bind() [2/2]

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

static

Definition at line 210 of file render_pass_mtl.mm.

                                         {
  if (!sampler || !texture.IsValid()) {
    return false;
  }
 
  if (texture.NeedsMipmapGeneration()) {
    // TODO(127697): generate mips when the GPU is available on iOS.
#if !FML_OS_IOS
    VALIDATION_LOG
        << "Texture at binding index " << bind_index
        << " has a mip count > 1, but the mipmap has not been generated.";
    return false;
#endif  // !FML_OS_IOS
  }
 
  return pass.SetTexture(stage, bind_index,
                         TextureMTL::Cast(texture).GetMTLTexture()) &&
         pass.SetSampler(stage, bind_index,
                         SamplerMTL::Cast(*sampler).GetMTLSamplerState());
}

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

BindVertexBuffer()

static bool impeller::BindVertexBuffer ( const ProcTableGLES &  gl, BufferBindingsGLES *  vertex_desc_gles, const BufferView &  vertex_buffer_view, size_t  buffer_index  )

static

Bind the vertex attributes associated with vertex buffer.

Definition at line 148 of file render_pass_gles.cc.

                                                  {
  if (!vertex_buffer_view) {
    return false;
  }
 
  const DeviceBuffer* vertex_buffer = vertex_buffer_view.GetBuffer();
 
  if (!vertex_buffer) {
    return false;
  }
 
  const auto& vertex_buffer_gles = DeviceBufferGLES::Cast(*vertex_buffer);
  if (!vertex_buffer_gles.BindAndUploadDataIfNecessary(
          DeviceBufferGLES::BindingType::kArrayBuffer)) {
    return false;
  }
 
  //--------------------------------------------------------------------------
  /// Bind the vertex attributes associated with vertex buffer.
  ///
  if (!vertex_desc_gles->BindVertexAttributes(
          gl, buffer_index, vertex_buffer_view.GetRange().offset)) {
    return false;
  }
 
  return true;
}

References impeller::BufferBindingsGLES::BindVertexAttributes(), impeller::BufferView::GetBuffer(), impeller::BufferView::GetRange(), and impeller::Range::offset.

Referenced by EncodeCommandsInReactor().

BlendModeToString()

const char * impeller::BlendModeToString

(

BlendMode

blend_mode

)

Definition at line 47 of file color.cc.

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

References kBlendModeNames.

Referenced by impeller::ContentContext::GetPorterDuffPipeline(), std::operator<<(), impeller::VerticesSimpleBlendContents::Render(), and impeller::testing::TEST().

BM_Convex()

template<class... Args>

static void impeller::BM_Convex ( benchmark::State &  state, Args &&...  args  )

static

Definition at line 68 of file geometry_benchmarks.cc.

                                                             {
  auto args_tuple = std::make_tuple(std::move(args)...);
  auto path = flutter::DlPath(std::get<flutter::DlPath>(args_tuple));
 
  size_t point_count = 0u;
  size_t single_point_count = 0u;
  auto points = std::make_unique<std::vector<Point>>();
  auto indices = std::make_unique<std::vector<uint16_t>>();
  points->reserve(2048);
  while (state.KeepRunning()) {
    points->clear();
    indices->clear();
    Tessellator::TessellateConvexInternal(path, *points, *indices, 1.0f);
    single_point_count = indices->size();
    point_count += indices->size();
  }
  state.counters["SinglePointCount"] = single_point_count;
  state.counters["TotalPointCount"] = point_count;
}

References points, and impeller::Tessellator::TessellateConvexInternal().

BM_StrokePath()

template<class... Args>

static void impeller::BM_StrokePath ( benchmark::State &  state, Args &&...  args  )

static

Definition at line 41 of file geometry_benchmarks.cc.

                                                                 {
  auto args_tuple = std::make_tuple(std::move(args)...);
  auto path = std::get<flutter::DlPath>(args_tuple);
 
  Tessellator tessellator;
  StrokeParameters stroke{
      .width = 5.0f,
      .cap = std::get<Cap>(args_tuple),
      .join = std::get<Join>(args_tuple),
      .miter_limit = 10.0f,
  };
 
  const Scalar scale = 1.0f;
 
  size_t point_count = 0u;
  size_t single_point_count = 0u;
  while (state.KeepRunning()) {
    auto vertices = ImpellerBenchmarkAccessor::GenerateSolidStrokeVertices(
        tessellator, path, stroke, scale);
    single_point_count = vertices.size();
    point_count += single_point_count;
  }
  state.counters["SinglePointCount"] = single_point_count;
  state.counters["TotalPointCount"] = point_count;
}

References impeller::ImpellerBenchmarkAccessor::GenerateSolidStrokeVertices(), and impeller::StrokeParameters::width.

BuildGLArguments()

template<class... Type>

std::string impeller::BuildGLArguments

(

Type...

args

)

Definition at line 68 of file proc_table_gles.h.

                                                       {
  std::stringstream stream;
  stream << "(";
  BuildGLArgumentsStream(stream, args...);
  stream << ")";
  return stream.str();
}

References BuildGLArgumentsStream().

Referenced by impeller::GLProc< T >::operator()().

BuildGLArgumentsStream() [1/3]

constexpr void impeller::BuildGLArgumentsStream ( std::stringstream &  stream )

constexpr

Definition at line 56 of file proc_table_gles.h.

{}

BuildGLArgumentsStream() [2/3]

template<class Type >

void impeller::BuildGLArgumentsStream	(	std::stringstream &	stream,
		Type	arg
	)

Definition at line 52 of file proc_table_gles.h.

                                                               {
  stream << arg;
}

Referenced by BuildGLArguments(), and BuildGLArgumentsStream().

BuildGLArgumentsStream() [3/3]

template<class Type , class... Rest>

void impeller::BuildGLArgumentsStream	(	std::stringstream &	stream,
		Type	arg,
		Rest...	other_args
	)

Definition at line 59 of file proc_table_gles.h.

                                                {
  BuildGLArgumentsStream(stream, arg);
  stream << ", ";
  BuildGLArgumentsStream(stream, other_args...);
}

References BuildGLArgumentsStream().

BulkUpdateAtlasBitmap()

static bool impeller::BulkUpdateAtlasBitmap ( const GlyphAtlas &  atlas, std::shared_ptr< BlitPass > &  blit_pass, HostBuffer &  host_buffer, const std::shared_ptr< Texture > &  texture, const std::vector< FontGlyphPair > &  new_pairs, size_t  start_index, size_t  end_index  )

static

Batch render to a single surface.

This is only safe for use when updating a fresh texture.

Definition at line 265 of file typographer_context_skia.cc.

                                                    {
  TRACE_EVENT0("impeller", __FUNCTION__);
 
  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
 
  SkBitmap bitmap;
  bitmap.setInfo(GetImageInfo(atlas, Size(texture->GetSize())));
  if (!bitmap.tryAllocPixels()) {
    return false;
  }
 
  auto surface = SkSurfaces::WrapPixels(bitmap.pixmap());
  if (!surface) {
    return false;
  }
  auto canvas = surface->getCanvas();
  if (!canvas) {
    return false;
  }
 
  for (size_t i = start_index; i < end_index; i++) {
    const FontGlyphPair& pair = new_pairs[i];
    auto data = atlas.FindFontGlyphBounds(pair);
    if (!data.has_value()) {
      continue;
    }
    auto [pos, bounds, placeholder] = data.value();
    FML_DCHECK(!placeholder);
    Size size = pos.GetSize();
    if (size.IsEmpty()) {
      continue;
    }
 
    DrawGlyph(canvas, SkPoint::Make(pos.GetLeft(), pos.GetTop()),
              pair.scaled_font, pair.glyph, bounds, pair.glyph.properties,
              has_color);
  }
 
  // Writing to a malloc'd buffer and then copying to the staging buffers
  // benchmarks as substantially faster on a number of Android devices.
  BufferView buffer_view = host_buffer.Emplace(
      bitmap.getAddr(0, 0),
      texture->GetSize().Area() *
          BytesPerPixelForPixelFormat(
              atlas.GetTexture()->GetTextureDescriptor().format),
      host_buffer.GetMinimumUniformAlignment());
 
  return blit_pass->AddCopy(std::move(buffer_view),  //
                            texture,                 //
                            IRect::MakeXYWH(0, 0, texture->GetSize().width,
                                            texture->GetSize().height));
}

References buffer_view, BytesPerPixelForPixelFormat(), data, DrawGlyph(), impeller::HostBuffer::Emplace(), impeller::GlyphAtlas::FindFontGlyphBounds(), GetImageInfo(), impeller::HostBuffer::GetMinimumUniformAlignment(), impeller::GlyphAtlas::GetTexture(), impeller::GlyphAtlas::GetType(), impeller::FontGlyphPair::glyph, impeller::TSize< T >::IsEmpty(), impeller::GlyphAtlas::kColorBitmap, impeller::TRect< T >::MakeXYWH(), impeller::SubpixelGlyph::properties, and impeller::FontGlyphPair::scaled_font.

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas().

BytesPerPixelForPixelFormat()

constexpr size_t impeller::BytesPerPixelForPixelFormat ( PixelFormat  format )

constexpr

Definition at line 466 of file formats.h.

                                                                 {
  switch (format) {
    case PixelFormat::kUnknown:
      return 0u;
    case PixelFormat::kA8UNormInt:
    case PixelFormat::kR8UNormInt:
    case PixelFormat::kS8UInt:
      return 1u;
    case PixelFormat::kR8G8UNormInt:
      return 2u;
    case PixelFormat::kR8G8B8A8UNormInt:
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
    case PixelFormat::kB8G8R8A8UNormInt:
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
    case PixelFormat::kB10G10R10XRSRGB:
    case PixelFormat::kB10G10R10XR:
      return 4u;
    case PixelFormat::kD24UnormS8Uint:
      return 4u;
    case PixelFormat::kD32FloatS8UInt:
      return 5u;
    case PixelFormat::kR16G16B16A16Float:
    case PixelFormat::kB10G10R10A10XR:
      return 8u;
    case PixelFormat::kR32G32B32A32Float:
      return 16u;
  }
  return 0u;
}

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

Referenced by impeller::BlitPass::AddCopy(), BulkUpdateAtlasBitmap(), impeller::BlitCopyBufferToTextureCommandGLES::Encode(), impeller::TextureDescriptor::GetByteSizeOfAllMipLevels(), impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), impeller::TextureDescriptor::GetBytesPerRow(), impeller::Allocator::MinimumBytesPerRow(), and UpdateAtlasBitmap().

CanClearAttachment()

constexpr bool impeller::CanClearAttachment ( LoadAction  action )

constexpr

Definition at line 239 of file formats.h.

                                                     {
  switch (action) {
    case LoadAction::kLoad:
      return false;
    case LoadAction::kDontCare:
    case LoadAction::kClear:
      return true;
  }
  FML_UNREACHABLE();
}

References kClear, kDontCare, and kLoad.

CanDiscardAttachmentWhenDone()

constexpr bool impeller::CanDiscardAttachmentWhenDone ( StoreAction  action )

constexpr

Definition at line 250 of file formats.h.

                                                                {
  switch (action) {
    case StoreAction::kStore:
    case StoreAction::kStoreAndMultisampleResolve:
      return false;
    case StoreAction::kDontCare:
    case StoreAction::kMultisampleResolve:
      return true;
  }
  FML_UNREACHABLE();
}

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

ChooseAlphaCompositionMode()

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

static

Definition at line 97 of file khr_swapchain_impl_vk.cc.

                                    {
  if (flags & vk::CompositeAlphaFlagBitsKHR::eInherit) {
    return vk::CompositeAlphaFlagBitsKHR::eInherit;
  }
  if (flags & vk::CompositeAlphaFlagBitsKHR::ePreMultiplied) {
    return vk::CompositeAlphaFlagBitsKHR::ePreMultiplied;
  }
  if (flags & vk::CompositeAlphaFlagBitsKHR::ePostMultiplied) {
    return vk::CompositeAlphaFlagBitsKHR::ePostMultiplied;
  }
  if (flags & vk::CompositeAlphaFlagBitsKHR::eOpaque) {
    return vk::CompositeAlphaFlagBitsKHR::eOpaque;
  }
 
  return std::nullopt;
}

ChooseSurfaceFormat()

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

static

Definition at line 75 of file khr_swapchain_impl_vk.cc.

                            {
  const auto colorspace = vk::ColorSpaceKHR::eSrgbNonlinear;
  const auto vk_preference =
      vk::SurfaceFormatKHR{ToVKImageFormat(preference), colorspace};
  if (ContainsFormat(formats, vk_preference)) {
    return vk_preference;
  }
 
  std::vector<vk::SurfaceFormatKHR> options = {
      {vk::Format::eB8G8R8A8Unorm, colorspace},
      {vk::Format::eR8G8B8A8Unorm, colorspace}};
  for (const auto& format : options) {
    if (ContainsFormat(formats, format)) {
      return format;
    }
  }
 
  return std::nullopt;
}

References ContainsFormat(), and ToVKImageFormat().

ClipColor()

static constexpr Vector3 impeller::ClipColor ( Vector3  color )

inlinestaticconstexpr

Definition at line 67 of file color.cc.

                                                         {
  Scalar lum = Luminosity(color);
  Scalar mn = std::min(std::min(color.x, color.y), color.z);
  Scalar mx = std::max(std::max(color.x, color.y), color.z);
  // `lum - mn` and `mx - lum` will always be >= 0 in the following conditions,
  // so adding a tiny value is enough to make these divisions safe.
  if (mn < 0.0f) {
    color = lum + (((color - lum) * lum) / (lum - mn + kEhCloseEnough));
  }
  if (mx > 1.0) {
    color =
        lum + (((color - lum) * (1.0f - lum)) / (mx - lum + kEhCloseEnough));
  }
  return color;
}

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

                                 {
  builder->Close();
}

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

ColorAttachmentToString()

std::string impeller::ColorAttachmentToString

(

const ColorAttachment &

color

)

Definition at line 123 of file formats.cc.

                                                                {
  std::stringstream stream;
  stream << AttachmentToString(color) << ",";
  stream << "ClearColor=(" << ColorToString(color.clear_color) << ")";
  return stream.str();
}

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

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

ColorToString()

std::string impeller::ColorToString

(

const Color &

color

)

Definition at line 333 of file color.cc.

                                            {
  return SPrintF("R=%.1f,G=%.1f,B=%.1f,A=%.1f",  //
                 color.red,                      //
                 color.green,                    //
                 color.blue,                     //
                 color.alpha                     //
  );
}

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

Referenced by ColorAttachmentToString().

ComponentChoose()

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

inlinestaticconstexpr

Definition at line 101 of file color.cc.

                                                               {
  return Vector3(value.x > cutoff ? b.x : a.x,  //
                 value.y > cutoff ? b.y : a.y,  //
                 value.z > cutoff ? b.z : a.z   //
  );
}

References impeller::saturated::b, value, 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 24 of file texture_descriptor.h.

                                                                    {
  switch (type) {
    case CompressionType::kLossless:
      return "Lossless";
    case CompressionType::kLossy:
      return "Lossy";
  }
  FML_UNREACHABLE();
}

References kLossless, kLossy, and type.

Referenced by TextureDescriptorToString().

ComputeConicSubdivisions()

Scalar impeller::ComputeConicSubdivisions	(	Scalar	scale_factor,
		Point	p0,
		Point	p1,
		Point	p2,
		Scalar	w
	)

Returns the minimum number of evenly spaced (in the parametric sense) line segments that the conic must be chopped into in order to guarantee all lines stay within a distance of "1/intolerance" pixels from the true curve.

The scale_factor should be the max basis XY of the current transform.

Definition at line 48 of file wangs_formula.cc.

                                          {
  // Compute center of bounding box in projected space
  const Point C = 0.5f * (p0.Min(p1).Min(p2) + p0.Max(p1).Max(p2));
 
  // Translate by -C. This improves translation-invariance of the formula,
  // see Sec. 3.3 of cited paper
  p0 -= C;
  p1 -= C;
  p2 -= C;
 
  // Compute max length
  const Scalar max_len =
      std::sqrt(std::max(p0.Dot(p0), std::max(p1.Dot(p1), p2.Dot(p2))));
 
  // Compute forward differences
  const Point dp = -2 * w * p1 + p0 + p2;
  const Scalar dw = std::abs(-2 * w + 2);
 
  // Compute numerator and denominator for parametric step size of
  // linearization. Here, the epsilon referenced from the cited paper
  // is 1/precision.
  Scalar k = scale_factor * kPrecision;
  const Scalar rp_minus_1 = std::max(0.0f, max_len * k - 1);
  const Scalar numer = std::sqrt(dp.Dot(dp)) * k + rp_minus_1 * dw;
  const Scalar denom = 4 * std::min(w, 1.0f);
 
  // Number of segments = sqrt(numer / denom).
  // This assumes parametric interval of curve being linearized is
  //   [t0,t1] = [0, 1].
  // If not, the number of segments is (tmax - tmin) / sqrt(denom / numer).
  return std::sqrt(numer / denom);
}

References impeller::TPoint< T >::Dot(), impeller::TPoint< T >::Max(), and impeller::TPoint< T >::Min().

Referenced by impeller::PathTessellator::Conic::SubdivisionCount().

ComputeCubicSubdivisions()

Scalar impeller::ComputeCubicSubdivisions	(	Scalar	scale_factor,
		Point	p0,
		Point	p1,
		Point	p2,
		Point	p3
	)

Returns the minimum number of evenly spaced (in the parametric sense) line segments that the cubic must be chopped into in order to guarantee all lines stay within a distance of "1/intolerance" pixels from the true curve.

The scale_factor should be the max basis XY of the current transform.

Definition at line 23 of file wangs_formula.cc.

                                          {
  Scalar k = scale_factor * .75f * kPrecision;
  Point a = (p0 - p1 * 2 + p2).Abs();
  Point b = (p1 - p2 * 2 + p3).Abs();
  return std::sqrt(k * length(a.Max(b)));
}

References impeller::saturated::b, and impeller::TPoint< T >::Max().

Referenced by impeller::PathTessellator::Cubic::SubdivisionCount().

computeErf7()

static Scalar impeller::computeErf7 ( Scalar  x )

static

Definition at line 59 of file solid_rrect_like_blur_contents.cc.

                                    {
  x *= kTwoOverSqrtPi;
  float xx = x * x;
  x = x + (0.24295 + (0.03395 + 0.0104 * xx) * xx) * (x * xx);
  return x / sqrt(1.0 + x * x);
}

References kTwoOverSqrtPi, and x.

ComputeFractionalPosition()

static constexpr SubpixelPosition impeller::ComputeFractionalPosition ( Scalar  value )

staticconstexpr

Definition at line 75 of file text_frame.cc.

                                                                          {
  value += 0.125;
  value = (value - floorf(value));
  if (value < 0.25) {
    return SubpixelPosition::kSubpixel00;
  }
  if (value < 0.5) {
    return SubpixelPosition::kSubpixel10;
  }
  if (value < 0.75) {
    return SubpixelPosition::kSubpixel20;
  }
  return SubpixelPosition::kSubpixel30;
}

References kSubpixel00, kSubpixel10, kSubpixel20, kSubpixel30, and value.

Referenced by impeller::TextFrame::ComputeSubpixelPosition().

ComputeGlyphSize()

static Rect impeller::ComputeGlyphSize ( const SkFont &  font, const SubpixelGlyph &  glyph, Scalar  scale  )

static

Definition at line 397 of file typographer_context_skia.cc.

                                           {
  SkRect scaled_bounds;
  SkPaint glyph_paint;
  if (glyph.properties.has_value() && glyph.properties->stroke) {
    glyph_paint.setStroke(true);
    glyph_paint.setStrokeWidth(glyph.properties->stroke->width * scale);
    glyph_paint.setStrokeCap(ToSkiaCap(glyph.properties->stroke->cap));
    glyph_paint.setStrokeJoin(ToSkiaJoin(glyph.properties->stroke->join));
    glyph_paint.setStrokeMiter(glyph.properties->stroke->miter_limit);
  }
  font.getBounds(&glyph.glyph.index, 1, &scaled_bounds, &glyph_paint);
 
  // Expand the bounds of glyphs at subpixel offsets by 2 in the x direction.
  Scalar adjustment = 0.0;
  if (glyph.subpixel_offset != SubpixelPosition::kSubpixel00) {
    adjustment = 1.0;
  }
  return Rect::MakeLTRB(scaled_bounds.fLeft - adjustment, scaled_bounds.fTop,
                        scaled_bounds.fRight + adjustment,
                        scaled_bounds.fBottom);
};

References impeller::SubpixelGlyph::glyph, impeller::Glyph::index, kSubpixel00, impeller::TRect< Scalar >::MakeLTRB(), impeller::SubpixelGlyph::properties, and impeller::SubpixelGlyph::subpixel_offset.

ComputeNextAtlasSize()

static ISize impeller::ComputeNextAtlasSize ( const std::shared_ptr< GlyphAtlasContext > &  atlas_context, const std::vector< FontGlyphPair > &  extra_pairs, std::vector< Rect > &  glyph_positions, const std::vector< Rect > &  glyph_sizes, size_t  glyph_index_start, int64_t  max_texture_height  )

static

Definition at line 166 of file typographer_context_skia.cc.

                                {
  // Because we can't grow the skyline packer horizontally, pick a reasonable
  // large width for all atlases.
  static constexpr int64_t kAtlasWidth = 4096;
  static constexpr int64_t kMinAtlasHeight = 1024;
 
  ISize current_size = ISize(kAtlasWidth, kMinAtlasHeight);
  if (atlas_context->GetAtlasSize().height > current_size.height) {
    current_size.height = atlas_context->GetAtlasSize().height * 2;
  }
 
  auto height_adjustment = atlas_context->GetAtlasSize().height;
  while (current_size.height <= max_texture_height) {
    std::shared_ptr<RectanglePacker> rect_packer;
    if (atlas_context->GetRectPacker() || glyph_index_start) {
      rect_packer = RectanglePacker::Factory(
          kAtlasWidth,
          current_size.height - atlas_context->GetAtlasSize().height);
    } else {
      rect_packer = RectanglePacker::Factory(kAtlasWidth, current_size.height);
    }
    glyph_positions.erase(glyph_positions.begin() + glyph_index_start,
                          glyph_positions.end());
    atlas_context->UpdateRectPacker(rect_packer);
    auto next_index = PairsFitInAtlasOfSize(
        extra_pairs, current_size, glyph_positions, glyph_sizes,
        height_adjustment, rect_packer, glyph_index_start);
    if (next_index == extra_pairs.size()) {
      return current_size;
    }
    current_size = ISize(current_size.width, current_size.height * 2);
  }
  return {};
}

References impeller::RectanglePacker::Factory(), impeller::TSize< T >::height, PairsFitInAtlasOfSize(), and impeller::TSize< T >::width.

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas().

ComputeQuadradicSubdivisions()

Scalar impeller::ComputeQuadradicSubdivisions	(	Scalar	scale_factor,
		Point	p0,
		Point	p1,
		Point	p2
	)

Returns the minimum number of evenly spaced (in the parametric sense) line segments that the quadratic must be chopped into in order to guarantee all lines stay within a distance of "1/intolerance" pixels from the true curve.

The scale_factor should be the max basis XY of the current transform.

Definition at line 34 of file wangs_formula.cc.

                                              {
  Scalar k = scale_factor * .25f * kPrecision;
  return std::sqrt(k * length(p0 - p1 * 2 + p2));
}

Referenced by impeller::PathTessellator::Quad::SubdivisionCount().

ComputeSaveLayerCoverage()

std::optional< Rect > impeller::ComputeSaveLayerCoverage	(	const Rect &	content_coverage,
		const Matrix &	effect_transform,
		const Rect &	coverage_limit,
		const std::shared_ptr< FilterContents > &	image_filter,
		bool	flood_output_coverage = false,
		bool	flood_input_coverage = false
	)

Compute the coverage of a subpass in the global coordinate space.

Parameters

content_coverage	the computed coverage of the contents of the save layer. This value may be empty if the save layer has no contents, or Rect::Maximum if the contents are unbounded (like a destructive blend).
effect_transform	The CTM of the subpass.
coverage_limit	The current clip coverage. This is used to bound the subpass size.
image_filter	A subpass image filter, or nullptr.
flood_output_coverage	Whether the coverage should be flooded to clip coverage regardless of input coverage. This should be set to true when the restore Paint has a destructive blend mode.
flood_input_coverage	Whther the content coverage should be flooded. This should be set to true if the paint has a backdrop filter or if there is a transparent black effecting color filter.

The coverage computation expects content_coverage to be in the child coordinate space. effect_transform is used to transform this back into the global coordinate space. A return value of std::nullopt indicates that the coverage is empty or otherwise does not intersect with the parent coverage limit and should be discarded.

Definition at line 19 of file save_layer_utils.cc.

                               {
  Rect coverage = content_coverage;
  // There are three conditions that should cause input coverage to flood, the
  // first is the presence of a backdrop filter on the saveLayer. The second is
  // the presence of a color filter that effects transparent black on the
  // saveLayer. The last is the presence of unbounded content within the
  // saveLayer (such as a drawPaint, bdf, et cetera). Note that unbounded
  // coverage is handled in the display list dispatcher.
  //
  // Backdrop filters apply before the saveLayer is restored. The presence of
  // a backdrop filter causes the content coverage of the saveLayer to be
  // unbounded.
  //
  // If there is a color filter that needs to flood its output. The color filter
  // is applied before any image filters, so this floods input coverage and not
  // the output coverage. Technically, we only need to flood the output of the
  // color filter and could allocate a render target sized just to the content,
  // but we don't currenty have the means to do so. Flooding the coverage is a
  // non-optimal but technically correct way to render this.
  //
  // If the saveLayer contains unbounded content, then at this point the
  // dl_dispatcher will have set content coverage to Rect::MakeMaximum().
  if (flood_input_coverage) {
    coverage = Rect::MakeMaximum();
  }
 
  // The content coverage must be scaled by any image filters present on the
  // saveLayer paint. For example, if a saveLayer has a coverage limit of
  // 100x100, but it has a Matrix image filter that scales by one half, the
  // actual coverage limit is 200x200.
  if (image_filter) {
    // Transform the input coverage into the global coordinate space before
    // computing the bounds limit intersection. This is the "worst case"
    // coverage value before we intersect with the content coverage below.
    std::optional<Rect> source_coverage_limit =
        image_filter->GetSourceCoverage(effect_transform, coverage_limit);
    if (!source_coverage_limit.has_value()) {
      // No intersection with parent coverage limit.
      return std::nullopt;
    }
    // The image filter may change the coverage limit required to flood
    // the parent layer. Returning the source coverage limit so that we
    // can guarantee the render target is larger enough.
    //
    // See note below on flood_output_coverage.
    if (flood_output_coverage || coverage.IsMaximum()) {
      return source_coverage_limit;
    }
 
    // Trimming the content coverage by the coverage limit can reduce memory
    // bandwith. But in cases where there are animated matrix filters, such as
    // in the framework's zoom transition, the changing scale values continually
    // change the source_coverage_limit. Intersecting the source_coverage_limit
    // with the coverage may result in slightly different texture sizes each
    // frame of the animation. This leads to non-optimal allocation patterns as
    // differently sized textures cannot be reused. Hence the following
    // herustic: If the coverage is within a semi-arbitrary percentage of the
    // intersected coverage, then just use the transformed coverage. In other
    // cases, use the intersection.
    auto transformed_coverage = coverage.TransformBounds(effect_transform);
    auto intersected_coverage =
        transformed_coverage.Intersection(source_coverage_limit.value());
    if (intersected_coverage.has_value() &&
        SizeDifferenceUnderThreshold(transformed_coverage.GetSize(),
                                     intersected_coverage->GetSize(),
                                     kDefaultSizeThreshold)) {
      // Returning the transformed coverage is always correct, it just may
      // be larger than the clip area or onscreen texture.
      return transformed_coverage;
    }
    return intersected_coverage;
  }
 
  // If the input coverage is maximum, just return the coverage limit that
  // is already in the global coordinate space.
  //
  // If flood_output_coverage is true, then the restore is applied with a
  // destructive blend mode that requires flooding to the coverage limit.
  // Technically we could only allocated a render target as big as the input
  // coverage and then use a decal sampling mode to perform the flood. Returning
  // the coverage limit is a correct but non optimal means of ensuring correct
  // rendering.
  if (flood_output_coverage || coverage.IsMaximum()) {
    return coverage_limit;
  }
 
  // Transform the input coverage into the global coordinate space before
  // computing the bounds limit intersection.
  Rect transformed_coverage = coverage.TransformBounds(effect_transform);
  std::optional<Rect> intersection =
      transformed_coverage.Intersection(coverage_limit);
  if (!intersection.has_value()) {
    return std::nullopt;
  }
  // The the resulting coverage rect is nearly the same as the coverage_limit,
  // round up to the coverage_limit.
  Rect intersect_rect = intersection.value();
  if (SizeDifferenceUnderThreshold(intersect_rect.GetSize(),
                                   coverage_limit.GetSize(),
                                   kDefaultSizeThreshold)) {
    return coverage_limit;
  }
 
  return intersect_rect;
}

References impeller::TRect< T >::GetSize(), impeller::TRect< T >::Intersection(), impeller::TRect< T >::IsMaximum(), impeller::TRect< Scalar >::MakeMaximum(), and impeller::TRect< T >::TransformBounds().

Referenced by impeller::Canvas::SaveLayer(), and impeller::testing::TEST().

ConfigureAttachment()

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

static

Definition at line 56 of file render_pass_mtl.mm.

                                                                               {
  if (!desc.texture) {
    return false;
  }
 
  attachment.texture = TextureMTL::Cast(*desc.texture).GetMTLTexture();
  attachment.loadAction = ToMTLLoadAction(desc.load_action);
  attachment.storeAction = ToMTLStoreAction(desc.store_action);
 
  if (!ConfigureResolveTextureAttachment(desc, attachment)) {
    return false;
  }
 
  return true;
}

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

                                                               {
  if (color->blending_enabled) {
    gl.Enable(GL_BLEND);
    gl.BlendFuncSeparate(
        ToBlendFactor(color->src_color_blend_factor),  // src color
        ToBlendFactor(color->dst_color_blend_factor),  // dst color
        ToBlendFactor(color->src_alpha_blend_factor),  // src alpha
        ToBlendFactor(color->dst_alpha_blend_factor)   // dst alpha
    );
    gl.BlendEquationSeparate(
        ToBlendOperation(color->color_blend_op),  // mode color
        ToBlendOperation(color->alpha_blend_op)   // mode alpha
    );
  } else {
    gl.Disable(GL_BLEND);
  }
 
  {
    const auto is_set = [](ColorWriteMask mask,
                           ColorWriteMask check) -> GLboolean {
      return (mask & check) ? GL_TRUE : GL_FALSE;
    };
 
    gl.ColorMask(
        is_set(color->write_mask, ColorWriteMaskBits::kRed),    // red
        is_set(color->write_mask, ColorWriteMaskBits::kGreen),  // green
        is_set(color->write_mask, ColorWriteMaskBits::kBlue),   // blue
        is_set(color->write_mask, ColorWriteMaskBits::kAlpha)   // alpha
    );
  }
}

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

                                                        {
  if (!ConfigureAttachment(desc, attachment)) {
    return false;
  }
  attachment.clearColor = ToMTLClearColor(desc.clear_color);
  return true;
}

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.

                                                        {
  if (!ConfigureAttachment(desc, attachment)) {
    return false;
  }
  attachment.clearDepth = desc.clear_depth;
  return true;
}

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

                     {
  auto handle = TextureGLES::Cast(texture.get())->GetGLHandle();
  if (!handle.has_value()) {
    return std::nullopt;
  }
 
  if (TextureGLES::Cast(*texture).IsWrapped()) {
    // The texture is attached to the default FBO, so there's no need to
    // create/configure one.
    gl.BindFramebuffer(fbo_type, 0);
    return 0;
  }
 
  GLuint fbo;
  gl.GenFramebuffers(1u, &fbo);
  gl.BindFramebuffer(fbo_type, fbo);
 
  if (!TextureGLES::Cast(*texture).SetAsFramebufferAttachment(
          fbo_type, TextureGLES::AttachmentType::kColor0)) {
    VALIDATION_LOG << "Could not attach texture to framebuffer.";
    DeleteFBO(gl, fbo, fbo_type);
    return std::nullopt;
  }
 
  if (gl.CheckFramebufferStatus(fbo_type) != GL_FRAMEBUFFER_COMPLETE) {
    VALIDATION_LOG << "Could not create a complete framebuffer.";
    DeleteFBO(gl, fbo, fbo_type);
    return std::nullopt;
  }
 
  return fbo;
};

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

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

ConfigureResolveTextureAttachment()

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

static

Definition at line 27 of file render_pass_mtl.mm.

                                                   {
  bool needs_resolve =
      desc.store_action == StoreAction::kMultisampleResolve ||
      desc.store_action == StoreAction::kStoreAndMultisampleResolve;
 
  if (needs_resolve && !desc.resolve_texture) {
    VALIDATION_LOG << "Resolve store action specified on attachment but no "
                      "resolve texture was specified.";
    return false;
  }
 
  if (desc.resolve_texture && !needs_resolve) {
    VALIDATION_LOG << "A resolve texture was specified even though the store "
                      "action doesn't require it.";
    return false;
  }
 
  if (!desc.resolve_texture) {
    return true;
  }
 
  attachment.resolveTexture =
      TextureMTL::Cast(*desc.resolve_texture).GetMTLTexture();
 
  return true;
}

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

                                                  {
  if (!pipeline.HasStencilAttachmentDescriptors()) {
    gl.Disable(GL_STENCIL_TEST);
    return;
  }
 
  gl.Enable(GL_STENCIL_TEST);
  const auto& front = pipeline.GetFrontStencilAttachmentDescriptor();
  const auto& back = pipeline.GetBackStencilAttachmentDescriptor();
 
  if (front.has_value() && back.has_value() && front == back) {
    ConfigureStencil(GL_FRONT_AND_BACK, gl, *front, stencil_reference);
    return;
  }
  if (front.has_value()) {
    ConfigureStencil(GL_FRONT, gl, *front, stencil_reference);
  }
  if (back.has_value()) {
    ConfigureStencil(GL_BACK, gl, *back, stencil_reference);
  }
}

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

Referenced by EncodeCommandsInReactor().

ConfigureStencil() [2/2]

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

Definition at line 79 of file render_pass_gles.cc.

                                                  {
  gl.StencilOpSeparate(
      face,                                    // face
      ToStencilOp(stencil.stencil_failure),    // stencil fail
      ToStencilOp(stencil.depth_failure),      // depth fail
      ToStencilOp(stencil.depth_stencil_pass)  // depth stencil pass
  );
  gl.StencilFuncSeparate(face,                                        // face
                         ToCompareFunction(stencil.stencil_compare),  // func
                         stencil_reference,                           // ref
                         stencil.read_mask                            // mask
  );
  gl.StencilMaskSeparate(face, stencil.write_mask);
}

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.

ConfigureStencilAttachment()

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

static

Definition at line 93 of file render_pass_mtl.mm.

                                                          {
  if (!ConfigureAttachment(desc, attachment)) {
    return false;
  }
  attachment.clearStencil = desc.clear_stencil;
  return true;
}

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

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

Referenced by ChooseSurfaceFormat().

CornerContains()

static bool impeller::CornerContains ( const Point &  p, const Point &  corner, const Point &  direction, const Size &  radii  )

static

Definition at line 30 of file round_rect.cc.

                                              {
  FML_DCHECK(radii.width >= 0.0f && radii.height >= 0.0f);
  if (radii.IsEmpty()) {
    // This corner is not curved, therefore the containment is the same as
    // the previously checked bounds containment.
    return true;
  }
 
  // The positive X,Y distance between the corner and the point.
  Point corner_relative = (corner - p) * direction;
 
  // The distance from the "center" of the corner's elliptical curve.
  // If both numbers are positive then we need to do an elliptical distance
  // check to determine if it is inside the curve.
  // If either number is negative, then the point is outside this quadrant
  // and is governed by inclusion in the bounds and inclusion within other
  // corners of this round rect. In that case, we return true here to allow
  // further evaluation within other quadrants.
  Point quadrant_relative = radii - corner_relative;
  if (quadrant_relative.x <= 0.0f || quadrant_relative.y <= 0.0f) {
    // Not within the curved quadrant of this corner, therefore "inside"
    // relative to this one corner.
    return true;
  }
 
  // Dividing the quadrant_relative point by the radii gives a corresponding
  // location within a unit circle which can be more easily tested for
  // containment. We can use x^2 + y^2 and compare it against the radius
  // squared (1.0) to avoid the sqrt.
  Point quadrant_unit_circle_point = quadrant_relative / radii;
  return quadrant_unit_circle_point.GetLengthSquared() <= 1.0;
}

References impeller::TPoint< T >::GetLengthSquared(), impeller::TSize< T >::height, impeller::TSize< T >::IsEmpty(), impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by impeller::RoundRect::Contains(), and impeller::RoundSuperellipseParam::Contains().

CreateBufferPool()

static PoolVMA impeller::CreateBufferPool ( VmaAllocator  allocator )

static

Definition at line 59 of file allocator_vk.cc.

                                                        {
  vk::BufferCreateInfo buffer_info;
  buffer_info.usage = vk::BufferUsageFlagBits::eVertexBuffer |
                      vk::BufferUsageFlagBits::eIndexBuffer |
                      vk::BufferUsageFlagBits::eUniformBuffer |
                      vk::BufferUsageFlagBits::eStorageBuffer |
                      vk::BufferUsageFlagBits::eTransferSrc |
                      vk::BufferUsageFlagBits::eTransferDst;
  buffer_info.size = 1u;  // doesn't matter
  buffer_info.sharingMode = vk::SharingMode::eExclusive;
  auto buffer_info_native =
      static_cast<vk::BufferCreateInfo::NativeType>(buffer_info);
 
  VmaAllocationCreateInfo allocation_info = {};
  allocation_info.usage = VMA_MEMORY_USAGE_AUTO;
  allocation_info.preferredFlags = static_cast<VkMemoryPropertyFlags>(
      ToVKBufferMemoryPropertyFlags(StorageMode::kHostVisible));
  allocation_info.flags = ToVmaAllocationBufferCreateFlags(
      StorageMode::kHostVisible, /*readback=*/false);
 
  uint32_t memTypeIndex;
  auto result = vk::Result{vmaFindMemoryTypeIndexForBufferInfo(
      allocator, &buffer_info_native, &allocation_info, &memTypeIndex)};
  if (result != vk::Result::eSuccess) {
    return {};
  }
 
  VmaPoolCreateInfo pool_create_info = {};
  pool_create_info.memoryTypeIndex = memTypeIndex;
  pool_create_info.flags = VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT;
  pool_create_info.minBlockCount = 1;
 
  VmaPool pool = {};
  result = vk::Result{::vmaCreatePool(allocator, &pool_create_info, &pool)};
  if (result != vk::Result::eSuccess) {
    return {};
  }
  return {allocator, pool};
}

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.

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

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 127 of file pipeline_vk.cc.

                                    {
  RenderPassBuilderVK builder;
 
  for (const auto& [bind_point, color] : desc.GetColorAttachmentDescriptors()) {
    builder.SetColorAttachment(bind_point,             //
                               color.format,           //
                               desc.GetSampleCount(),  //
                               LoadAction::kDontCare,  //
                               StoreAction::kDontCare  //
    );
  }
 
  if (auto depth = desc.GetDepthStencilAttachmentDescriptor();
      depth.has_value()) {
    builder.SetDepthStencilAttachment(desc.GetDepthPixelFormat(),  //
                                      desc.GetSampleCount(),       //
                                      LoadAction::kDontCare,       //
                                      StoreAction::kDontCare       //
    );
  } else if (desc.HasStencilAttachmentDescriptors()) {
    builder.SetStencilAttachment(desc.GetStencilPixelFormat(),  //
                                 desc.GetSampleCount(),         //
                                 LoadAction::kDontCare,         //
                                 StoreAction::kDontCare         //
    );
  }
 
  auto pass = builder.Build(device);
  if (!pass) {
    VALIDATION_LOG << "Failed to create render pass for pipeline: "
                   << desc.GetLabel();
    return {};
  }
 
#ifdef IMPELLER_DEBUG
  ContextVK::SetDebugName(
      device, pass.get(),
      SPrintF("Compat Render Pass: %s", desc.GetLabel().data()));
#endif  // IMPELLER_DEBUG
 
  return pass;
}

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(), SPrintF(), 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 528 of file content_context.cc.

                            {
  auto desc = PipelineT::Builder::MakeDefaultPipelineDescriptor(context);
  if (!desc.has_value()) {
    return nullptr;
  }
  // Apply default ContentContextOptions to the descriptor.
  const auto default_color_format =
      context.GetCapabilities()->GetDefaultColorFormat();
  ContentContextOptions{.sample_count = SampleCount::kCount4,
                        .primitive_type = PrimitiveType::kTriangleStrip,
                        .color_attachment_pixel_format = default_color_format}
      .ApplyToPipelineDescriptor(*desc);
  return std::make_unique<PipelineT>(context, desc);
}

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

                          {
  auto descriptor = ToMTLDepthStencilDescriptor(
      desc.GetDepthStencilAttachmentDescriptor(),  //
      desc.GetFrontStencilAttachmentDescriptor(),  //
      desc.GetBackStencilAttachmentDescriptor()    //
  );
  return [device newDepthStencilStateWithDescriptor:descriptor];
}

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

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.

                                                                  {
  FML_DCHECK(stops.size() == colors.size());
 
  uint32_t texture_size;
  if (stops.size() == 2) {
    texture_size = colors.size();
  } else {
    auto minimum_delta = 1.0;
    for (size_t i = 1; i < stops.size(); i++) {
      auto value = stops[i] - stops[i - 1];
      // Smaller than kEhCloseEnough
      if (value < 0.0001) {
        continue;
      }
      if (value < minimum_delta) {
        minimum_delta = value;
      }
    }
    // Avoid creating textures that are absurdly large due to stops that are
    // very close together.
    // TODO(jonahwilliams): this should use a platform specific max texture
    // size.
    texture_size = std::min(
        static_cast<uint32_t>(std::round(1.0 / minimum_delta)) + 1, 1024u);
  }
  GradientData data = {
      .color_bytes = {},
      .texture_size = texture_size,
  };
  data.color_bytes.reserve(texture_size * 4);
 
  if (texture_size == colors.size() && colors.size() <= 1024) {
    for (auto i = 0u; i < colors.size(); i++) {
      AppendColor(colors[i], &data);
    }
  } else {
    Color previous_color = colors[0];
    auto previous_stop = 0.0;
    auto previous_color_index = 0;
 
    // The first index is always equal to the first color, exactly.
    AppendColor(previous_color, &data);
 
    for (auto i = 1u; i < texture_size - 1; i++) {
      auto scaled_i = i / (texture_size - 1.0);
      Color next_color = colors[previous_color_index + 1];
      auto next_stop = stops[previous_color_index + 1];
      // We're almost exactly equal to the next stop.
      if (ScalarNearlyEqual(scaled_i, next_stop)) {
        AppendColor(next_color, &data);
 
        previous_color = next_color;
        previous_stop = next_stop;
        previous_color_index += 1;
      } else if (scaled_i < next_stop) {
        // We're still between the current stop and the next stop.
        auto t = (scaled_i - previous_stop) / (next_stop - previous_stop);
        auto mixed_color = Color::Lerp(previous_color, next_color, t);
 
        AppendColor(mixed_color, &data);
      } else {
        // We've slightly overshot the previous stop.
        previous_color = next_color;
        previous_stop = next_stop;
        previous_color_index += 1;
        next_color = colors[previous_color_index + 1];
        auto next_stop = stops[previous_color_index + 1];
 
        auto t = (scaled_i - previous_stop) / (next_stop - previous_stop);
        auto mixed_color = Color::Lerp(previous_color, next_color, t);
 
        AppendColor(mixed_color, &data);
      }
    }
    // The last index is always equal to the last color, exactly.
    AppendColor(colors.back(), &data);
  }
  return data;
}

References AppendColor(), data, impeller::Color::Lerp(), ScalarNearlyEqual(), and value.

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 34 of file gradient_generator.cc.

                                                                           {
  FML_DCHECK(stops.size() == colors.size());
 
  std::vector<StopData> result;
  result.reserve(stops.size());
  Scalar last_stop = 0;
  for (auto i = 0u; i < stops.size(); i++) {
    Scalar delta = stops[i] - last_stop;
    Scalar inverse_delta = delta == 0.0f ? 0.0 : 1.0 / delta;
    result.emplace_back(StopData{
        .color = colors[i], .stop = stops[i], .inverse_delta = inverse_delta});
    last_stop = stops[i];
  }
  return result;
}

References impeller::StopData::color.

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.

                                                   {
  if (gradient_data.texture_size == 0) {
    FML_DLOG(ERROR) << "Invalid gradient data.";
    return nullptr;
  }
 
  impeller::TextureDescriptor texture_descriptor;
  texture_descriptor.storage_mode = impeller::StorageMode::kHostVisible;
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_descriptor.size = {gradient_data.texture_size, 1};
 
  return CreateTexture(texture_descriptor, gradient_data.color_bytes, context,
                       "Gradient");
}

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

CreateMappingFromAllocation()

std::shared_ptr< fml::Mapping > impeller::CreateMappingFromAllocation

(

const std::shared_ptr< Allocation > &

allocation

)

Creates a mapping from allocation.

        No data copy occurs. Only a reference to the underlying
        allocation is bumped up.

        Changes to the underlying allocation will not be reflected in
        the mapping and must not change.

Parameters

[in]

allocation

The allocation.

Returns

A new mapping or nullptr if the argument allocation was invalid.

Definition at line 99 of file allocation.cc.

                                                 {
  if (!allocation) {
    return nullptr;
  }
  return std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(allocation->GetBuffer()),  //
      allocation->GetLength().GetByteSize(),                      //
      [allocation](auto, auto) {}                                 //
  );
}

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

CreateMappingWithCopy()

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

Creates a mapping with copy of the bytes.

Parameters

[in]	contents	The contents
[in]	length	The length

Returns

The new mapping or nullptr if the copy could not be performed.

Definition at line 83 of file allocation.cc.

                                                                  {
  if (contents == nullptr) {
    return nullptr;
  }
 
  auto allocation = std::make_shared<Allocation>();
  if (!allocation->Truncate(length)) {
    return nullptr;
  }
 
  std::memmove(allocation->GetBuffer(), contents, length.GetByteSize());
 
  return CreateMappingFromAllocation(allocation);
}

References CreateMappingFromAllocation(), and impeller::AllocationSize< Period >::GetByteSize().

CreateMappingWithString() [1/2]

std::shared_ptr<fml::Mapping> impeller::CreateMappingWithString

(

std::shared_ptr< const std::string >

string

)

Creates a mapping with string data.

        Only a reference to the underlying string is bumped up and the
        string is not copied.

Parameters

[in]

string

The string

Returns

A new mapping or nullptr in case of allocation failures.

CreateMappingWithString() [2/2]

std::shared_ptr< fml::Mapping > impeller::CreateMappingWithString

(

std::string

string

)

Creates a mapping with string data.

        The string is copied.

Parameters

[in]

string

The string

Returns

A new mapping or nullptr in case of allocation failures.

Definition at line 111 of file allocation.cc.

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

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

CreateMetalCommandQueue()

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

static

Definition at line 219 of file context_mtl.mm.

                                                                         {
  auto command_queue = device.newCommandQueue;
  if (!command_queue) {
    VALIDATION_LOG << "Could not set up the command queue.";
    return nullptr;
  }
  command_queue.label = @"Impeller Command Queue";
  return command_queue;
}

References VALIDATION_LOG.

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

CreateMetalDevice()

static id<MTLDevice> impeller::CreateMetalDevice ( )

static

Definition at line 215 of file context_mtl.mm.

                                         {
  return ::MTLCreateSystemDefaultDevice();
}

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

CreatePathBuilder()

IMPELLER_API PathBuilder * impeller::CreatePathBuilder

(

)

Definition at line 12 of file tessellator.cc.

                                 {
  return new PathBuilder();
}

CreatePipelineFuture() [1/2]

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

Definition at line 37 of file pipeline.cc.

                                                 {
  if (!context.IsValid()) {
    return {
        desc,
        RealizedFuture<std::shared_ptr<Pipeline<ComputePipelineDescriptor>>>(
            nullptr)};
  }
 
  return context.GetPipelineLibrary()->GetPipeline(std::move(desc));
}

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

CreatePipelineFuture() [2/2]

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

Create a pipeline for the given descriptor.

If async is true, the compilation is performed on a worker thread. The returned future will complete once that work is done. If async is false, the work is done on the current thread.

It is more performant to set async to false than to spawn a worker and immediately block on the future completion.

Definition at line 24 of file pipeline.cc.

                {
  if (!context.IsValid()) {
    return {desc, RealizedFuture<std::shared_ptr<Pipeline<PipelineDescriptor>>>(
                      nullptr)};
  }
 
  return context.GetPipelineLibrary()->GetPipeline(std::move(desc),
                                                   /*async=*/async);
}

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

CreateSampler()

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

static

Definition at line 14 of file sampler_vk.cc.

                                                          {
  const auto min_filter = ToVKSamplerMinMagFilter(desc.min_filter);
  const auto mag_filter = ToVKSamplerMinMagFilter(desc.mag_filter);
 
  const auto address_mode_u = ToVKSamplerAddressMode(desc.width_address_mode);
  const auto address_mode_v = ToVKSamplerAddressMode(desc.height_address_mode);
  const auto address_mode_w = ToVKSamplerAddressMode(desc.depth_address_mode);
 
  vk::StructureChain<vk::SamplerCreateInfo,
                     // For VK_KHR_sampler_ycbcr_conversion
                     vk::SamplerYcbcrConversionInfo>
      sampler_chain;
 
  auto& sampler_info = sampler_chain.get();
 
  sampler_info.magFilter = mag_filter;
  sampler_info.minFilter = min_filter;
  sampler_info.addressModeU = address_mode_u;
  sampler_info.addressModeV = address_mode_v;
  sampler_info.addressModeW = address_mode_w;
  sampler_info.borderColor = vk::BorderColor::eFloatTransparentBlack;
  sampler_info.maxLod = VK_LOD_CLAMP_NONE;
 
  // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateInfo.html#_description
  switch (desc.mip_filter) {
    case MipFilter::kBase:
      sampler_info.mipmapMode = vk::SamplerMipmapMode::eNearest;
      sampler_info.minLod = sampler_info.maxLod = 0.0f;
      break;
    case MipFilter::kNearest:
      sampler_info.mipmapMode = vk::SamplerMipmapMode::eNearest;
      break;
    case MipFilter::kLinear:
      sampler_info.mipmapMode = vk::SamplerMipmapMode::eLinear;
      break;
  }
 
  if (yuv_conversion && yuv_conversion->IsValid()) {
    sampler_chain.get<vk::SamplerYcbcrConversionInfo>().conversion =
        yuv_conversion->GetConversion();
 
    // Spec: If sampler Y'CBCR conversion is enabled and the potential format
    // features of the sampler Y'CBCR conversion do not support or enable
    // separate reconstruction filters, minFilter and magFilter must be equal to
    // the sampler Y'CBCR conversion's chromaFilter.
    //
    // We don't enable separate reconstruction filters. So, just do what the
    // spec. says and use the conversions chromaFilter.
    //
    // See the validation VUID-VkSamplerCreateInfo-minFilter-01645 for more.
    //
    sampler_info.minFilter = sampler_info.magFilter =
        yuv_conversion->GetDescriptor().get().chromaFilter;
 
    // Spec: If sampler Y′CBCR conversion is enabled, addressModeU,
    // addressModeV, and addressModeW must be
    // VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, anisotropyEnable must be VK_FALSE,
    // and unnormalizedCoordinates must be VK_FALSE.
    //
    // See the validation VUID-VkSamplerCreateInfo-addressModeU-01646 for more.
    //
    sampler_info.addressModeU = vk::SamplerAddressMode::eClampToEdge;
    sampler_info.addressModeV = vk::SamplerAddressMode::eClampToEdge;
    sampler_info.addressModeW = vk::SamplerAddressMode::eClampToEdge;
    sampler_info.anisotropyEnable = false;
    sampler_info.unnormalizedCoordinates = false;
  } else {
    sampler_chain.unlink<vk::SamplerYcbcrConversionInfo>();
  }
 
  auto sampler = device.createSamplerUnique(sampler_chain.get());
  if (sampler.result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not create sampler: "
                   << vk::to_string(sampler.result);
    return {};
  }
 
  if (!desc.label.empty()) {
    ContextVK::SetDebugName(device, sampler.value.get(), desc.label.data());
  }
 
  return std::move(sampler.value);
}

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

CreateTexture()

std::shared_ptr< Texture > impeller::CreateTexture	(	const TextureDescriptor &	texture_descriptor,
		const std::vector< uint8_t > &	data,
		const std::shared_ptr< impeller::Context > &	context,
		std::string_view	debug_label
	)

Definition at line 11 of file texture_util.cc.

                                {
  std::shared_ptr<Texture> texture =
      context->GetResourceAllocator()->CreateTexture(texture_descriptor);
 
  auto data_mapping =
      std::make_shared<fml::NonOwnedMapping>(data.data(), data.size());
  std::shared_ptr<DeviceBuffer> buffer =
      context->GetResourceAllocator()->CreateBufferWithCopy(*data_mapping);
 
  std::shared_ptr<CommandBuffer> cmd_buffer = context->CreateCommandBuffer();
  std::shared_ptr<BlitPass> blit_pass = cmd_buffer->CreateBlitPass();
  blit_pass->AddCopy(DeviceBuffer::AsBufferView(std::move(buffer)), texture);
 
  if (!blit_pass->EncodeCommands() ||
      !context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok()) {
    return nullptr;
  }
 
  texture->SetLabel(debug_label);
  return texture;
}

References impeller::DeviceBuffer::AsBufferView(), and data.

Referenced by CreateGradientTexture().

CreateTextureForDecompressedImage()

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

static

Definition at line 391 of file playground.cc.

                            {
  TextureDescriptor texture_descriptor;
  texture_descriptor.storage_mode = StorageMode::kDevicePrivate;
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_descriptor.size = decompressed_image.GetSize();
  texture_descriptor.mip_count =
      enable_mipmapping ? decompressed_image.GetSize().MipCount() : 1u;
 
  auto texture =
      context->GetResourceAllocator()->CreateTexture(texture_descriptor);
  if (!texture) {
    VALIDATION_LOG << "Could not allocate texture for fixture.";
    return nullptr;
  }
 
  auto command_buffer = context->CreateCommandBuffer();
  if (!command_buffer) {
    FML_DLOG(ERROR) << "Could not create command buffer for mipmap generation.";
    return nullptr;
  }
  command_buffer->SetLabel("Mipmap Command Buffer");
 
  auto blit_pass = command_buffer->CreateBlitPass();
  auto buffer_view = DeviceBuffer::AsBufferView(
      context->GetResourceAllocator()->CreateBufferWithCopy(
          *decompressed_image.GetAllocation()));
  blit_pass->AddCopy(buffer_view, texture);
  if (enable_mipmapping) {
    blit_pass->SetLabel("Mipmap Blit Pass");
    blit_pass->GenerateMipmap(texture);
  }
  blit_pass->EncodeCommands();
  if (!context->GetCommandQueue()->Submit({command_buffer}).ok()) {
    FML_DLOG(ERROR) << "Failed to submit blit pass command buffer.";
    return nullptr;
  }
  return texture;
}

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

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

CreateUniformMemberKey() [1/2]

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

static

Definition at line 96 of file buffer_bindings_gles.cc.

                                        {
  return NormalizeUniformKey(non_struct_member);
}

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

                                                         {
  std::string result;
  result.reserve(struct_name.length() + member.length() + (is_array ? 4 : 1));
  result += struct_name;
  if (!member.empty()) {
    result += '.';
    result += member;
  }
  if (is_array) {
    result += "[0]";
  }
  return NormalizeUniformKey(result);
}

References NormalizeUniformKey().

CreateVertexBuffer()

template<class VertexType , size_t size>

VertexBuffer impeller::CreateVertexBuffer	(	std::array< VertexType, size >	input,
		HostBuffer &	host_buffer
	)

Create an index-less vertex buffer from a fixed size array.

Definition at line 24 of file vertex_buffer_builder.h.

                                                         {
  return VertexBuffer{
      .vertex_buffer = host_buffer.Emplace(
          input.data(), sizeof(VertexType) * size, alignof(VertexType)),  //
      .vertex_count = size,                                               //
      .index_type = IndexType::kNone,                                     //
  };
}

References impeller::HostBuffer::Emplace(), kNone, and impeller::VertexBuffer::vertex_buffer.

Referenced by AdvancedBlend(), PipelineBlend(), impeller::SolidRRectLikeBlurContents::Render(), impeller::TextureContents::Render(), impeller::ClipContents::Render(), and RenderClipRestore().

CubicTo()

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

Definition at line 28 of file tessellator.cc.

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

DebugToFramebufferError()

std::string impeller::DebugToFramebufferError

(

int

status

)

Definition at line 9 of file formats_gles.cc.

                                              {
  switch (status) {
    case GL_FRAMEBUFFER_UNDEFINED:
      return "GL_FRAMEBUFFER_UNDEFINED";
    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
      return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
      return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
    case GL_FRAMEBUFFER_UNSUPPORTED:
      return "GL_FRAMEBUFFER_UNSUPPORTED";
    case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
      return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
    default:
      return "Unknown error code: " + std::to_string(status);
  }
}

Referenced by EncodeCommandsInReactor().

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.

                                                                           {
  if (lhs.size() != rhs.size()) {
    return false;
  }
 
  for (auto i = lhs.begin(), j = rhs.begin(); i != lhs.end(); i++, j++) {
    if (i->first != j->first) {
      return false;
    }
 
    if (!DeepComparePointer(i->second, j->second)) {
      return false;
    }
  }
 
  return true;
}

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.

                                                                  {
  if (lhs == rhs) {
    return true;
  }
 
  if (lhs && rhs) {
    return lhs->IsEqual(*rhs);
  }
 
  return false;
}

Referenced by DeepCompareMap(), impeller::ComputePipelineDescriptor::IsEqual(), impeller::Font::IsEqual(), impeller::PipelineDescriptor::IsEqual(), and impeller::PipelineLibraryGLES::ProgramKey::Equal::operator()().

DeleteFBO()

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

static

Definition at line 43 of file blit_command_gles.cc.

                                                                        {
  if (fbo != GL_NONE) {
    gl.BindFramebuffer(type, GL_NONE);
    gl.DeleteFramebuffers(1u, &fbo);
  }
};

References type.

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

DepthAttachmentToString()

std::string impeller::DepthAttachmentToString

(

const DepthAttachment &

depth

)

Definition at line 130 of file formats.cc.

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

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

                                                                    {
  GLint type = GL_NONE;
  gl.GetFramebufferAttachmentParameteriv(
      GL_FRAMEBUFFER,                         // target
      attachment,                             // attachment
      GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,  // parameter name
      &type                                   // parameter
  );
 
  if (type != GL_NONE) {
    GLint object = GL_NONE;
    gl.GetFramebufferAttachmentParameteriv(
        GL_FRAMEBUFFER,                         // target
        attachment,                             // attachment
        GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,  // parameter name
        &object                                 // parameter
    );
    std::stringstream stream;
    stream << AttachmentTypeString(type) << "(" << object << ")";
    return stream.str();
  }
 
  return "No Attachment";
}

References AttachmentTypeString(), and type.

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

DestroyPathBuilder()

IMPELLER_API void impeller::DestroyPathBuilder

(

PathBuilder *

builder

)

Definition at line 16 of file tessellator.cc.

                                              {
  delete builder;
}

DestroyTessellator()

void impeller::DestroyTessellator

(

TESStesselator *

tessellator

)

Definition at line 186 of file tessellator_libtess.cc.

                                                     {
  if (tessellator != nullptr) {
    ::tessDeleteTess(tessellator);
  }
}

Referenced by impeller::TessellatorLibtess::TessellatorLibtess().

DestroyVertices()

IMPELLER_API void impeller::DestroyVertices

(

Vertices *

vertices

)

Definition at line 77 of file tessellator.cc.

                                         {
  delete vertices->points;
  delete vertices;
}

References impeller::Vertices::points.

DetermineIfANGLE()

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

static

Definition at line 43 of file description_gles.cc.

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

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

DetermineIfES()

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

static

Definition at line 39 of file description_gles.cc.

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

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.

                                                                {
  // Format for OpenGL "OpenGL<space>ES<space><version
  // number><space><vendor-specific information>".
  //
  // Format for OpenGL SL "OpenGL<space>ES<space>GLSL<space>ES<space><version
  // number><space><vendor-specific information>"
  //
  // The prefixes appear to be absent on Desktop GL.
 
  version = StripPrefix(version, "OpenGL ES ");
  version = StripPrefix(version, "GLSL ES ");
 
  if (version.empty()) {
    return std::nullopt;
  }
 
  std::stringstream stream;
  for (size_t i = 0; i < version.size(); i++) {
    const auto character = version[i];
    if (std::isdigit(character) || character == '.') {
      stream << character;
    } else {
      break;
    }
  }
  std::istringstream istream;
  istream.str(stream.str());
  std::vector<size_t> version_components;
  for (std::string version_component;
       std::getline(istream, version_component, '.');) {
    version_components.push_back(std::stoul(version_component));
  }
  return Version::FromVector(version_components);
}

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

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

DeviceMaxTextureSizeSupported()

ISize impeller::DeviceMaxTextureSizeSupported

(

id< MTLDevice >

device

)

Definition at line 25 of file allocator_mtl.mm.

                                                          {
  // Since Apple didn't expose API for us to get the max texture size, we have
  // to use hardcoded data from
  // https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
  // According to the feature set table, there are two supported max sizes :
  // 16384 and 8192 for devices flutter support. The former is used on macs and
  // latest ios devices. The latter is used on old ios devices.
  if ([device supportsFamily:MTLGPUFamilyApple3] ||
      [device supportsFamily:MTLGPUFamilyMacCatalyst1] ||
      [device supportsFamily:MTLGPUFamilyMac1]) {
    return {16384, 16384};
  }
  return {8192, 8192};
}

Referenced by impeller::AllocatorMTL::AllocatorMTL(), and InferMetalCapabilities().

DeviceSupportsComputeSubgroups()

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

static

Definition at line 36 of file context_mtl.mm.

                                                                 {
  // Refer to the "SIMD-scoped reduction operations" feature in the table
  // below: https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
  return [device supportsFamily:MTLGPUFamilyApple7] ||
         [device supportsFamily:MTLGPUFamilyMac2];
}

Referenced by InferMetalCapabilities().

DeviceSupportsDeviceTransientTargets()

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

static

Definition at line 19 of file allocator_mtl.mm.

                                                                       {
  // Refer to the "Memoryless render targets" feature in the table below:
  // https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
  return [device supportsFamily:MTLGPUFamilyApple2];
}

Referenced by impeller::AllocatorMTL::AllocatorMTL().

DeviceSupportsExtendedRangeFormats()

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

static

Definition at line 45 of file context_mtl.mm.

                                                                     {
  return [device supportsFamily:MTLGPUFamilyApple3];
}

Referenced by InferMetalCapabilities().

DeviceSupportsFramebufferFetch()

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

static

Definition at line 24 of file context_mtl.mm.

                                                                 {
#if FML_OS_IOS_SIMULATOR
  // The iOS simulator lies about supporting framebuffer fetch.
  return false;
#else   // FML_OS_IOS_SIMULATOR
  // According to
  // https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf, Apple2
  // corresponds to iOS GPU family 2, which supports A8 devices.
  return [device supportsFamily:MTLGPUFamilyApple2];
#endif  // FML_OS_IOS_SIMULATOR
}

Referenced by InferMetalCapabilities().

DeviceTypeToString()

constexpr const char* impeller::DeviceTypeToString ( DeviceTypeVK  type )

constexpr

Definition at line 223 of file driver_info_vk.cc.

                                                            {
  switch (type) {
    case DeviceTypeVK::kUnknown:
      return "Unknown";
    case DeviceTypeVK::kIntegratedGPU:
      return "Integrated GPU";
    case DeviceTypeVK::kDiscreteGPU:
      return "Discrete GPU";
    case DeviceTypeVK::kVirtualGPU:
      return "Virtual GPU";
    case DeviceTypeVK::kCPU:
      return "CPU";
  }
  FML_UNREACHABLE();
}

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

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

DisplayListToTexture()

std::shared_ptr< Texture > impeller::DisplayListToTexture	(	const sk_sp< flutter::DisplayList > &	display_list,
		ISize	size,
		AiksContext &	context,
		bool	reset_host_buffer,
		bool	generate_mips
	)

Render the provided display list to a texture with the given size.

Definition at line 1224 of file dl_dispatcher.cc.

                        {
  int mip_count = 1;
  if (generate_mips) {
    mip_count = size.MipCount();
  }
  // Do not use the render target cache as the lifecycle of this texture
  // will outlive a particular frame.
  impeller::RenderTargetAllocator render_target_allocator =
      impeller::RenderTargetAllocator(
          context.GetContext()->GetResourceAllocator());
  impeller::RenderTarget target;
  if (context.GetContext()->GetCapabilities()->SupportsOffscreenMSAA()) {
    target = render_target_allocator.CreateOffscreenMSAA(
        *context.GetContext(),  // context
        size,                   // size
        /*mip_count=*/mip_count,
        "Picture Snapshot MSAA",  // label
        impeller::RenderTarget::
            kDefaultColorAttachmentConfigMSAA  // color_attachment_config
    );
  } else {
    target = render_target_allocator.CreateOffscreen(
        *context.GetContext(),  // context
        size,                   // size
        /*mip_count=*/mip_count,
        "Picture Snapshot",  // label
        impeller::RenderTarget::
            kDefaultColorAttachmentConfig  // color_attachment_config
    );
  }
  if (!target.IsValid()) {
    return nullptr;
  }
 
  DlIRect cull_rect = DlIRect::MakeWH(size.width, size.height);
  impeller::FirstPassDispatcher collector(
      context.GetContentContext(), impeller::Matrix(), Rect::MakeSize(size));
  display_list->Dispatch(collector, cull_rect);
  impeller::CanvasDlDispatcher impeller_dispatcher(
      context.GetContentContext(),               //
      target,                                    //
      /*is_onscreen=*/false,                     //
      display_list->root_has_backdrop_filter(),  //
      display_list->max_root_blend_mode(),       //
      impeller::IRect::MakeSize(size)            //
  );
  const auto& [data, count] = collector.TakeBackdropData();
  impeller_dispatcher.SetBackdropData(data, count);
  context.GetContentContext().GetTextShadowCache().MarkFrameStart();
  fml::ScopedCleanupClosure cleanup([&] {
    if (reset_host_buffer) {
      context.GetContentContext().GetTransientsBuffer().Reset();
    }
    context.GetContentContext().GetTextShadowCache().MarkFrameEnd();
    context.GetContentContext().GetLazyGlyphAtlas()->ResetTextFrames();
    context.GetContext()->DisposeThreadLocalCachedResources();
  });
 
  display_list->Dispatch(impeller_dispatcher, cull_rect);
  impeller_dispatcher.FinishRecording();
 
  return target.GetRenderTargetTexture();
}

References impeller::RenderTargetAllocator::CreateOffscreen(), impeller::RenderTargetAllocator::CreateOffscreenMSAA(), data, impeller::CanvasDlDispatcher::FinishRecording(), impeller::AiksContext::GetContentContext(), impeller::AiksContext::GetContext(), impeller::RenderTarget::GetRenderTargetTexture(), impeller::ContentContext::GetTextShadowCache(), impeller::TSize< T >::height, impeller::RenderTarget::IsValid(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< T >::MakeSize(), impeller::TextShadowCache::MarkFrameStart(), impeller::TSize< T >::MipCount(), impeller::CanvasDlDispatcher::SetBackdropData(), impeller::FirstPassDispatcher::TakeBackdropData(), and impeller::TSize< T >::width.

Referenced by impeller::GoldenPlaygroundTest::MakeScreenshot(), impeller::GoldenPlaygroundTest::OpenPlaygroundHere(), impeller::testing::TEST_F(), and impeller::testing::TEST_P().

DoColorBlend()

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

inlinestatic

Definition at line 139 of file color.cc.

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

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

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

DoColorBlendComponents()

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

inlinestatic

Definition at line 147 of file color.cc.

                                                           {
  Vector3 blend_result = Vector3(blend_func(dst.red, src.red),      //
                                 blend_func(dst.green, src.green),  //
                                 blend_func(dst.blue, src.blue));   //
  return ApplyBlendedColor(dst, src, blend_result).Unpremultiply();
}

References ApplyBlendedColor(), impeller::Color::blue, impeller::Color::green, impeller::Color::red, and impeller::Color::Unpremultiply().

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

DrawGlyph()

static void impeller::DrawGlyph ( SkCanvas *  canvas, const SkPoint  position, const ScaledFont &  scaled_font, const SubpixelGlyph &  glyph, const Rect &  scaled_bounds, const std::optional< GlyphProperties > &  prop, bool  has_color  )

static

Definition at line 211 of file typographer_context_skia.cc.

                                      {
  const auto& metrics = scaled_font.font.GetMetrics();
  SkGlyphID glyph_id = glyph.glyph.index;
 
  SkFont sk_font(
      TypefaceSkia::Cast(*scaled_font.font.GetTypeface()).GetSkiaTypeface(),
      metrics.point_size, metrics.scaleX, metrics.skewX);
  sk_font.setEdging(SkFont::Edging::kAntiAlias);
  sk_font.setHinting(SkFontHinting::kSlight);
  sk_font.setEmbolden(metrics.embolden);
  sk_font.setSubpixel(true);
  sk_font.setSize(sk_font.getSize() * static_cast<Scalar>(scaled_font.scale));
 
  auto glyph_color = prop.has_value() ? prop->color.ToARGB() : SK_ColorBLACK;
 
  SkPaint glyph_paint;
  glyph_paint.setColor(glyph_color);
  glyph_paint.setBlendMode(SkBlendMode::kSrc);
  if (prop.has_value()) {
    auto stroke = prop->stroke;
    if (stroke.has_value()) {
      glyph_paint.setStroke(true);
      glyph_paint.setStrokeWidth(stroke->width *
                                 static_cast<Scalar>(scaled_font.scale));
      glyph_paint.setStrokeCap(ToSkiaCap(stroke->cap));
      glyph_paint.setStrokeJoin(ToSkiaJoin(stroke->join));
      glyph_paint.setStrokeMiter(stroke->miter_limit);
    } else {
      glyph_paint.setStroke(false);
    }
  }
  canvas->save();
  Point subpixel_offset = SubpixelPositionToPoint(glyph.subpixel_offset);
  canvas->translate(subpixel_offset.x, subpixel_offset.y);
  canvas->drawGlyphs(1u,         // count
                     &glyph_id,  // glyphs
                     &position,  // positions
                     SkPoint::Make(-scaled_bounds.GetLeft(),
                                   -scaled_bounds.GetTop()),  // origin
                     sk_font,                                 // font
                     glyph_paint                              // paint
  );
  canvas->restore();
}

References 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::SubpixelGlyph::glyph, impeller::Glyph::index, impeller::ScaledFont::scale, impeller::SubpixelGlyph::subpixel_offset, SubpixelPositionToPoint(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by BulkUpdateAtlasBitmap(), and UpdateAtlasBitmap().

DrawPlaygroundLine()

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

Definition at line 50 of file widgets.cc.

                                                                      {
  Point position_a = DrawPlaygroundPoint(point_a);
  Point position_b = DrawPlaygroundPoint(point_b);
 
  if (ImGui::GetCurrentContext()) {
    auto dir = (position_b - position_a).Normalize() * point_a.radius;
    auto line_a = position_a + dir;
    auto line_b = position_b - dir;
    ImGui::GetBackgroundDrawList()->AddLine(
        {line_a.x, line_a.y}, {line_b.x, line_b.y},
        ImColor(point_b.color.red, point_b.color.green, point_b.color.blue,
                0.3f));
  }
  return std::make_tuple(position_a, position_b);
}

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.

                                                  {
  if (ImGui::GetCurrentContext()) {
    impeller::Point mouse_pos(ImGui::GetMousePos().x, ImGui::GetMousePos().y);
    if (!point.prev_mouse_pos.has_value()) {
      point.prev_mouse_pos = mouse_pos;
    }
 
    if (ImGui::IsKeyPressed(ImGuiKey_R)) {
      point.position = point.reset_position;
      point.dragging = false;
    }
 
    bool hovering =
        point.position.GetDistance(mouse_pos) < point.radius &&
        point.position.GetDistance(point.prev_mouse_pos.value()) < point.radius;
    if (!ImGui::IsMouseDown(0)) {
      point.dragging = false;
    } else if (hovering && ImGui::IsMouseClicked(0)) {
      point.dragging = true;
    }
    if (point.dragging) {
      point.position += mouse_pos - point.prev_mouse_pos.value();
    }
    ImGui::GetBackgroundDrawList()->AddCircleFilled(
        {point.position.x, point.position.y}, point.radius,
        ImColor(point.color.red, point.color.green, point.color.blue,
                (hovering || point.dragging) ? 0.6f : 0.3f));
    if (hovering || point.dragging) {
      ImGui::GetBackgroundDrawList()->AddText(
          {point.position.x - point.radius,
           point.position.y + point.radius + 10},
          ImColor(point.color.red, point.color.green, point.color.blue, 1.0f),
          impeller::SPrintF("x:%0.3f y:%0.3f", point.position.x,
                            point.position.y)
              .c_str());
    }
    point.prev_mouse_pos = mouse_pos;
  }
  return point.position;
}

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(), x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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

eccentricity()

static Point impeller::eccentricity ( Point  v, double  sInverse  )

static

Definition at line 50 of file solid_rrect_like_blur_contents.cc.

                                                    {
  Point vOverS = v * sInverse * 0.5;
  Point vOverS_squared = -(vOverS * vOverS);
  return {std::exp(vOverS_squared.x), std::exp(vOverS_squared.y)};
}

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

EmptyFeedback()

static vk::PipelineCreationFeedbackEXT impeller::EmptyFeedback ( )

static

Definition at line 22 of file pipeline_vk.cc.

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

EncodeCommandsInReactor() [1/2]

bool impeller::EncodeCommandsInReactor	(	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.

                            {
  TRACE_EVENT0("impeller", "BlitPassGLES::EncodeCommandsInReactor");
 
  if (commands.empty()) {
    return true;
  }
 
#ifdef IMPELLER_DEBUG
  const auto& gl = reactor.GetProcTable();
  fml::ScopedCleanupClosure pop_pass_debug_marker(
      [&gl]() { gl.PopDebugGroup(); });
  if (!label.empty()) {
    gl.PushDebugGroup(label);
  } else {
    pop_pass_debug_marker.Release();
  }
#endif  // IMPELLER_DEBUG
 
  for (const auto& command : commands) {
#ifdef IMPELLER_DEBUG
    fml::ScopedCleanupClosure pop_cmd_debug_marker(
        [&gl]() { gl.PopDebugGroup(); });
    auto label = command->GetLabel();
    if (!label.empty()) {
      gl.PushDebugGroup(label);
    } else {
      pop_cmd_debug_marker.Release();
    }
#endif  // IMPELLER_DEBUG
 
    if (!command->Encode(reactor)) {
      return false;
    }
  }
 
  return true;
}

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

EncodeCommandsInReactor() [2/2]

bool impeller::EncodeCommandsInReactor	(	const RenderPassData &	pass_data,
		const ReactorGLES &	reactor,
		const std::vector< Command > &	commands,
		const std::vector< BufferView > &	vertex_buffers,
		const std::vector< TextureAndSampler > &	bound_textures,
		const std::vector< BufferResource > &	bound_buffers,
		const std::shared_ptr< GPUTracerGLES > &	tracer
	)

Setup the viewport.

Configure blending.

Setup stencil.

Configure depth.

Setup the viewport.

Setup the scissor rect.

Setup culling.

Setup winding order.

Bind vertex buffers.

Note: There is no need to run RenderPass::ValidateVertexBuffers or RenderPass::ValidateIndexBuffer here, as validation already runs when the vertex/index buffers are set on the command.

Bind the pipeline program.

Bind uniform data.

Determine the primitive type.

Finally! Invoke the draw call.

Unbind vertex attribs.

Definition at line 192 of file render_pass_gles.cc.

                                                {
  TRACE_EVENT0("impeller", "RenderPassGLES::EncodeCommandsInReactor");
 
  const auto& gl = reactor.GetProcTable();
#ifdef IMPELLER_DEBUG
  tracer->MarkFrameStart(gl);
 
  fml::ScopedCleanupClosure pop_pass_debug_marker(
      [&gl]() { gl.PopDebugGroup(); });
  if (!pass_data.label.empty()) {
    gl.PushDebugGroup(pass_data.label);
  } else {
    pop_pass_debug_marker.Release();
  }
#endif  // IMPELLER_DEBUG
 
  TextureGLES& color_gles = TextureGLES::Cast(*pass_data.color_attachment);
  const bool is_default_fbo = color_gles.IsWrapped();
 
  std::optional<GLuint> fbo = 0;
  if (is_default_fbo) {
    if (color_gles.GetFBO().has_value()) {
      // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
      gl.BindFramebuffer(GL_FRAMEBUFFER, *color_gles.GetFBO());
    }
  } else {
    // Create and bind an offscreen FBO.
    if (!color_gles.GetCachedFBO().IsDead()) {
      fbo = reactor.GetGLHandle(color_gles.GetCachedFBO());
      if (!fbo.has_value()) {
        return false;
      }
      gl.BindFramebuffer(GL_FRAMEBUFFER, fbo.value());
    } else {
      HandleGLES cached_fbo =
          reactor.CreateUntrackedHandle(HandleType::kFrameBuffer);
      color_gles.SetCachedFBO(cached_fbo);
      fbo = reactor.GetGLHandle(cached_fbo);
      if (!fbo.has_value()) {
        return false;
      }
      gl.BindFramebuffer(GL_FRAMEBUFFER, fbo.value());
 
      if (!color_gles.SetAsFramebufferAttachment(
              GL_FRAMEBUFFER, TextureGLES::AttachmentType::kColor0)) {
        return false;
      }
 
      if (auto depth = TextureGLES::Cast(pass_data.depth_attachment.get())) {
        if (!depth->SetAsFramebufferAttachment(
                GL_FRAMEBUFFER, TextureGLES::AttachmentType::kDepth)) {
          return false;
        }
      }
      if (auto stencil =
              TextureGLES::Cast(pass_data.stencil_attachment.get())) {
        if (!stencil->SetAsFramebufferAttachment(
                GL_FRAMEBUFFER, TextureGLES::AttachmentType::kStencil)) {
          return false;
        }
      }
 
      auto status = gl.CheckFramebufferStatus(GL_FRAMEBUFFER);
      if (status != GL_FRAMEBUFFER_COMPLETE) {
        VALIDATION_LOG << "Could not create a complete framebuffer: "
                       << DebugToFramebufferError(status);
        return false;
      }
    }
  }
 
  gl.ClearColor(pass_data.clear_color.red,    // red
                pass_data.clear_color.green,  // green
                pass_data.clear_color.blue,   // blue
                pass_data.clear_color.alpha   // alpha
  );
  if (pass_data.depth_attachment) {
    if (gl.DepthRangef.IsAvailable()) {
      gl.ClearDepthf(pass_data.clear_depth);
    } else {
      gl.ClearDepth(pass_data.clear_depth);
    }
  }
  if (pass_data.stencil_attachment) {
    gl.ClearStencil(pass_data.clear_stencil);
  }
 
  GLenum clear_bits = 0u;
  if (pass_data.clear_color_attachment) {
    clear_bits |= GL_COLOR_BUFFER_BIT;
  }
  if (pass_data.clear_depth_attachment) {
    clear_bits |= GL_DEPTH_BUFFER_BIT;
  }
  if (pass_data.clear_stencil_attachment) {
    clear_bits |= GL_STENCIL_BUFFER_BIT;
  }
 
  RenderPassGLES::ResetGLState(gl);
 
  gl.Clear(clear_bits);
 
  // Both the viewport and scissor are specified in framebuffer coordinates.
  // Impeller's framebuffer coordinate system is top left origin, but OpenGL's
  // is bottom left origin, so we convert the coordinates here.
  ISize target_size = pass_data.color_attachment->GetSize();
 
  //--------------------------------------------------------------------------
  /// Setup the viewport.
  ///
  const auto& viewport = pass_data.viewport;
  gl.Viewport(viewport.rect.GetX(),  // x
              target_size.height - viewport.rect.GetY() -
                  viewport.rect.GetHeight(),  // y
              viewport.rect.GetWidth(),       // width
              viewport.rect.GetHeight()       // height
  );
  if (pass_data.depth_attachment) {
    if (gl.DepthRangef.IsAvailable()) {
      gl.DepthRangef(viewport.depth_range.z_near, viewport.depth_range.z_far);
    } else {
      gl.DepthRange(viewport.depth_range.z_near, viewport.depth_range.z_far);
    }
  }
 
  CullMode current_cull_mode = CullMode::kNone;
  WindingOrder current_winding_order = WindingOrder::kClockwise;
  gl.FrontFace(GL_CW);
 
  for (const auto& command : commands) {
#ifdef IMPELLER_DEBUG
    fml::ScopedCleanupClosure pop_cmd_debug_marker(
        [&gl]() { gl.PopDebugGroup(); });
    if (!command.label.empty()) {
      gl.PushDebugGroup(command.label);
    } else {
      pop_cmd_debug_marker.Release();
    }
#endif  // IMPELLER_DEBUG
 
    const auto& pipeline = PipelineGLES::Cast(*command.pipeline);
 
    const auto* color_attachment =
        pipeline.GetDescriptor().GetLegacyCompatibleColorAttachment();
    if (!color_attachment) {
      VALIDATION_LOG
          << "Color attachment is too complicated for a legacy renderer.";
      return false;
    }
 
    //--------------------------------------------------------------------------
    /// Configure blending.
    ///
    ConfigureBlending(gl, color_attachment);
 
    //--------------------------------------------------------------------------
    /// Setup stencil.
    ///
    ConfigureStencil(gl, pipeline.GetDescriptor(), command.stencil_reference);
 
    //--------------------------------------------------------------------------
    /// Configure depth.
    ///
    if (auto depth =
            pipeline.GetDescriptor().GetDepthStencilAttachmentDescriptor();
        depth.has_value()) {
      gl.Enable(GL_DEPTH_TEST);
      gl.DepthFunc(ToCompareFunction(depth->depth_compare));
      gl.DepthMask(depth->depth_write_enabled ? GL_TRUE : GL_FALSE);
    } else {
      gl.Disable(GL_DEPTH_TEST);
    }
 
    //--------------------------------------------------------------------------
    /// Setup the viewport.
    ///
    if (command.viewport.has_value()) {
      gl.Viewport(viewport.rect.GetX(),  // x
                  target_size.height - viewport.rect.GetY() -
                      viewport.rect.GetHeight(),  // y
                  viewport.rect.GetWidth(),       // width
                  viewport.rect.GetHeight()       // height
      );
      if (pass_data.depth_attachment) {
        if (gl.DepthRangef.IsAvailable()) {
          gl.DepthRangef(viewport.depth_range.z_near,
                         viewport.depth_range.z_far);
        } else {
          gl.DepthRange(viewport.depth_range.z_near,
                        viewport.depth_range.z_far);
        }
      }
    }
 
    //--------------------------------------------------------------------------
    /// Setup the scissor rect.
    ///
    if (command.scissor.has_value()) {
      const auto& scissor = command.scissor.value();
      gl.Enable(GL_SCISSOR_TEST);
      gl.Scissor(
          scissor.GetX(),                                             // x
          target_size.height - scissor.GetY() - scissor.GetHeight(),  // y
          scissor.GetWidth(),                                         // width
          scissor.GetHeight()                                         // height
      );
    }
 
    //--------------------------------------------------------------------------
    /// Setup culling.
    ///
    CullMode pipeline_cull_mode = pipeline.GetDescriptor().GetCullMode();
    if (current_cull_mode != pipeline_cull_mode) {
      switch (pipeline_cull_mode) {
        case CullMode::kNone:
          gl.Disable(GL_CULL_FACE);
          break;
        case CullMode::kFrontFace:
          gl.Enable(GL_CULL_FACE);
          gl.CullFace(GL_FRONT);
          break;
        case CullMode::kBackFace:
          gl.Enable(GL_CULL_FACE);
          gl.CullFace(GL_BACK);
          break;
      }
      current_cull_mode = pipeline_cull_mode;
    }
 
    //--------------------------------------------------------------------------
    /// Setup winding order.
    ///
    WindingOrder pipeline_winding_order =
        pipeline.GetDescriptor().GetWindingOrder();
    if (current_winding_order != pipeline_winding_order) {
      switch (pipeline.GetDescriptor().GetWindingOrder()) {
        case WindingOrder::kClockwise:
          gl.FrontFace(GL_CW);
          break;
        case WindingOrder::kCounterClockwise:
          gl.FrontFace(GL_CCW);
          break;
      }
      current_winding_order = pipeline_winding_order;
    }
 
    BufferBindingsGLES* vertex_desc_gles = pipeline.GetBufferBindings();
 
    //--------------------------------------------------------------------------
    /// Bind vertex buffers.
    ///
    /// Note: There is no need to run `RenderPass::ValidateVertexBuffers` or
    ///       `RenderPass::ValidateIndexBuffer` here, as validation already runs
    ///       when the vertex/index buffers are set on the command.
    ///
    for (size_t i = 0; i < command.vertex_buffers.length; i++) {
      if (!BindVertexBuffer(gl, vertex_desc_gles,
                            vertex_buffers[i + command.vertex_buffers.offset],
                            i)) {
        return false;
      }
    }
 
    //--------------------------------------------------------------------------
    /// Bind the pipeline program.
    ///
    if (!pipeline.BindProgram()) {
      return false;
    }
 
    //--------------------------------------------------------------------------
    /// Bind uniform data.
    ///
    if (!vertex_desc_gles->BindUniformData(
            gl,                                        //
            bound_textures,                            //
            bound_buffers,                             //
            /*texture_range=*/command.bound_textures,  //
            /*buffer_range=*/command.bound_buffers     //
            )) {
      return false;
    }
 
    //--------------------------------------------------------------------------
    /// Determine the primitive type.
    ///
    // GLES doesn't support setting the fill mode, so override the primitive
    // with GL_LINE_STRIP to somewhat emulate PolygonMode::kLine. This isn't
    // correct; full triangle outlines won't be drawn and disconnected
    // geometry may appear connected. However this can still be useful for
    // wireframe debug views.
    GLenum mode =
        pipeline.GetDescriptor().GetPolygonMode() == PolygonMode::kLine
            ? GL_LINE_STRIP
            : ToMode(pipeline.GetDescriptor().GetPrimitiveType());
 
    //--------------------------------------------------------------------------
    /// Finally! Invoke the draw call.
    ///
    if (command.index_type == IndexType::kNone) {
      gl.DrawArrays(mode, command.base_vertex, command.element_count);
    } else {
      // Bind the index buffer if necessary.
      auto index_buffer_view = command.index_buffer;
      const DeviceBuffer* index_buffer = index_buffer_view.GetBuffer();
      const auto& index_buffer_gles = DeviceBufferGLES::Cast(*index_buffer);
      if (!index_buffer_gles.BindAndUploadDataIfNecessary(
              DeviceBufferGLES::BindingType::kElementArrayBuffer)) {
        return false;
      }
      gl.DrawElements(mode,                             // mode
                      command.element_count,            // count
                      ToIndexType(command.index_type),  // type
                      reinterpret_cast<const GLvoid*>(static_cast<GLsizei>(
                          index_buffer_view.GetRange().offset))  // indices
      );
    }
 
    //--------------------------------------------------------------------------
    /// Unbind vertex attribs.
    ///
    if (!vertex_desc_gles->UnbindVertexAttributes(gl)) {
      return false;
    }
  }
 
  if (pass_data.resolve_attachment &&
      !gl.GetCapabilities()->SupportsImplicitResolvingMSAA() &&
      !is_default_fbo) {
    FML_DCHECK(pass_data.resolve_attachment != pass_data.color_attachment);
    // Perform multisample resolve via blit.
    // Create and bind a resolve FBO.
    GLuint resolve_fbo;
    gl.GenFramebuffers(1u, &resolve_fbo);
    gl.BindFramebuffer(GL_FRAMEBUFFER, resolve_fbo);
 
    if (!TextureGLES::Cast(*pass_data.resolve_attachment)
             .SetAsFramebufferAttachment(
                 GL_FRAMEBUFFER, TextureGLES::AttachmentType::kColor0)) {
      return false;
    }
 
    auto status = gl.CheckFramebufferStatus(GL_FRAMEBUFFER);
    if (gl.CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
      VALIDATION_LOG << "Could not create a complete frambuffer: "
                     << DebugToFramebufferError(status);
      return false;
    }
 
    // Bind MSAA renderbuffer to read framebuffer.
    gl.BindFramebuffer(GL_READ_FRAMEBUFFER, fbo.value());
    gl.BindFramebuffer(GL_DRAW_FRAMEBUFFER, resolve_fbo);
 
    RenderPassGLES::ResetGLState(gl);
    auto size = pass_data.color_attachment->GetSize();
 
    gl.BlitFramebuffer(/*srcX0=*/0,
                       /*srcY0=*/0,
                       /*srcX1=*/size.width,
                       /*srcY1=*/size.height,
                       /*dstX0=*/0,
                       /*dstY0=*/0,
                       /*dstX1=*/size.width,
                       /*dstY1=*/size.height,
                       /*mask=*/GL_COLOR_BUFFER_BIT,
                       /*filter=*/GL_NEAREST);
 
    gl.BindFramebuffer(GL_DRAW_FRAMEBUFFER, GL_NONE);
    gl.BindFramebuffer(GL_READ_FRAMEBUFFER, GL_NONE);
    gl.DeleteFramebuffers(1u, &resolve_fbo);
    // Rebind the original FBO so that we can discard it below.
    gl.BindFramebuffer(GL_FRAMEBUFFER, fbo.value());
  }
 
  if (gl.DiscardFramebufferEXT.IsAvailable()) {
    std::array<GLenum, 3> attachments;
    size_t attachment_count = 0;
 
    // TODO(130048): discarding stencil or depth on the default fbo causes Angle
    // to discard the entire render target. Until we know the reason, default to
    // storing.
    bool angle_safe = gl.GetCapabilities()->IsANGLE() ? !is_default_fbo : true;
 
    if (pass_data.discard_color_attachment) {
      attachments[attachment_count++] =
          (is_default_fbo ? GL_COLOR_EXT : GL_COLOR_ATTACHMENT0);
    }
    if (pass_data.discard_depth_attachment && angle_safe) {
      attachments[attachment_count++] =
          (is_default_fbo ? GL_DEPTH_EXT : GL_DEPTH_ATTACHMENT);
    }
 
    if (pass_data.discard_stencil_attachment && angle_safe) {
      attachments[attachment_count++] =
          (is_default_fbo ? GL_STENCIL_EXT : GL_STENCIL_ATTACHMENT);
    }
    gl.DiscardFramebufferEXT(GL_FRAMEBUFFER,     // target
                             attachment_count,   // attachments to discard
                             attachments.data()  // size
    );
  }
 
#ifdef IMPELLER_DEBUG
  if (is_default_fbo) {
    tracer->MarkFrameEnd(gl);
  }
#endif  // IMPELLER_DEBUG
 
  return true;
}

References impeller::Color::alpha, impeller::BufferBindingsGLES::BindUniformData(), BindVertexBuffer(), impeller::Color::blue, 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(), impeller::ReactorGLES::CreateUntrackedHandle(), DebugToFramebufferError(), impeller::RenderPassData::depth_attachment, impeller::RenderPassData::discard_color_attachment, impeller::RenderPassData::discard_depth_attachment, impeller::RenderPassData::discard_stencil_attachment, impeller::TextureGLES::GetCachedFBO(), impeller::TextureGLES::GetFBO(), impeller::ReactorGLES::GetGLHandle(), impeller::ReactorGLES::GetProcTable(), impeller::Color::green, impeller::TSize< T >::height, impeller::HandleGLES::IsDead(), impeller::TextureGLES::IsWrapped(), impeller::RenderPassData::label, impeller::ProcTableGLES::PushDebugGroup(), impeller::Color::red, impeller::RenderPassData::resolve_attachment, impeller::TextureGLES::SetAsFramebufferAttachment(), impeller::TextureGLES::SetCachedFBO(), impeller::RenderPassData::stencil_attachment, ToCompareFunction(), ToIndexType(), ToMode(), impeller::BufferBindingsGLES::UnbindVertexAttributes(), VALIDATION_LOG, and impeller::RenderPassData::viewport.

FindSwiftShaderICDAtKnownPaths()

static void impeller::FindSwiftShaderICDAtKnownPaths ( )

static

Definition at line 20 of file swiftshader_utilities.cc.

                                             {
  static constexpr const char* kSwiftShaderICDJSON = "vk_swiftshader_icd.json";
  static constexpr const char* kVulkanICDFileNamesEnvVariableKey =
      "VK_ICD_FILENAMES";
  const auto executable_directory_path =
      fml::paths::GetExecutableDirectoryPath();
  FML_CHECK(executable_directory_path.first);
  const auto executable_directory =
      fml::OpenDirectory(executable_directory_path.second.c_str(), false,
                         fml::FilePermission::kRead);
  FML_CHECK(executable_directory.is_valid());
  if (fml::FileExists(executable_directory, kSwiftShaderICDJSON)) {
    const auto icd_path = fml::paths::JoinPaths(
        {executable_directory_path.second, kSwiftShaderICDJSON});
#if FML_OS_WIN
    const auto success =
        ::SetEnvironmentVariableA(kVulkanICDFileNamesEnvVariableKey,  //
                                  icd_path.c_str()                    //
                                  ) != 0;
#else   // FML_OS_WIN
    const auto success = ::setenv(kVulkanICDFileNamesEnvVariableKey,  //
                                  icd_path.c_str(),                   //
                                  1  // overwrite
                                  ) == 0;
#endif  // FML_OS_WIN
    FML_CHECK(success)
        << "Could not set the environment variable to use SwiftShader.";
  } else {
    FML_CHECK(false)
        << "Was asked to use SwiftShader but could not find the installable "
           "client driver (ICD) for the locally built SwiftShader.";
  }
}

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.

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

Referenced by impeller::ComputePlaygroundTest::GetWindowTitle().

FramebufferStatusToString()

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

static

Definition at line 216 of file proc_table_gles.cc.

                                                            {
  switch (status) {
    case GL_FRAMEBUFFER_COMPLETE:
      return "GL_FRAMEBUFFER_COMPLETE";
    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
      return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
#if GL_ES_VERSION_2_0
    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
      return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
#endif
    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
      return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
    case GL_FRAMEBUFFER_UNSUPPORTED:
      return "GL_FRAMEBUFFER_UNSUPPORTED";
    case GL_INVALID_ENUM:
      return "GL_INVALID_ENUM";
  }
 
  return "Unknown FBO Error Status";
}

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

FromMTLLoadAction()

constexpr LoadAction impeller::FromMTLLoadAction ( MTLLoadAction  action )

constexpr

Definition at line 292 of file formats_mtl.h.

                                                             {
  switch (action) {
    case MTLLoadActionDontCare:
      return LoadAction::kDontCare;
    case MTLLoadActionLoad:
      return LoadAction::kLoad;
    case MTLLoadActionClear:
      return LoadAction::kClear;
    default:
      break;
  }
 
  return LoadAction::kDontCare;
}

References kClear, kDontCare, and kLoad.

FromMTLPixelFormat()

constexpr PixelFormat impeller::FromMTLPixelFormat ( MTLPixelFormat  format )

constexpr

Definition at line 22 of file formats_mtl.h.

                                                                {
  switch (format) {
    case MTLPixelFormatInvalid:
      return PixelFormat::kUnknown;
    case MTLPixelFormatBGRA8Unorm:
      return PixelFormat::kB8G8R8A8UNormInt;
    case MTLPixelFormatBGRA8Unorm_sRGB:
      return PixelFormat::kB8G8R8A8UNormIntSRGB;
    case MTLPixelFormatRGBA8Unorm:
      return PixelFormat::kR8G8B8A8UNormInt;
    case MTLPixelFormatRGBA8Unorm_sRGB:
      return PixelFormat::kR8G8B8A8UNormIntSRGB;
    case MTLPixelFormatRGBA32Float:
      return PixelFormat::kR32G32B32A32Float;
    case MTLPixelFormatRGBA16Float:
      return PixelFormat::kR16G16B16A16Float;
    case MTLPixelFormatStencil8:
      return PixelFormat::kS8UInt;
#if !FML_OS_IOS
    case MTLPixelFormatDepth24Unorm_Stencil8:
      return PixelFormat::kD24UnormS8Uint;
#endif  // FML_OS_IOS
    case MTLPixelFormatDepth32Float_Stencil8:
      return PixelFormat::kD32FloatS8UInt;
    case MTLPixelFormatBGR10_XR_sRGB:
      return PixelFormat::kB10G10R10XRSRGB;
    case MTLPixelFormatBGR10_XR:
      return PixelFormat::kB10G10R10XR;
    case MTLPixelFormatBGRA10_XR:
      return PixelFormat::kB10G10R10A10XR;
    default:
      return PixelFormat::kUnknown;
  }
  return PixelFormat::kUnknown;
}

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

Referenced by WrapTextureMTL(), and WrapTextureWithRenderTarget().

FromMTLStoreAction()

constexpr StoreAction impeller::FromMTLStoreAction ( MTLStoreAction  action )

constexpr

Definition at line 321 of file formats_mtl.h.

                                                                {
  switch (action) {
    case MTLStoreActionDontCare:
      return StoreAction::kDontCare;
    case MTLStoreActionStore:
      return StoreAction::kStore;
    case MTLStoreActionMultisampleResolve:
      return StoreAction::kMultisampleResolve;
    case MTLStoreActionStoreAndMultisampleResolve:
      return StoreAction::kStoreAndMultisampleResolve;
    default:
      break;
  }
  return StoreAction::kDontCare;
}

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

FromRGB()

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

inlinestaticconstexpr

Definition at line 115 of file color.cc.

                                                                   {
  return {color.x, color.y, color.z, alpha};
}

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

Referenced by ApplyBlendedColor().

GenerateBlurInfo()

KernelSamples impeller::GenerateBlurInfo

(

BlurParameters

parameters

)

Definition at line 912 of file gaussian_blur_filter_contents.cc.

                                                          {
  KernelSamples result;
  result.sample_count =
      ((2 * parameters.blur_radius) / parameters.step_size) + 1;
 
  // Chop off the last samples if the radius >= 16 where they can account for
  // < 1.56% of the result.
  int x_offset = 0;
  if (parameters.blur_radius >= 16) {
    result.sample_count -= 2;
    x_offset = 1;
  }
 
  // This is a safe-guard to make sure we don't overflow the fragment shader.
  // The kernel size is multiplied by 2 since we'll use the lerp hack on the
  // result. In practice this isn't throwing away much data since the blur radii
  // are around 53 before the down-sampling and max sigma of 500 kick in.
  //
  // TODO(https://github.com/flutter/flutter/issues/150462): Come up with a more
  // wholistic remedy for this.  A proper downsample size should not make this
  // required. Or we can increase the kernel size.
  if (result.sample_count > KernelSamples::kMaxKernelSize) {
    result.sample_count = KernelSamples::kMaxKernelSize;
  }
 
  Scalar tally = 0.0f;
  for (int i = 0; i < result.sample_count; ++i) {
    int x = x_offset + (i * parameters.step_size) - parameters.blur_radius;
    result.samples[i] = KernelSample{
        .uv_offset = parameters.blur_uv_offset * x,
        .coefficient = expf(-0.5f * (x * x) /
                            (parameters.blur_sigma * parameters.blur_sigma)) /
                       (sqrtf(2.0f * M_PI) * parameters.blur_sigma),
    };
    tally += result.samples[i].coefficient;
  }
 
  // Make sure everything adds up to 1.
  for (auto& sample : result.samples) {
    sample.coefficient /= tally;
  }
 
  return result;
}

References impeller::BlurParameters::blur_radius, impeller::BlurParameters::blur_sigma, impeller::BlurParameters::blur_uv_offset, impeller::KernelSample::coefficient, impeller::KernelSamples::kMaxKernelSize, impeller::KernelSamples::sample_count, impeller::KernelSamples::samples, impeller::BlurParameters::step_size, impeller::KernelSample::uv_offset, and x.

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

GetAdrenoVersion()

AdrenoGPU impeller::GetAdrenoVersion

(

std::string_view

version

)

The format that Adreno names follow is "Adreno (TM) VERSION".

Definition at line 108 of file driver_info_vk.cc.

                                                   {
  /// The format that Adreno names follow is "Adreno (TM) VERSION".
  auto paren_pos = version.find("Adreno (TM) ");
  if (paren_pos == std::string::npos) {
    return AdrenoGPU::kUnknown;
  }
  auto version_string = version.substr(paren_pos + 12);
  const auto& result = kAdrenoVersions.find(version_string);
  if (result == kAdrenoVersions.end()) {
    return AdrenoGPU::kUnknown;
  }
  return result->second;
}

References kAdrenoVersions, and kUnknown.

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

GetBytesPerPixel()

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

static

Definition at line 46 of file decompressed_image.cc.

                                                               {
  switch (format) {
    case DecompressedImage::Format::kInvalid:
      return 0u;
    case DecompressedImage::Format::kGrey:
      return 1u;
    case DecompressedImage::Format::kGreyAlpha:
      return 1u;
    case DecompressedImage::Format::kRGB:
      return 3u;
    case DecompressedImage::Format::kRGBA:
      return 4;
  }
  return 0u;
}

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

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

GetCPUColorFilterProc()

ColorFilterProc impeller::GetCPUColorFilterProc

(

const flutter::DlColorFilter *

filter

)

Definition at line 66 of file color_filter.cc.

                                                                          {
  FML_DCHECK(filter);
 
  switch (filter->type()) {
    case flutter::DlColorFilterType::kBlend: {
      const flutter::DlBlendColorFilter* blend_filter = filter->asBlend();
      FML_DCHECK(blend_filter);
 
      return [filter_blend_mode = static_cast<BlendMode>(blend_filter->mode()),
              filter_color = skia_conversions::ToColor(blend_filter->color())](
                 Color color) {
        return color.Blend(filter_color, filter_blend_mode);
      };
    }
    case flutter::DlColorFilterType::kMatrix: {
      const flutter::DlMatrixColorFilter* matrix_filter = filter->asMatrix();
      FML_DCHECK(matrix_filter);
 
      impeller::ColorMatrix color_matrix;
      matrix_filter->get_matrix(color_matrix.array);
      return [color_matrix = color_matrix](Color color) {
        return color.ApplyColorMatrix(color_matrix);
      };
    }
    case flutter::DlColorFilterType::kSrgbToLinearGamma: {
      return [](Color color) { return color.SRGBToLinear(); };
    }
 
    case flutter::DlColorFilterType::kLinearToSrgbGamma: {
      return [](Color color) { return color.LinearToSRGB(); };
    }
  }
 
  FML_UNREACHABLE();
}

References impeller::ColorMatrix::array, impeller::Color::Blend(), and impeller::skia_conversions::ToColor().

GetExtensionName() [1/4]

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

static

Definition at line 202 of file capabilities_vk.cc.

                                                                          {
  switch (ext) {
    case OptionalAndroidDeviceExtensionVK::kKHRExternalFenceFd:
      return VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME;
    case OptionalAndroidDeviceExtensionVK::kKHRExternalFence:
      return VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME;
    case OptionalAndroidDeviceExtensionVK::kKHRExternalSemaphoreFd:
      return VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME;
    case OptionalAndroidDeviceExtensionVK::kKHRExternalSemaphore:
      return VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME;
    case OptionalAndroidDeviceExtensionVK::kLast:
      return "Unknown";
  }
}

References kKHRExternalFence, kKHRExternalFenceFd, kKHRExternalSemaphore, kKHRExternalSemaphoreFd, and kLast.

GetExtensionName() [2/4]

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

static

Definition at line 217 of file capabilities_vk.cc.

                                                                   {
  switch (ext) {
    case OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback:
      return VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME;
    case OptionalDeviceExtensionVK::kVKKHRPortabilitySubset:
      return "VK_KHR_portability_subset";
    case OptionalDeviceExtensionVK::kEXTImageCompressionControl:
      return VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME;
    case OptionalDeviceExtensionVK::kLast:
      return "Unknown";
  }
  FML_UNREACHABLE();
}

References kEXTImageCompressionControl, kEXTPipelineCreationFeedback, kLast, and kVKKHRPortabilitySubset.

GetExtensionName() [3/4]

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

static

Definition at line 183 of file capabilities_vk.cc.

                                                                          {
  switch (ext) {
    case RequiredAndroidDeviceExtensionVK::
        kANDROIDExternalMemoryAndroidHardwareBuffer:
      return "VK_ANDROID_external_memory_android_hardware_buffer";
    case RequiredAndroidDeviceExtensionVK::kKHRSamplerYcbcrConversion:
      return VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME;
    case RequiredAndroidDeviceExtensionVK::kKHRExternalMemory:
      return VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME;
    case RequiredAndroidDeviceExtensionVK::kEXTQueueFamilyForeign:
      return VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME;
    case RequiredAndroidDeviceExtensionVK::kKHRDedicatedAllocation:
      return VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME;
    case RequiredAndroidDeviceExtensionVK::kLast:
      return "Unknown";
  }
  FML_UNREACHABLE();
}

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

GetExtensionName() [4/4]

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

static

Definition at line 173 of file capabilities_vk.cc.

                                                                         {
  switch (ext) {
    case RequiredCommonDeviceExtensionVK::kKHRSwapchain:
      return VK_KHR_SWAPCHAIN_EXTENSION_NAME;
    case RequiredCommonDeviceExtensionVK::kLast:
      return "Unknown";
  }
  FML_UNREACHABLE();
}

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 81 of file fence_waiter_vk.cc.

                                                                  {
  std::vector<vk::Fence> fences;
  for (const auto& entry : set) {
    if (!entry->IsSignalled()) {
      fences.emplace_back(entry->GetFence());
    }
  }
  return fences;
}

GetGLString()

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

static

Definition at line 21 of file description_gles.cc.

                                                                   {
  auto str = gl.GetString(name);
  if (str == nullptr) {
    return "";
  }
  return reinterpret_cast<const char*>(str);
}

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.

                                           {
  auto str = gl.GetStringi(name, index);
  if (str == nullptr) {
    return "";
  }
  return reinterpret_cast<const char*>(str);
}

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

GetImageInfo()

static SkImageInfo impeller::GetImageInfo ( const GlyphAtlas &  atlas, Size  size  )

static

Definition at line 89 of file typographer_context_skia.cc.

                                                                    {
  switch (atlas.GetType()) {
    case GlyphAtlas::Type::kAlphaBitmap:
      return SkImageInfo::MakeA8(SkISize{static_cast<int32_t>(size.width),
                                         static_cast<int32_t>(size.height)});
    case GlyphAtlas::Type::kColorBitmap:
      return SkImageInfo::MakeN32Premul(size.width, size.height);
  }
  FML_UNREACHABLE();
}

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

Referenced by BulkUpdateAtlasBitmap(), and UpdateAtlasBitmap().

GetMaliVersion()

MaliGPU impeller::GetMaliVersion

(

std::string_view

version

)

Definition at line 133 of file driver_info_vk.cc.

                                               {
  // These names are usually Mali-VERSION or Mali-Version-EXTRA_CRAP.
  auto dash_pos = version.find("Mali-");
  if (dash_pos == std::string::npos) {
    return MaliGPU::kUnknown;
  }
  auto version_string_with_trailing = version.substr(dash_pos + 5);
  // Remove any trailing crap if present.
  auto more_dash_pos = version_string_with_trailing.find("-");
  if (more_dash_pos != std::string::npos) {
    version_string_with_trailing =
        version_string_with_trailing.substr(0, more_dash_pos);
  }
 
  const auto& result = kMaliVersions.find(version_string_with_trailing);
  if (result == kMaliVersions.end()) {
    return MaliGPU::kUnknown;
  }
  return result->second;
}

References kMaliVersions, and kUnknown.

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

GetMTLComputePipelineDescriptor()

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

static

Definition at line 88 of file pipeline_library_mtl.mm.

                                           {
  auto descriptor = [[MTLComputePipelineDescriptor alloc] init];
  descriptor.label = @(desc.GetLabel().c_str());
  descriptor.computeFunction =
      ShaderFunctionMTL::Cast(*desc.GetStageEntrypoint()).GetMTLFunction();
  return descriptor;
}

References impeller::ComputePipelineDescriptor::GetLabel(), and impeller::ComputePipelineDescriptor::GetStageEntrypoint().

GetMTLRenderPipelineDescriptor()

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

static

Definition at line 32 of file pipeline_library_mtl.mm.

                                                                     {
  auto descriptor = [[MTLRenderPipelineDescriptor alloc] init];
  descriptor.label = @(desc.GetLabel().data());
  descriptor.rasterSampleCount = static_cast<NSUInteger>(desc.GetSampleCount());
  bool created_specialized_function = false;
 
  if (const auto& vertex_descriptor = desc.GetVertexDescriptor()) {
    VertexDescriptorMTL vertex_descriptor_mtl;
    if (vertex_descriptor_mtl.SetStageInputsAndLayout(
            vertex_descriptor->GetStageInputs(),
            vertex_descriptor->GetStageLayouts())) {
      descriptor.vertexDescriptor =
          vertex_descriptor_mtl.GetMTLVertexDescriptor();
    }
  }
 
  for (const auto& item : desc.GetColorAttachmentDescriptors()) {
    descriptor.colorAttachments[item.first] =
        ToMTLRenderPipelineColorAttachmentDescriptor(item.second);
  }
 
  descriptor.depthAttachmentPixelFormat =
      ToMTLPixelFormat(desc.GetDepthPixelFormat());
  descriptor.stencilAttachmentPixelFormat =
      ToMTLPixelFormat(desc.GetStencilPixelFormat());
 
  const auto& constants = desc.GetSpecializationConstants();
  for (const auto& entry : desc.GetStageEntrypoints()) {
    if (entry.first == ShaderStage::kVertex) {
      descriptor.vertexFunction =
          ShaderFunctionMTL::Cast(*entry.second).GetMTLFunction();
    }
    if (entry.first == ShaderStage::kFragment) {
      if (constants.empty()) {
        descriptor.fragmentFunction =
            ShaderFunctionMTL::Cast(*entry.second).GetMTLFunction();
      } else {
        // This code only expects a single specialized function per pipeline.
        FML_CHECK(!created_specialized_function);
        created_specialized_function = true;
        ShaderFunctionMTL::Cast(*entry.second)
            .GetMTLFunctionSpecialized(
                constants, [callback, descriptor](id<MTLFunction> function) {
                  descriptor.fragmentFunction = function;
                  callback(descriptor);
                });
      }
    }
  }
 
  if (!created_specialized_function) {
    callback(descriptor);
  }
}

References impeller::PipelineDescriptor::GetColorAttachmentDescriptors(), impeller::PipelineDescriptor::GetDepthPixelFormat(), impeller::PipelineDescriptor::GetLabel(), impeller::VertexDescriptorMTL::GetMTLVertexDescriptor(), impeller::PipelineDescriptor::GetSampleCount(), impeller::PipelineDescriptor::GetSpecializationConstants(), impeller::PipelineDescriptor::GetStageEntrypoints(), impeller::PipelineDescriptor::GetStencilPixelFormat(), impeller::PipelineDescriptor::GetVertexDescriptor(), impeller::VertexDescriptorMTL::SetStageInputsAndLayout(), ToMTLPixelFormat(), and ToMTLRenderPipelineColorAttachmentDescriptor().

GetPorterDuffSpecConstants()

std::array<std::vector<Scalar>, 15> impeller::GetPorterDuffSpecConstants

(

bool

supports_decal

)

Definition at line 505 of file content_context.cc.

                         {
  Scalar x = supports_decal ? 1 : 0;
  return {{
      {x, 0, 0, 0, 0, 0},    // Clear
      {x, 1, 0, 0, 0, 0},    // Source
      {x, 0, 0, 1, 0, 0},    // Destination
      {x, 1, 0, 1, -1, 0},   // SourceOver
      {x, 1, -1, 1, 0, 0},   // DestinationOver
      {x, 0, 1, 0, 0, 0},    // SourceIn
      {x, 0, 0, 0, 1, 0},    // DestinationIn
      {x, 1, -1, 0, 0, 0},   // SourceOut
      {x, 0, 0, 1, -1, 0},   // DestinationOut
      {x, 0, 1, 1, -1, 0},   // SourceATop
      {x, 1, -1, 0, 1, 0},   // DestinationATop
      {x, 1, -1, 1, -1, 0},  // Xor
      {x, 1, 0, 1, 0, 0},    // Plus
      {x, 0, 0, 0, 0, 1},    // Modulate
      {x, 0, 0, 1, 0, -1},   // Screen
  }};
}

References x.

Referenced by impeller::ContentContext::ContentContext().

GetPowerVRVersion()

PowerVRGPU impeller::GetPowerVRVersion

(

std::string_view

version

)

Definition at line 122 of file driver_info_vk.cc.

                                                     {
  // We don't really care about the specific model, just the series.
  if (version.find("DXT") != std::string::npos) {
    return PowerVRGPU::kDXT;
  }
  if (version.find("CXT") != std::string::npos) {
    return PowerVRGPU::kCXT;
  }
  return PowerVRGPU::kUnknown;
}

References kCXT, kDXT, and kUnknown.

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

GetQueueCreateInfos()

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

static

Definition at line 68 of file context_vk.cc.

                                              {
  std::map<size_t /* family */, size_t /* index */> family_index_map;
  for (const auto& queue : queues) {
    family_index_map[queue.family] = 0;
  }
  for (const auto& queue : queues) {
    auto value = family_index_map[queue.family];
    family_index_map[queue.family] = std::max(value, queue.index);
  }
 
  static float kQueuePriority = 1.0f;
  std::vector<vk::DeviceQueueCreateInfo> infos;
  for (const auto& item : family_index_map) {
    vk::DeviceQueueCreateInfo info;
    info.setQueueFamilyIndex(item.first);
    info.setQueueCount(item.second + 1);
    info.setQueuePriorities(kQueuePriority);
    infos.push_back(info);
  }
  return infos;
}

References value.

GetShaderClipDepth()

static Scalar impeller::GetShaderClipDepth ( uint32_t  clip_depth )

static

Definition at line 20 of file clip_contents.cc.

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

References impeller::Entity::GetShaderClipDepth().

Referenced by impeller::ClipContents::Render(), and RenderClipRestore().

GetShaderInfoLog()

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

static

Definition at line 22 of file pipeline_library_gles.cc.

                                                                          {
  GLint log_length = 0;
  gl.GetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
  if (log_length == 0) {
    return "";
  }
  auto log_buffer =
      reinterpret_cast<char*>(std::calloc(log_length, sizeof(char)));
  gl.GetShaderInfoLog(shader, log_length, &log_length, log_buffer);
  auto log_string = std::string(log_buffer, log_length);
  std::free(log_buffer);
  return log_string;
}

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.

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

References data.

Referenced by LinkProgram(), and LogShaderCompilationFailure().

GetShaderType()

static ShaderType impeller::GetShaderType ( RuntimeUniformType  type )

static

Definition at line 75 of file runtime_effect_contents.cc.

                                                         {
  switch (type) {
    case kSampledImage:
      return ShaderType::kSampledImage;
    case kFloat:
      return ShaderType::kFloat;
    case kStruct:
      return ShaderType::kStruct;
  }
}

References kFloat, kSampledImage, kStruct, and type.

Referenced by MakeShaderMetadata().

GetSupportedDeviceExtensions()

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

static

Definition at line 244 of file capabilities_vk.cc.

                                             {
  auto device_extensions = physical_device.enumerateDeviceExtensionProperties();
  if (device_extensions.result != vk::Result::eSuccess) {
    return std::nullopt;
  }
 
  std::set<std::string> exts;
  for (const auto& device_extension : device_extensions.value) {
    exts.insert(device_extension.extensionName);
  };
 
  return exts;
}

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

GetVKClearValues()

static size_t impeller::GetVKClearValues ( const RenderTarget &  target, std::array< vk::ClearValue, kMaxAttachments > &  values  )

static

Definition at line 52 of file render_pass_vk.cc.

                                                     {
  size_t offset = 0u;
  target.IterateAllColorAttachments(
      [&values, &offset](size_t index,
                         const ColorAttachment& attachment) -> bool {
        values.at(offset++) = VKClearValueFromColor(attachment.clear_color);
        if (attachment.resolve_texture) {
          values.at(offset++) = VKClearValueFromColor(attachment.clear_color);
        }
        return true;
      });
 
  const auto& depth = target.GetDepthAttachment();
  const auto& stencil = target.GetStencilAttachment();
 
  if (depth.has_value()) {
    values.at(offset++) = VKClearValueFromDepthStencil(
        stencil ? stencil->clear_stencil : 0u, depth->clear_depth);
  } else if (stencil.has_value()) {
    values.at(offset++) = VKClearValueFromDepthStencil(
        stencil->clear_stencil, depth ? depth->clear_depth : 0.0f);
  }
  return offset;
}

References impeller::ColorAttachment::clear_color, impeller::RenderTarget::GetDepthAttachment(), impeller::RenderTarget::GetStencilAttachment(), impeller::RenderTarget::IterateAllColorAttachments(), impeller::Attachment::resolve_texture, VKClearValueFromColor(), and VKClearValueFromDepthStencil().

GetWorkaroundsFromDriverInfo()

WorkaroundsVK impeller::GetWorkaroundsFromDriverInfo

(

DriverInfoVK &

driver_info

)

Definition at line 10 of file workarounds_vk.cc.

                                                                      {
  WorkaroundsVK workarounds;
 
  const auto& adreno_gpu = driver_info.GetAdrenoGPUInfo();
  const auto& powervr_gpu = driver_info.GetPowerVRGPUInfo();
 
  if (adreno_gpu.has_value()) {
    workarounds.slow_primitive_restart_performance = true;
    workarounds.broken_mipmap_generation = true;
 
    if (adreno_gpu.value() <= AdrenoGPU::kAdreno630) {
      workarounds.input_attachment_self_dependency_broken = true;
      workarounds.batch_submit_command_buffer_timeout = true;
    }
  } else if (powervr_gpu.has_value()) {
    workarounds.input_attachment_self_dependency_broken = true;
  }
  return workarounds;
}

References impeller::WorkaroundsVK::batch_submit_command_buffer_timeout, impeller::WorkaroundsVK::broken_mipmap_generation, impeller::DriverInfoVK::GetAdrenoGPUInfo(), impeller::DriverInfoVK::GetPowerVRGPUInfo(), impeller::WorkaroundsVK::input_attachment_self_dependency_broken, kAdreno630, and impeller::WorkaroundsVK::slow_primitive_restart_performance.

Referenced by impeller::testing::CanBatchSubmitTest(), impeller::testing::CanUseFramebufferFetch(), impeller::testing::CanUseMipgeneration(), impeller::testing::CanUsePrimitiveRestartSubmitTest(), and impeller::testing::TEST().

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.

                                  {
  switch (value) {
    case GL_NO_ERROR:
      return false;
    case GL_INVALID_ENUM:
    case GL_INVALID_VALUE:
    case GL_INVALID_OPERATION:
    case GL_INVALID_FRAMEBUFFER_OPERATION:
    case GL_OUT_OF_MEMORY:
      return true;
  }
  return false;
}

References value.

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

GLErrorToString()

const char * impeller::GLErrorToString

(

GLenum

value

)

Definition at line 18 of file proc_table_gles.cc.

                                          {
  switch (value) {
    case GL_NO_ERROR:
      return "GL_NO_ERROR";
    case GL_INVALID_ENUM:
      return "GL_INVALID_ENUM";
    case GL_INVALID_VALUE:
      return "GL_INVALID_VALUE";
    case GL_INVALID_OPERATION:
      return "GL_INVALID_OPERATION";
    case GL_INVALID_FRAMEBUFFER_OPERATION:
      return "GL_INVALID_FRAMEBUFFER_OPERATION";
    case GL_FRAMEBUFFER_COMPLETE:
      return "GL_FRAMEBUFFER_COMPLETE";
    case GL_OUT_OF_MEMORY:
      return "GL_OUT_OF_MEMORY";
  }
  return "Unknown.";
}

References value.

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

GLESShaderNameToShaderKeyName()

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

static

Definition at line 29 of file shader_library_gles.cc.

                                                                    {
  std::stringstream stream;
  stream << name;
  switch (stage) {
    case ShaderStage::kUnknown:
      stream << "_unknown_";
      break;
    case ShaderStage::kVertex:
      stream << "_vertex_";
      break;
    case ShaderStage::kFragment:
      stream << "_fragment_";
      break;
    case ShaderStage::kCompute:
      stream << "_compute_";
      break;
  }
  stream << "main";
  return stream.str();
}

References kCompute, kFragment, kUnknown, and kVertex.

HandleTypeToString()

std::string impeller::HandleTypeToString

(

HandleType

type

)

Definition at line 11 of file handle_gles.cc.

                                              {
  switch (type) {
    case HandleType::kUnknown:
      return "Unknown";
    case HandleType::kTexture:
      return "Texture";
    case HandleType::kBuffer:
      return "Buffer";
    case HandleType::kProgram:
      return "Program";
    case HandleType::kRenderBuffer:
      return "RenderBuffer";
    case HandleType::kFrameBuffer:
      return "Framebuffer";
    case HandleType::kFence:
      return "Fence";
  }
  FML_UNREACHABLE();
}

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

Referenced by std::operator<<().

HasPrefix()

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

Definition at line 30 of file strings.cc.

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

Referenced by DetermineIfES(), and StripPrefix().

HasRequiredProperties()

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

static

Definition at line 365 of file capabilities_vk.cc.

                                                                           {
  auto properties = physical_device.getProperties();
  if (!(properties.limits.framebufferColorSampleCounts &
        (vk::SampleCountFlagBits::e1 | vk::SampleCountFlagBits::e4))) {
    return false;
  }
  return true;
}

References e1.

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

HasRequiredQueues()

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

static

Definition at line 374 of file capabilities_vk.cc.

                                                                       {
  auto queue_flags = vk::QueueFlags{};
  for (const auto& queue : physical_device.getQueueFamilyProperties()) {
    if (queue.queueCount == 0) {
      continue;
    }
    queue_flags |= queue.queueFlags;
  }
  return static_cast<VkQueueFlags>(queue_flags &
                                   (vk::QueueFlagBits::eGraphics |
                                    vk::QueueFlagBits::eCompute |
                                    vk::QueueFlagBits::eTransfer));
}

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.

                                                                 {
  auto position = string.rfind(suffix);
  if (position == std::string::npos) {
    return false;
  }
  return position == string.size() - suffix.size();
}

HasSuitableColorFormat()

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

static

Definition at line 340 of file capabilities_vk.cc.

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

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

HasSuitableDepthStencilFormat()

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

static

Definition at line 348 of file capabilities_vk.cc.

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

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

HasValidationLayers()

bool impeller::HasValidationLayers

(

)

Definition at line 53 of file context_vk.cc.

                           {
  return gHasValidationLayers;
}

References gHasValidationLayers.

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

HeapAlloc()

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

static

Definition at line 12 of file tessellator_libtess.cc.

                                                          {
  return malloc(size);
}

HeapFree()

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

static

Definition at line 20 of file tessellator_libtess.cc.

                                                {
  free(ptr);
}

HeapRealloc()

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

static

Definition at line 16 of file tessellator_libtess.cc.

                                                                       {
  return realloc(ptr, size);
}

IdentifyVendor()

constexpr VendorVK impeller::IdentifyVendor ( uint32_t  vendor )

constexpr

Definition at line 154 of file driver_info_vk.cc.

                                                   {
  // Check if the vendor has a PCI ID:
  // https://pcisig.com/membership/member-companies
  switch (vendor) {
    case 0x1AE0:
      return VendorVK::kGoogle;
    case 0x168C:
    case 0x17CB:
    case 0x1969:
    case 0x5143:
      return VendorVK::kQualcomm;
    case 0x13B5:
      return VendorVK::kARM;
    case 0x1010:
      return VendorVK::kImgTec;
    case 0x1002:
    case 0x1022:
      return VendorVK::kAMD;
    case 0x10DE:
      return VendorVK::kNvidia;
    case 0x8086:  // :)
      return VendorVK::kIntel;
    case 0x106B:
      return VendorVK::kApple;
    case 0x19E5:
      return VendorVK::kHuawei;
    case 0x144D:
      return VendorVK::kSamsung;
  }
  // Check if the ID is a known Khronos vendor.
  switch (vendor) {
    case VK_VENDOR_ID_MESA:
      return VendorVK::kMesa;
      // There are others but have never been observed. These can be added as
      // needed.
  }
  return VendorVK::kUnknown;
}

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

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

IMPELLER_ENUM_IS_MASK() [1/4]

impeller::IMPELLER_ENUM_IS_MASK

(

android::HardwareBufferUsageFlags

)

IMPELLER_ENUM_IS_MASK() [2/4]

impeller::IMPELLER_ENUM_IS_MASK

(

ColorWriteMaskBits

)

IMPELLER_ENUM_IS_MASK() [3/4]

impeller::IMPELLER_ENUM_IS_MASK

(

MyMaskBits

)

IMPELLER_ENUM_IS_MASK() [4/4]

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.

                                                         {
  FML_CHECK(false) << "Unimplemented: " << method << " in " << file << ":"
                   << line;
  std::abort();
}

ImpellerValidationBreak()

void impeller::ImpellerValidationBreak	(	const char *	message,
		const char *	file,
		int	line
	)

Definition at line 54 of file validation.cc.

                                                                              {
  if (sValidationFailureCallback &&
      sValidationFailureCallback(message, file, line)) {
    return;
  }
  const auto severity =
      ImpellerValidationErrorsAreFatal() ? fml::LOG_FATAL : fml::LOG_ERROR;
  auto fml_log = fml::LogMessage{severity, file, line, nullptr};
  fml_log.stream() <<
#if FLUTTER_RELEASE
      "Impeller validation: " << message;
#else   // FLUTTER_RELEASE
      "Break on '" << __FUNCTION__
                   << "' to inspect point of failure: " << message;
#endif  // FLUTTER_RELEASE
}

References ImpellerValidationErrorsAreFatal(), and sValidationFailureCallback.

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

ImpellerValidationErrorsAreFatal()

bool impeller::ImpellerValidationErrorsAreFatal

(

)

Definition at line 71 of file validation.cc.

                                        {
  return sValidationLogsAreFatal;
}

References sValidationLogsAreFatal.

Referenced by ImpellerValidationBreak(), and TEST().

ImpellerValidationErrorsSetCallback()

void impeller::ImpellerValidationErrorsSetCallback

(

ValidationFailureCallback

callback

)

Sets a callback that callers (usually tests) can set to intercept validation failures.

Returning true from the callback indicates that Impeller can continue and avoid any default behavior on tripping validation (which could include process termination).

Parameters

[in]

callback

The callback

Definition at line 21 of file validation.cc.

                                                                             {
  sValidationFailureCallback = std::move(callback);
}

References sValidationFailureCallback.

Referenced by impeller::PlaygroundTest::PlaygroundTest(), and impeller::PlaygroundTest::~PlaygroundTest().

ImpellerValidationErrorsSetFatal()

void impeller::ImpellerValidationErrorsSetFatal

(

bool

fatal

)

Definition at line 17 of file validation.cc.

                                                  {
  sValidationLogsAreFatal = fatal;
}

References sValidationLogsAreFatal.

Referenced by main().

InferMetalCapabilities()

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

static

Definition at line 49 of file context_mtl.mm.

                              {
  return CapabilitiesBuilder()
      .SetSupportsOffscreenMSAA(true)
      .SetSupportsSSBO(true)
      .SetSupportsTextureToTextureBlits(true)
      .SetSupportsDecalSamplerAddressMode(true)
      .SetSupportsFramebufferFetch(DeviceSupportsFramebufferFetch(device))
      .SetDefaultColorFormat(color_format)
      .SetDefaultStencilFormat(PixelFormat::kS8UInt)
      .SetDefaultDepthStencilFormat(PixelFormat::kD32FloatS8UInt)
      .SetSupportsCompute(true)
      .SetSupportsComputeSubgroups(DeviceSupportsComputeSubgroups(device))
      .SetSupportsReadFromResolve(true)
      .SetSupportsDeviceTransientTextures(true)
      .SetDefaultGlyphAtlasFormat(PixelFormat::kA8UNormInt)
      .SetSupportsTriangleFan(false)
      .SetMaximumRenderPassAttachmentSize(DeviceMaxTextureSizeSupported(device))
      .SetSupportsExtendedRangeFormats(
          DeviceSupportsExtendedRangeFormats(device))
#if FML_OS_IOS && !TARGET_OS_SIMULATOR
      .SetMinimumUniformAlignment(16)
#else
      .SetMinimumUniformAlignment(256)
#endif  // FML_OS_IOS && !TARGET_OS_SIMULATOR
      .Build();
}

References impeller::CapabilitiesBuilder::Build(), DeviceMaxTextureSizeSupported(), DeviceSupportsComputeSubgroups(), DeviceSupportsExtendedRangeFormats(), DeviceSupportsFramebufferFetch(), kA8UNormInt, kD32FloatS8UInt, kS8UInt, impeller::CapabilitiesBuilder::SetDefaultColorFormat(), impeller::CapabilitiesBuilder::SetDefaultDepthStencilFormat(), impeller::CapabilitiesBuilder::SetDefaultGlyphAtlasFormat(), impeller::CapabilitiesBuilder::SetDefaultStencilFormat(), impeller::CapabilitiesBuilder::SetMaximumRenderPassAttachmentSize(), impeller::CapabilitiesBuilder::SetMinimumUniformAlignment(), impeller::CapabilitiesBuilder::SetSupportsCompute(), impeller::CapabilitiesBuilder::SetSupportsComputeSubgroups(), impeller::CapabilitiesBuilder::SetSupportsDecalSamplerAddressMode(), impeller::CapabilitiesBuilder::SetSupportsDeviceTransientTextures(), impeller::CapabilitiesBuilder::SetSupportsExtendedRangeFormats(), impeller::CapabilitiesBuilder::SetSupportsFramebufferFetch(), impeller::CapabilitiesBuilder::SetSupportsOffscreenMSAA(), impeller::CapabilitiesBuilder::SetSupportsReadFromResolve(), impeller::CapabilitiesBuilder::SetSupportsSSBO(), impeller::CapabilitiesBuilder::SetSupportsTextureToTextureBlits(), and impeller::CapabilitiesBuilder::SetSupportsTriangleFan().

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

InferShaderTypefromFileExtension()

std::optional<ArchiveShaderType> impeller::InferShaderTypefromFileExtension

(

const std::filesystem::path &

path

)

Definition at line 20 of file shader_archive_writer.cc.

                                   {
#if FML_OS_QNX
  return std::nullopt;
#else   // FML_OS_QNX
  if (path == ".vert") {
    return ArchiveShaderType::kVertex;
  } else if (path == ".frag") {
    return ArchiveShaderType::kFragment;
  } else if (path == ".comp") {
    return ArchiveShaderType::kCompute;
  }
  return std::nullopt;
#endif  // FML_OS_QNX
}

References kCompute, kFragment, and kVertex.

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

InitializeGLFWOnce()

static void impeller::InitializeGLFWOnce ( )

static

Definition at line 58 of file playground.cc.

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

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 244 of file render_pass_builder_vk.cc.

                                                               {
  // This barrier must be a subset of the masks specified in the subpass
  // dependency setup.
  vk::ImageMemoryBarrier barrier;
  barrier.srcAccessMask = kSelfDependencySrcAccessMask;
  barrier.dstAccessMask = kSelfDependencyDstAccessMask;
  barrier.oldLayout = vk::ImageLayout::eGeneral;
  barrier.newLayout = vk::ImageLayout::eGeneral;
  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  barrier.image = image;
 
  vk::ImageSubresourceRange image_levels;
  image_levels.aspectMask = vk::ImageAspectFlagBits::eColor;
  image_levels.baseArrayLayer = 0u;
  image_levels.baseMipLevel = 0u;
  image_levels.layerCount = VK_REMAINING_ARRAY_LAYERS;
  image_levels.levelCount = VK_REMAINING_MIP_LEVELS;
  barrier.subresourceRange = image_levels;
 
  buffer.pipelineBarrier(kSelfDependencySrcStageMask,  //
                         kSelfDependencyDstStageMask,  //
                         kSelfDependencyFlags,         //
                         {},                           //
                         {},                           //
                         barrier                       //
  );
}

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

                                                                    {
  if (old_layout == new_layout) {
    return;
  }
 
  vk::ImageMemoryBarrier barrier;
  barrier.srcAccessMask = src_access_mask;
  barrier.dstAccessMask = dst_access_mask;
  barrier.oldLayout = old_layout;
  barrier.newLayout = new_layout;
  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  barrier.image = image;
  barrier.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
  barrier.subresourceRange.baseMipLevel = base_mip_level;
  barrier.subresourceRange.levelCount = mip_level_count;
  barrier.subresourceRange.baseArrayLayer = 0u;
  barrier.subresourceRange.layerCount = 1u;
 
  cmd.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier);
}

InvertPorterDuffBlend()

std::optional< BlendMode > impeller::InvertPorterDuffBlend

(

BlendMode

blend_mode

)

Definition at line 51 of file blend_filter_contents.cc.

                                                                   {
  switch (blend_mode) {
    case BlendMode::kClear:
      return BlendMode::kClear;
    case BlendMode::kSrc:
      return BlendMode::kDst;
    case BlendMode::kDst:
      return BlendMode::kSrc;
    case BlendMode::kSrcOver:
      return BlendMode::kDstOver;
    case BlendMode::kDstOver:
      return BlendMode::kSrcOver;
    case BlendMode::kSrcIn:
      return BlendMode::kDstIn;
    case BlendMode::kDstIn:
      return BlendMode::kSrcIn;
    case BlendMode::kSrcOut:
      return BlendMode::kDstOut;
    case BlendMode::kDstOut:
      return BlendMode::kSrcOut;
    case BlendMode::kSrcATop:
      return BlendMode::kDstATop;
    case BlendMode::kDstATop:
      return BlendMode::kSrcATop;
    case BlendMode::kXor:
      return BlendMode::kXor;
    case BlendMode::kPlus:
      return BlendMode::kPlus;
    case BlendMode::kModulate:
      return BlendMode::kModulate;
    default:
      return std::nullopt;
  }
}

References kClear, kDst, kDstATop, kDstIn, kDstOut, kDstOver, kModulate, kPlus, kSrc, kSrcATop, kSrcIn, kSrcOut, kSrcOver, and kXor.

Referenced by impeller::AtlasContents::Render(), and impeller::VerticesSimpleBlendContents::Render().

IPLR_CAPABILITY()

class impeller::IPLR_CAPABILITY

(

"mutex"

)

Definition at line 1 of file thread.h.

                                     {
 public:
  Mutex() = default;
 
  ~Mutex() = default;
 
  void Lock() IPLR_ACQUIRE() { mutex_.lock(); }
 
  void Unlock() IPLR_RELEASE() { mutex_.unlock(); }
 
 private:
  friend class ConditionVariable;
 
  std::mutex mutex_;
 
  Mutex(const Mutex&) = delete;
 
  Mutex(Mutex&&) = delete;
 
  Mutex& operator=(const Mutex&) = delete;
 
  Mutex& operator=(Mutex&&) = delete;
};

References IPLR_ACQUIRE, IPLR_ACQUIRE_SHARED, IPLR_RELEASE, and IPLR_RELEASE_SHARED.

IPLR_GUARDED_BY()

static std::unordered_map< uint64_t, std::unordered_map<std::thread::id, std::weak_ptr<CommandPoolVK> > > g_all_pools_map impeller::IPLR_GUARDED_BY ( g_all_pools_map_mutex  )

static

IsDepthWritable()

constexpr bool impeller::IsDepthWritable ( PixelFormat  format )

constexpr

Definition at line 119 of file formats.h.

                                                   {
  switch (format) {
    case PixelFormat::kD24UnormS8Uint:
    case PixelFormat::kD32FloatS8UInt:
      return true;
    default:
      return false;
  }
}

References kD24UnormS8Uint, and kD32FloatS8UInt.

IsExtensionInList()

template<class ExtensionEnum >

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

static

Definition at line 389 of file capabilities_vk.cc.

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

References GetExtensionName().

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

IsMappingSPIRV()

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

static

Definition at line 116 of file shader_library_vk.cc.

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

IsMultisampleCapable()

constexpr bool impeller::IsMultisampleCapable ( TextureType  type )

constexpr

Definition at line 283 of file formats.h.

                                                      {
  switch (type) {
    case TextureType::kTexture2D:
    case TextureType::kTextureCube:
    case TextureType::kTextureExternalOES:
      return false;
    case TextureType::kTexture2DMultisample:
      return true;
  }
  return false;
}

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

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

IsStencilWritable()

constexpr bool impeller::IsStencilWritable ( PixelFormat  format )

constexpr

Definition at line 129 of file formats.h.

                                                     {
  switch (format) {
    case PixelFormat::kS8UInt:
    case PixelFormat::kD24UnormS8Uint:
    case PixelFormat::kD32FloatS8UInt:
      return true;
    default:
      return false;
  }
}

References kD24UnormS8Uint, kD32FloatS8UInt, and kS8UInt.

IterateExtensions()

template<class T >

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

static

Definition at line 232 of file capabilities_vk.cc.

                                                              {
  if (!it) {
    return false;
  }
  for (size_t i = 0; i < static_cast<uint32_t>(T::kLast); i++) {
    if (!it(static_cast<T>(i))) {
      return false;
    }
  }
  return true;
}

JoinLabels()

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

static

Definition at line 48 of file debug_report_vk.cc.

                                            {
  std::stringstream stream;
  for (size_t i = 0u; i < count; i++) {
    stream << labels[i].pLabelName;
    if (i != count - 1u) {
      stream << ", ";
    }
  }
  return stream.str();
}

JoinVKDebugUtilsObjectNameInfoEXT()

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

static

Definition at line 60 of file debug_report_vk.cc.

                  {
  std::stringstream stream;
  for (size_t i = 0u; i < count; i++) {
    stream << vk::to_string(static_cast<vk::ObjectType>(names[i].objectType))
           << " [" << names[i].objectHandle << "] [";
    if (names[i].pObjectName != nullptr) {
      stream << names[i].pObjectName;
    } else {
      stream << "UNNAMED";
    }
    stream << "]";
    if (i != count - 1u) {
      stream << ", ";
    }
  }
  return stream.str();
}

kLowerLeftDirection()

static constexpr Point impeller::kLowerLeftDirection ( -1.  0f, 1.  0f  )

staticconstexpr

Referenced by impeller::RoundRect::Contains().

kLowerRightDirection()

static constexpr Point impeller::kLowerRightDirection ( 1.  0f, 1.  0f  )

staticconstexpr

Referenced by impeller::RoundRect::Contains().

kUpperLeftDirection()

static constexpr Point impeller::kUpperLeftDirection ( -1.  0f, -1.  0f  )

staticconstexpr

Referenced by impeller::RoundRect::Contains().

kUpperRightDirection()

static constexpr Point impeller::kUpperRightDirection ( 1.  0f, -1.  0f  )

staticconstexpr

Referenced by impeller::RoundRect::Contains().

LerpHackKernelSamples()

GaussianBlurPipeline::FragmentShader::KernelSamples impeller::LerpHackKernelSamples

(

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 959 of file gaussian_blur_filter_contents.cc.

                              {
  GaussianBlurPipeline::FragmentShader::KernelSamples result = {};
  result.sample_count = ((parameters.sample_count - 1) / 2) + 1;
  int32_t middle = result.sample_count / 2;
  int32_t j = 0;
  FML_DCHECK(result.sample_count <= kGaussianBlurMaxKernelSize);
  static_assert(sizeof(result.sample_data) ==
                sizeof(std::array<Vector4, kGaussianBlurMaxKernelSize>));
 
  for (int i = 0; i < result.sample_count; i++) {
    if (i == middle) {
      result.sample_data[i].x = parameters.samples[j].uv_offset.x;
      result.sample_data[i].y = parameters.samples[j].uv_offset.y;
      result.sample_data[i].z = parameters.samples[j].coefficient;
      j++;
    } else {
      KernelSample left = parameters.samples[j];
      KernelSample right = parameters.samples[j + 1];
 
      result.sample_data[i].z = left.coefficient + right.coefficient;
 
      Point uv = (left.uv_offset * left.coefficient +
                  right.uv_offset * right.coefficient) /
                 (left.coefficient + right.coefficient);
      result.sample_data[i].x = uv.x;
      result.sample_data[i].y = uv.y;
      j += 2;
    }
  }
 
  return result;
}

References impeller::KernelSample::coefficient, kGaussianBlurMaxKernelSize, impeller::KernelSamples::sample_count, impeller::KernelSamples::samples, impeller::KernelSample::uv_offset, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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

LineTo()

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

Definition at line 24 of file tessellator.cc.

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

References x.

Referenced by impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::interop::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.

                                                              {
  TRACE_EVENT0("impeller", __FUNCTION__);
 
  const auto& descriptor = pipeline->GetDescriptor();
 
  auto vert_mapping =
      ShaderFunctionGLES::Cast(*vert_function).GetSourceMapping();
  auto frag_mapping =
      ShaderFunctionGLES::Cast(*frag_function).GetSourceMapping();
 
  const auto& gl = reactor.GetProcTable();
 
  auto vert_shader = gl.CreateShader(GL_VERTEX_SHADER);
  auto frag_shader = gl.CreateShader(GL_FRAGMENT_SHADER);
 
  if (vert_shader == 0 || frag_shader == 0) {
    VALIDATION_LOG << "Could not create shader handles.";
    return false;
  }
 
  gl.SetDebugLabel(DebugResourceType::kShader, vert_shader,
                   SPrintF("%s Vertex Shader", descriptor.GetLabel().data()));
  gl.SetDebugLabel(DebugResourceType::kShader, frag_shader,
                   SPrintF("%s Fragment Shader", descriptor.GetLabel().data()));
 
  fml::ScopedCleanupClosure delete_vert_shader(
      [&gl, vert_shader]() { gl.DeleteShader(vert_shader); });
  fml::ScopedCleanupClosure delete_frag_shader(
      [&gl, frag_shader]() { gl.DeleteShader(frag_shader); });
 
  gl.ShaderSourceMapping(vert_shader, *vert_mapping,
                         descriptor.GetSpecializationConstants());
  gl.ShaderSourceMapping(frag_shader, *frag_mapping,
                         descriptor.GetSpecializationConstants());
 
  gl.CompileShader(vert_shader);
  gl.CompileShader(frag_shader);
 
  GLint vert_status = GL_FALSE;
  GLint frag_status = GL_FALSE;
 
  gl.GetShaderiv(vert_shader, GL_COMPILE_STATUS, &vert_status);
  gl.GetShaderiv(frag_shader, GL_COMPILE_STATUS, &frag_status);
 
  if (vert_status != GL_TRUE) {
    LogShaderCompilationFailure(gl, vert_shader, descriptor.GetLabel(),
                                *vert_mapping, ShaderStage::kVertex);
    return false;
  }
 
  if (frag_status != GL_TRUE) {
    LogShaderCompilationFailure(gl, frag_shader, descriptor.GetLabel(),
                                *frag_mapping, ShaderStage::kFragment);
    return false;
  }
 
  auto program = reactor.GetGLHandle(pipeline->GetProgramHandle());
  if (!program.has_value()) {
    VALIDATION_LOG << "Could not get program handle from reactor.";
    return false;
  }
 
  gl.AttachShader(*program, vert_shader);
  gl.AttachShader(*program, frag_shader);
 
  fml::ScopedCleanupClosure detach_vert_shader(
      [&gl, program = *program, vert_shader]() {
        gl.DetachShader(program, vert_shader);
      });
  fml::ScopedCleanupClosure detach_frag_shader(
      [&gl, program = *program, frag_shader]() {
        gl.DetachShader(program, frag_shader);
      });
 
  for (const auto& stage_input :
       descriptor.GetVertexDescriptor()->GetStageInputs()) {
    gl.BindAttribLocation(*program,                                   //
                          static_cast<GLuint>(stage_input.location),  //
                          stage_input.name                            //
    );
  }
 
  gl.LinkProgram(*program);
 
  GLint link_status = GL_FALSE;
  gl.GetProgramiv(*program, GL_LINK_STATUS, &link_status);
 
  if (link_status != GL_TRUE) {
    VALIDATION_LOG << "Could not link shader program: "
                   << gl.GetProgramInfoLogString(*program)
                   << "\nVertex Shader:\n"
                   << GetShaderSource(gl, vert_shader) << "\nFragment Shader:\n"
                   << GetShaderSource(gl, frag_shader);
    return false;
  }
  return true;
}

References impeller::ReactorGLES::GetGLHandle(), impeller::ReactorGLES::GetProcTable(), GetShaderSource(), LogShaderCompilationFailure(), SPrintF(), and VALIDATION_LOG.

LoadActionToString()

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

constexpr

Definition at line 215 of file formats.h.

                                                            {
  switch (action) {
    case LoadAction::kDontCare:
      return "DontCare";
    case LoadAction::kLoad:
      return "Load";
    case LoadAction::kClear:
      return "Clear";
  }
}

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.

                                                                           {
  if (!buffer) {
    return true;
  }
 
  if (buffer.status == MTLCommandBufferStatusCompleted) {
    return true;
  }
 
  std::stringstream stream;
  stream << ">>>>>>>" << std::endl;
  stream << "Impeller command buffer could not be committed!" << std::endl;
 
  if (auto desc = buffer.error.localizedDescription) {
    stream << desc.UTF8String << std::endl;
  }
 
  if (buffer.error) {
    stream << "Domain: "
           << (buffer.error.domain.length > 0u ? buffer.error.domain.UTF8String
                                               : "<unknown>")
           << " Code: "
           << MTLCommandBufferErrorToString(
                  static_cast<MTLCommandBufferError>(buffer.error.code))
                  .UTF8String
           << std::endl;
  }
 
  if (@available(iOS 14.0, macOS 11.0, *)) {
    NSArray<id<MTLCommandBufferEncoderInfo>>* infos =
        buffer.error.userInfo[MTLCommandBufferEncoderInfoErrorKey];
    for (id<MTLCommandBufferEncoderInfo> info in infos) {
      stream << (info.label.length > 0u ? info.label.UTF8String
                                        : "<Unlabelled Render Pass>")
             << ": "
             << MTLCommandEncoderErrorStateToString(info.errorState).UTF8String
             << std::endl;
 
      auto signposts = [info.debugSignposts componentsJoinedByString:@", "];
      if (signposts.length > 0u) {
        stream << signposts.UTF8String << std::endl;
      }
    }
 
    for (id<MTLFunctionLog> log in buffer.logs) {
      auto desc = log.description;
      if (desc.length > 0u) {
        stream << desc.UTF8String << std::endl;
      }
    }
  }
 
  stream << "<<<<<<<";
  VALIDATION_LOG << stream.str();
  return false;
}

References MTLCommandBufferErrorToString(), and VALIDATION_LOG.

LogShaderCompilationFailure()

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

static

Definition at line 49 of file pipeline_library_gles.cc.

                                                           {
  std::stringstream stream;
  stream << "Failed to compile ";
  switch (stage) {
    case ShaderStage::kUnknown:
      stream << "unknown";
      break;
    case ShaderStage::kVertex:
      stream << "vertex";
      break;
    case ShaderStage::kFragment:
      stream << "fragment";
      break;
    case ShaderStage::kCompute:
      stream << "compute";
      break;
  }
  stream << " shader for '" << name << "' with error:" << std::endl;
  stream << GetShaderInfoLog(gl, shader) << std::endl;
  stream << "Shader source was: " << std::endl;
  stream << GetShaderSource(gl, shader) << std::endl;
  VALIDATION_LOG << stream.str();
}

References GetShaderInfoLog(), GetShaderSource(), and VALIDATION_LOG.

Referenced by LinkProgram().

Luminosity()

static constexpr Scalar impeller::Luminosity ( Vector3  color )

inlinestaticconstexpr

Definition at line 63 of file color.cc.

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

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.

                                              {
  ShaderArchiveWriter writer;
 
  std::string output;
  if (!command_line.GetOptionValue("output", &output)) {
    std::cerr << "Output path not specified." << std::endl;
    return false;
  }
 
  for (const auto& input : command_line.GetOptionValues("input")) {
    if (!writer.AddShaderAtPath(std::string{input})) {
      std::cerr << "Could not add shader at path: " << input << std::endl;
      return false;
    }
  }
 
  auto archive = writer.CreateMapping();
  if (!archive) {
    std::cerr << "Could not create shader archive." << std::endl;
    return false;
  }
 
  auto current_directory =
      fml::OpenDirectory(std::filesystem::current_path().string().c_str(),
                         false, fml::FilePermission::kReadWrite);
  auto output_path =
      std::filesystem::absolute(std::filesystem::current_path() / output);
  if (!fml::WriteAtomically(current_directory, output_path.string().c_str(),
                            *archive)) {
    std::cerr << "Could not write shader archive to path " << output
              << std::endl;
    return false;
  }
 
  return true;
}

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

Referenced by main().

MAKE_STROKE_BENCHMARK_CAPTURE_ALL_CAPS_JOINS() [1/2]

impeller::MAKE_STROKE_BENCHMARK_CAPTURE_ALL_CAPS_JOINS	(	Cubic	,
		false
	)

MAKE_STROKE_BENCHMARK_CAPTURE_ALL_CAPS_JOINS() [2/2]

impeller::MAKE_STROKE_BENCHMARK_CAPTURE_ALL_CAPS_JOINS	(	Quadratic	,
		false
	)

MAKE_STROKE_PATH_BENCHMARK_CAPTURE() [1/6]

impeller::MAKE_STROKE_PATH_BENCHMARK_CAPTURE	(	RRect	,
		Butt	,
		Bevel
	)

MAKE_STROKE_PATH_BENCHMARK_CAPTURE() [2/6]

impeller::MAKE_STROKE_PATH_BENCHMARK_CAPTURE	(	RRect	,
		Butt	,
		Miter
	)

MAKE_STROKE_PATH_BENCHMARK_CAPTURE() [3/6]

impeller::MAKE_STROKE_PATH_BENCHMARK_CAPTURE	(	RRect	,
		Butt	,
		Round
	)

MAKE_STROKE_PATH_BENCHMARK_CAPTURE() [4/6]

impeller::MAKE_STROKE_PATH_BENCHMARK_CAPTURE	(	RSuperellipse	,
		Butt	,
		Bevel
	)

MAKE_STROKE_PATH_BENCHMARK_CAPTURE() [5/6]

impeller::MAKE_STROKE_PATH_BENCHMARK_CAPTURE	(	RSuperellipse	,
		Butt	,
		Miter
	)

MAKE_STROKE_PATH_BENCHMARK_CAPTURE() [6/6]

impeller::MAKE_STROKE_PATH_BENCHMARK_CAPTURE	(	RSuperellipse	,
		Butt	,
		Round
	)

MakeShaderMetadata()

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

static

Definition at line 86 of file runtime_effect_contents.cc.

                                              {
  std::unique_ptr<ShaderMetadata> metadata = std::make_unique<ShaderMetadata>();
  metadata->name = uniform.name;
  metadata->members.emplace_back(ShaderStructMemberMetadata{
      .type = GetShaderType(uniform.type),  //
      .size = uniform.dimensions.rows * uniform.dimensions.cols *
              (uniform.bit_width / 8u),  //
      .byte_length =
          (uniform.bit_width / 8u) * uniform.array_elements.value_or(1),  //
      .array_elements = uniform.array_elements                            //
  });
 
  return metadata;
}

References impeller::RuntimeUniformDescription::array_elements, impeller::RuntimeUniformDescription::bit_width, impeller::RuntimeUniformDimensions::cols, impeller::RuntimeUniformDescription::dimensions, GetShaderType(), impeller::RuntimeUniformDescription::name, impeller::RuntimeUniformDimensions::rows, 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 44 of file shared_object_vk.h.

                                                                  {
  if (!handle) {
    return std::shared_ptr<SharedObjectVKT<T>>{nullptr};
  }
  return std::make_shared<SharedObjectVKT<T>>(std::move(handle));
}

Referenced by impeller::ExternalSemaphoreVK::ExternalSemaphoreVK().

MakeTextFrameFromTextBlobSkia()

std::shared_ptr< impeller::TextFrame > impeller::MakeTextFrameFromTextBlobSkia

(

const sk_sp< SkTextBlob > &

blob

)

Definition at line 45 of file text_frame_skia.cc.

                                   {
  bool has_color = false;
  std::vector<TextRun> runs;
  for (SkTextBlobRunIterator run(blob.get()); !run.done(); run.next()) {
    SkStrikeSpec strikeSpec = SkStrikeSpec::MakeWithNoDevice(run.font());
    SkBulkGlyphMetricsAndPaths paths{strikeSpec};
    SkSpan<const SkGlyph*> glyphs =
        paths.glyphs(SkSpan(run.glyphs(), run.glyphCount()));
 
    for (const auto& glyph : glyphs) {
      has_color |= glyph->isColor();
    }
 
    AxisAlignment alignment = AxisAlignment::kNone;
    if (run.font().isSubpixel() && run.font().isBaselineSnap() && !has_color) {
      alignment = AxisAlignment::kX;
    }
 
    switch (run.positioning()) {
      case SkTextBlobRunIterator::kFull_Positioning: {
        std::vector<TextRun::GlyphPosition> positions;
        positions.reserve(run.glyphCount());
        for (auto i = 0u; i < run.glyphCount(); i++) {
          // kFull_Positioning has two scalars per glyph.
          const SkPoint* glyph_points = run.points();
          const SkPoint* point = glyph_points + i;
          Glyph::Type type =
              glyphs[i]->isColor() ? Glyph::Type::kBitmap : Glyph::Type::kPath;
          positions.emplace_back(TextRun::GlyphPosition{
              Glyph{glyphs[i]->getGlyphID(), type}, Point{
                                                        point->x(),
                                                        point->y(),
                                                    }});
        }
        TextRun text_run(ToFont(run, alignment), positions);
        runs.emplace_back(text_run);
        break;
      }
      default:
        FML_DLOG(ERROR) << "Unimplemented.";
        continue;
    }
  }
  return std::make_shared<TextFrame>(
      runs, ToRect(blob->bounds()), has_color,
      [blob]() -> fml::StatusOr<flutter::DlPath> {
        SkPath path = skia::textlayout::Paragraph::GetPath(blob.get());
        if (path.isEmpty()) {
          return fml::Status(fml::StatusCode::kCancelled, "No path available");
        }
        SkPath transformed = path.makeTransform(
            SkMatrix::Translate(blob->bounds().left(), blob->bounds().top()));
        return flutter::DlPath(transformed);
      });
}

References impeller::Glyph::kBitmap, kNone, impeller::Glyph::kPath, kX, ToFont(), ToRect(), type, and impeller::TPoint< T >::x.

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

Min()

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

inlinestaticconstexpr

Definition at line 55 of file color.cc.

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

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

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

References x.

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.

                                                                           {
  switch (code) {
    case MTLCommandBufferErrorNone:
      return @"none";
    case MTLCommandBufferErrorInternal:
      return @"internal";
    case MTLCommandBufferErrorTimeout:
      return @"timeout";
    case MTLCommandBufferErrorPageFault:
      return @"page fault";
    case MTLCommandBufferErrorNotPermitted:
      return @"not permitted";
    case MTLCommandBufferErrorOutOfMemory:
      return @"out of memory";
    case MTLCommandBufferErrorInvalidResource:
      return @"invalid resource";
    case MTLCommandBufferErrorMemoryless:
      return @"memory-less";
    default:
      break;
  }
 
  return [NSString stringWithFormat:@"<unknown> %zu", code];
}

Referenced by LogMTLCommandBufferErrorIfPresent().

MTLShaderLibraryFromFileData()

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

static

Definition at line 172 of file context_mtl.mm.

                            {
  NSMutableArray<id<MTLLibrary>>* found_libraries = [NSMutableArray array];
  for (const auto& library_data : libraries_data) {
    if (library_data == nullptr) {
      FML_LOG(ERROR) << "Shader library data was null.";
      return nil;
    }
 
    __block auto data = library_data;
 
    auto dispatch_data =
        ::dispatch_data_create(library_data->GetMapping(),  // buffer
                               library_data->GetSize(),     // size
                               dispatch_get_main_queue(),   // queue
                               ^() {
                                 // We just need a reference.
                                 data.reset();
                               }  // destructor
        );
    if (!dispatch_data) {
      FML_LOG(ERROR) << "Could not wrap shader data in dispatch data.";
      return nil;
    }
 
    NSError* shader_library_error = nil;
    auto library = [device newLibraryWithData:dispatch_data
                                        error:&shader_library_error];
    if (!library) {
      FML_LOG(ERROR) << "Could not create shader library: "
                     << shader_library_error.localizedDescription.UTF8String;
      return nil;
    }
    if (!label.empty()) {
      library.label = @(label.c_str());
    }
    [found_libraries addObject:library];
  }
  return found_libraries;
}

References data.

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

MTLShaderLibraryFromFilePaths()

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

static

Definition at line 149 of file context_mtl.mm.

                                                 {
  NSMutableArray<id<MTLLibrary>>* found_libraries = [NSMutableArray array];
  for (const auto& library_path : libraries_paths) {
    if (!fml::IsFile(library_path)) {
      VALIDATION_LOG << "Shader library does not exist at path '"
                     << library_path << "'";
      return nil;
    }
    NSError* shader_library_error = nil;
    auto library = [device newLibraryWithFile:@(library_path.c_str())
                                        error:&shader_library_error];
    if (!library) {
      FML_LOG(ERROR) << "Could not create shader library: "
                     << shader_library_error.localizedDescription.UTF8String;
      return nil;
    }
    [found_libraries addObject:library];
  }
  return found_libraries;
}

References VALIDATION_LOG.

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

NegPos()

static Point impeller::NegPos ( Scalar  v )

static

Definition at line 66 of file solid_rrect_like_blur_contents.cc.

                              {
  return {std::min(v, 0.0f), std::max(v, 0.0f)};
}

NormalizeEmptyToZero()

static void impeller::NormalizeEmptyToZero ( Size &  radii )

inlinestatic

Definition at line 9 of file rounding_radii.cc.

                                                     {
  if (radii.IsEmpty()) {
    radii = Size();
  }
}

References impeller::TSize< T >::IsEmpty().

Referenced by impeller::RoundingRadii::Scaled().

NormalizeUniformKey()

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

static

Definition at line 69 of file buffer_bindings_gles.cc.

                                                           {
  std::string result;
  result.reserve(key.length());
  for (char ch : key) {
    if (ch != '_') {
      result.push_back(toupper(ch));
    }
  }
  return result;
}

Referenced by CreateUniformMemberKey().

operator!=()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>

constexpr bool impeller::operator!= ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 223 of file mask.h.

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

operator&() [1/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>

constexpr Mask<EnumType> impeller::operator& ( const EnumType &  lhs, const EnumType &  rhs  )

inlineconstexpr

Definition at line 139 of file mask.h.

                                                               {
  return Mask<EnumType>{lhs} & rhs;
}

operator&() [2/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>

constexpr Mask<EnumType> impeller::operator& ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 170 of file mask.h.

                                                                     {
  return Mask<EnumType>{lhs} & rhs;
}

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

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

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

                                                                        {
  return p2 * p1;
}

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

                                                                     {
  return p * s;
}

operator*() [4/7]

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

constexpr Color impeller::operator* ( T  value, const Color &  c  )

inlineconstexpr

Definition at line 909 of file color.h.

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

References value.

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

                                                       {
  return p * s;
}

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

                                                     {
  return p * s;
}

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.

                                                   {
  return p * s;
}

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

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

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

                                                                        {
  return p2 + p1;
}

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

                                                                     {
  return p + s;
}

operator+() [4/5]

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

constexpr Color impeller::operator+ ( T  value, const Color &  c  )

inlineconstexpr

Definition at line 898 of file color.h.

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

References value.

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.

                                                   {
  return p + s;
}

operator-() [1/6]

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

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

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

operator-() [2/6]

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

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

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

operator-() [3/6]

template<class T >

constexpr TPoint<T> impeller::operator- ( const TPoint< T > &  p, T  v  )

constexpr

Definition at line 323 of file point.h.

                                                       {
  return {p.x - v, p.y - v};
}

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

operator-() [4/6]

template<class T , class U >

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

constexpr

Definition at line 308 of file point.h.

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

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

operator-() [5/6]

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

constexpr Color impeller::operator- ( T  value, const Color &  c  )

inlineconstexpr

Definition at line 903 of file color.h.

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

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

operator-() [6/6]

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.

                                                   {
  return -p + s;
}

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

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

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

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

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

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

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

operator/() [4/7]

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

constexpr Color impeller::operator/ ( T  value, const Color &  c  )

inlineconstexpr

Definition at line 914 of file color.h.

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

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

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

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

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

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

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.

                                                   {
  return {
      static_cast<Scalar>(s) / p.x,
      static_cast<Scalar>(s) / p.y,
      static_cast<Scalar>(s) / p.z,
  };
}

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

operator<()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>

constexpr bool impeller::operator< ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 188 of file mask.h.

                                                           {
  return Mask<EnumType>{lhs} < rhs;
}

operator<=()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>

constexpr bool impeller::operator<= ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 202 of file mask.h.

                                                            {
  return Mask<EnumType>{lhs} <= rhs;
}

operator==()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>

constexpr bool impeller::operator== ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 216 of file mask.h.

                                                            {
  return Mask<EnumType>{lhs} == rhs;
}

operator>()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>

constexpr bool impeller::operator> ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 195 of file mask.h.

                                                           {
  return Mask<EnumType>{lhs} > rhs;
}

operator>=()

template<typename EnumType , typename std::enable_if_t< MaskTraits< EnumType >::kIsMask, bool > = true>

constexpr bool impeller::operator>= ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 209 of file mask.h.

                                                            {
  return Mask<EnumType>{lhs} >= rhs;
}

operator^() [1/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>

constexpr Mask<EnumType> impeller::operator^ ( const EnumType &  lhs, const EnumType &  rhs  )

inlineconstexpr

Definition at line 147 of file mask.h.

                                                               {
  return Mask<EnumType>{lhs} ^ rhs;
}

operator^() [2/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>

constexpr Mask<EnumType> impeller::operator^ ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 178 of file mask.h.

                                                                     {
  return Mask<EnumType>{lhs} ^ rhs;
}

operator|() [1/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>

constexpr Mask<EnumType> impeller::operator| ( const EnumType &  lhs, const EnumType &  rhs  )

inlineconstexpr

Definition at line 131 of file mask.h.

                                                               {
  return Mask<EnumType>{lhs} | rhs;
}

operator|() [2/2]

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>

constexpr Mask<EnumType> impeller::operator| ( const EnumType &  lhs, const Mask< EnumType > &  rhs  )

inlineconstexpr

Definition at line 162 of file mask.h.

                                                                     {
  return Mask<EnumType>{lhs} | rhs;
}

operator~()

template<typename EnumType , typename std::enable_if< MaskTraits< EnumType >::kIsMask, bool >::type = true>

constexpr Mask<EnumType> impeller::operator~ ( const EnumType &  other )

inlineconstexpr

Definition at line 155 of file mask.h.

                                                                 {
  return ~Mask<EnumType>{other};
}

OptionsFromPass()

ContentContextOptions impeller::OptionsFromPass

(

const RenderPass &

pass

)

Definition at line 19 of file contents.cc.

                                                              {
  ContentContextOptions opts;
  opts.sample_count = pass.GetSampleCount();
  opts.color_attachment_pixel_format = pass.GetRenderTargetPixelFormat();
 
  bool has_depth_stencil_attachments =
      pass.HasDepthAttachment() && pass.HasStencilAttachment();
  FML_DCHECK(pass.HasDepthAttachment() == pass.HasStencilAttachment());
 
  opts.has_depth_stencil_attachments = has_depth_stencil_attachments;
  opts.depth_compare = CompareFunction::kGreaterEqual;
  opts.stencil_mode = ContentContextOptions::StencilMode::kIgnore;
  return opts;
}

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(), kGreaterEqual, impeller::ContentContextOptions::kIgnore, impeller::ContentContextOptions::sample_count, and impeller::ContentContextOptions::stencil_mode.

Referenced by AdvancedBlend(), OptionsFromPassAndEntity(), PipelineBlend(), impeller::ColorFilterAtlasContents::Render(), impeller::ClipContents::Render(), RenderClipRestore(), and impeller::testing::TEST_P().

OptionsFromPassAndEntity()

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

Definition at line 34 of file contents.cc.

                                                                     {
  ContentContextOptions opts = OptionsFromPass(pass);
  opts.blend_mode = entity.GetBlendMode();
  return opts;
}

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

Referenced by impeller::ColorSourceContents::DrawGeometry(), impeller::AtlasContents::Render(), impeller::SolidRRectLikeBlurContents::Render(), impeller::TextContents::Render(), impeller::TextureContents::Render(), impeller::VerticesSimpleBlendContents::Render(), and impeller::testing::TEST_P().

PairsFitInAtlasOfSize()

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

static

Definition at line 136 of file typographer_context_skia.cc.

                        {
  FML_DCHECK(!atlas_size.IsEmpty());
 
  for (size_t i = start_index; i < pairs.size(); i++) {
    ISize glyph_size = ISize::Ceil(glyph_sizes[i].GetSize());
    IPoint16 location_in_atlas;
    if (!rect_packer->AddRect(glyph_size.width + kPadding,   //
                              glyph_size.height + kPadding,  //
                              &location_in_atlas             //
                              )) {
      return i;
    }
    glyph_positions.push_back(Rect::MakeXYWH(
        location_in_atlas.x() + 1,                      //
        location_in_atlas.y() + height_adjustment + 1,  //
        glyph_size.width,                               //
        glyph_size.height                               //
        ));
  }
 
  return pairs.size();
}

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

Referenced by ComputeNextAtlasSize().

PhysicalDeviceSupportsRequiredFormats()

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

static

Definition at line 355 of file capabilities_vk.cc.

                                    {
  const auto has_color_format =
      HasSuitableColorFormat(device, vk::Format::eR8G8B8A8Unorm);
  const auto has_stencil_format =
      HasSuitableDepthStencilFormat(device, vk::Format::eD32SfloatS8Uint) ||
      HasSuitableDepthStencilFormat(device, vk::Format::eD24UnormS8Uint);
  return has_color_format && has_stencil_format;
}

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

                                {
  for (const auto& device : instance.enumeratePhysicalDevices().value) {
    if (caps.GetEnabledDeviceFeatures(device).has_value()) {
      return device;
    }
  }
  return std::nullopt;
}

References impeller::CapabilitiesVK::GetEnabledDeviceFeatures().

PickQueue()

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

static

Definition at line 91 of file context_vk.cc.

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

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

                               {
  using VS = TexturePipeline::VertexShader;
  using FS = TexturePipeline::FragmentShader;
 
  auto dst_snapshot =
      inputs[0]->GetSnapshot("PipelineBlend(Dst)", renderer, entity);
  if (!dst_snapshot.has_value()) {
    return std::nullopt;  // Nothing to render.
  }
 
  Rect subpass_coverage = coverage;
  if (entity.GetContents()) {
    auto coverage_hint = entity.GetContents()->GetCoverageHint();
 
    if (coverage_hint.has_value()) {
      auto maybe_subpass_coverage =
          subpass_coverage.Intersection(*coverage_hint);
      if (!maybe_subpass_coverage.has_value()) {
        return std::nullopt;  // Nothing to render.
      }
 
      subpass_coverage = *maybe_subpass_coverage;
    }
  }
 
  ContentContext::SubpassCallback callback = [&](const ContentContext& renderer,
                                                 RenderPass& pass) {
    auto& host_buffer = renderer.GetTransientsBuffer();
 
#ifdef IMPELLER_DEBUG
    pass.SetCommandLabel(BlendModeToFilterString(blend_mode));
#endif  // IMPELLER_DEBUG
    auto options = OptionsFromPass(pass);
    options.primitive_type = PrimitiveType::kTriangleStrip;
 
    auto add_blend_command = [&](std::optional<Snapshot> input) {
      if (!input.has_value()) {
        return false;
      }
      auto input_coverage = input->GetCoverage();
      if (!input_coverage.has_value()) {
        return false;
      }
 
      raw_ptr<const Sampler> sampler =
          renderer.GetContext()->GetSamplerLibrary()->GetSampler(
              input->sampler_descriptor);
      FS::BindTextureSampler(pass, input->texture, sampler);
 
      auto size = input->texture->GetSize();
      std::array<VS::PerVertexData, 4> vertices = {
          VS::PerVertexData{Point(0, 0), Point(0, 0)},
          VS::PerVertexData{Point(size.width, 0), Point(1, 0)},
          VS::PerVertexData{Point(0, size.height), Point(0, 1)},
          VS::PerVertexData{Point(size.width, size.height), Point(1, 1)},
      };
      pass.SetVertexBuffer(
          CreateVertexBuffer(vertices, renderer.GetTransientsBuffer()));
 
      VS::FrameInfo frame_info;
      frame_info.mvp = pass.GetOrthographicTransform() *
                       Matrix::MakeTranslation(-subpass_coverage.GetOrigin()) *
                       input->transform;
      frame_info.texture_sampler_y_coord_scale =
          input->texture->GetYCoordScale();
 
      FS::FragInfo frag_info;
      frag_info.alpha =
          absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
              ? input->opacity
              : 1.0;
      FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
      VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
 
      return pass.Draw().ok();
    };
 
    // Draw the first texture using kSource.
    options.blend_mode = BlendMode::kSrc;
    pass.SetPipeline(renderer.GetTexturePipeline(options));
    if (!add_blend_command(dst_snapshot)) {
      return true;
    }
 
    // Write subsequent textures using the selected blend mode.
 
    if (inputs.size() >= 2) {
      options.blend_mode = blend_mode;
      pass.SetPipeline(renderer.GetTexturePipeline(options));
 
      for (auto texture_i = inputs.begin() + 1; texture_i < inputs.end();
           texture_i++) {
        auto src_input = texture_i->get()->GetSnapshot("PipelineBlend(Src)",
                                                       renderer, entity);
        if (!add_blend_command(src_input)) {
          return true;
        }
      }
    }
 
    // If a foreground color is set, blend it in.
 
    if (foreground_color.has_value()) {
      auto contents = std::make_shared<SolidColorContents>();
      FillRectGeometry geom(Rect::MakeSize(pass.GetRenderTargetSize()));
      contents->SetGeometry(&geom);
      contents->SetColor(foreground_color.value());
 
      Entity foreground_entity;
      foreground_entity.SetBlendMode(blend_mode);
      foreground_entity.SetContents(contents);
      if (!foreground_entity.Render(renderer, pass)) {
        return false;
      }
    }
 
    return true;
  };
 
  std::shared_ptr<CommandBuffer> command_buffer =
      renderer.GetContext()->CreateCommandBuffer();
  if (!command_buffer) {
    return std::nullopt;
  }
 
  fml::StatusOr<RenderTarget> render_target =
      renderer.MakeSubpass("Pipeline Blend Filter",            //
                           ISize(subpass_coverage.GetSize()),  //
                           command_buffer,                     //
                           callback,                           //
                           /*msaa_enabled=*/false,             //
                           /*depth_stencil_enabled=*/false     //
      );
 
  if (!render_target.ok()) {
    return std::nullopt;
  }
  if (!renderer.GetContext()->EnqueueCommandBuffer(std::move(command_buffer))) {
    return std::nullopt;
  }
 
  return Entity::FromSnapshot(
      Snapshot{
          .texture = render_target.value().GetRenderTargetTexture(),
          .transform = Matrix::MakeTranslation(subpass_coverage.GetOrigin()),
          // Since we absorbed the transform of the inputs and used the
          // respective snapshot sampling modes when blending, pass on
          // the default NN clamp sampler.
          .sampler_descriptor = {},
          .opacity = (absorb_opacity == ColorFilterContents::AbsorbOpacity::kYes
                          ? 1.0f
                          : dst_snapshot->opacity) *
                     alpha.value_or(1.0)},
      entity.GetBlendMode());
}

References CreateVertexBuffer(), impeller::Entity::FromSnapshot(), impeller::Entity::GetBlendMode(), impeller::Entity::GetContents(), impeller::ContentContext::GetContext(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), impeller::ContentContext::GetTexturePipeline(), impeller::ContentContext::GetTransientsBuffer(), impeller::TRect< T >::Intersection(), kSrc, kTriangleStrip, impeller::ColorFilterContents::kYes, impeller::TRect< Scalar >::MakeSize(), impeller::ContentContext::MakeSubpass(), impeller::Matrix::MakeTranslation(), OptionsFromPass(), impeller::Entity::Render(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Snapshot::texture, and transform.

PipelineCacheDataPersist()

bool impeller::PipelineCacheDataPersist	(	const fml::UniqueFD &	cache_directory,
		const VkPhysicalDeviceProperties &	props,
		const vk::UniquePipelineCache &	cache
	)

Persist the pipeline cache to a file in the given cache directory. This function performs integrity checks the Vulkan driver may have missed.

Warning

The pipeline cache must be externally synchronized for most complete results. If additional pipelines are being created while this function is executing, this function may fail to persist data.

Parameters

[in]	cache_directory	The cache directory
[in]	props	The physical device properties
[in]	cache	The cache

Returns

If the cache data could be persisted to disk.

Definition at line 16 of file pipeline_cache_data_vk.cc.

                                                                  {
  if (!cache_directory.is_valid()) {
    return false;
  }
  size_t data_size = 0u;
  if (cache.getOwner().getPipelineCacheData(*cache, &data_size, nullptr) !=
      vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not fetch pipeline cache size.";
    return false;
  }
  if (data_size == 0u) {
    return true;
  }
  auto allocation = std::make_shared<Allocation>();
  if (!allocation->Truncate(Bytes{sizeof(PipelineCacheHeaderVK) + data_size},
                            false)) {
    VALIDATION_LOG << "Could not allocate pipeline cache data staging buffer.";
    return false;
  }
  const auto header = PipelineCacheHeaderVK{props, data_size};
  std::memcpy(allocation->GetBuffer(), &header, sizeof(header));
  vk::Result lookup_result = cache.getOwner().getPipelineCacheData(
      *cache, &data_size, allocation->GetBuffer() + sizeof(header));
 
  // Some drivers may return incomplete erroneously, but this is not an
  // error condition as some/all data was still written.
  if (lookup_result != vk::Result::eSuccess &&
      lookup_result != vk::Result::eIncomplete) {
    VALIDATION_LOG << "Could not copy pipeline cache data.";
    return false;
  }
 
  auto allocation_mapping = CreateMappingFromAllocation(allocation);
  if (!allocation_mapping) {
    return false;
  }
  if (!fml::WriteAtomically(cache_directory, kPipelineCacheFileName,
                            *allocation_mapping)) {
    VALIDATION_LOG << "Could not write cache file to disk.";
    return false;
  }
  return true;
}

References CreateMappingFromAllocation(), kPipelineCacheFileName, and VALIDATION_LOG.

Referenced by impeller::PipelineCacheVK::PersistCacheToDisk(), and impeller::testing::TEST_P().

PipelineCacheDataRetrieve()

std::unique_ptr< fml::Mapping > impeller::PipelineCacheDataRetrieve	(	const fml::UniqueFD &	cache_directory,
		const VkPhysicalDeviceProperties &	props
	)

Retrieve the previously persisted pipeline cache data. This function provides integrity checks the Vulkan driver may have missed.

The data is stripped of any additional headers that perform integrity checks. It can be used directly to construct a pre-initialized Vulkan pipeline cache.

Parameters

[in]	cache_directory	The cache directory
[in]	props	The properties

Returns

The cache data if it was found and checked to have passed additional integrity checks.

Definition at line 62 of file pipeline_cache_data_vk.cc.

                                             {
  if (!cache_directory.is_valid()) {
    return nullptr;
  }
  std::shared_ptr<fml::FileMapping> on_disk_data =
      fml::FileMapping::CreateReadOnly(cache_directory, kPipelineCacheFileName);
  if (!on_disk_data) {
    return nullptr;
  }
  if (on_disk_data->GetSize() < sizeof(PipelineCacheHeaderVK)) {
    VALIDATION_LOG << "Pipeline cache data size is too small.";
    return nullptr;
  }
  auto on_disk_header = PipelineCacheHeaderVK{};
  std::memcpy(&on_disk_header,             //
              on_disk_data->GetMapping(),  //
              sizeof(on_disk_header)       //
  );
  const auto current_header = PipelineCacheHeaderVK{props, 0u};
  if (!on_disk_header.IsCompatibleWith(current_header)) {
    FML_LOG(WARNING)
        << "Persisted pipeline cache is not compatible with current "
           "Vulkan context. Ignoring.";
    return nullptr;
  }
  // Zero sized data is known to cause issues.
  if (on_disk_header.data_size == 0u) {
    return nullptr;
  }
  return std::make_unique<fml::NonOwnedMapping>(
      on_disk_data->GetMapping() + sizeof(on_disk_header),
      on_disk_header.data_size, [on_disk_data](auto, auto) {});
}

References kPipelineCacheFileName, and VALIDATION_LOG.

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

PixelFormatIsDepthStencil()

constexpr bool impeller::PixelFormatIsDepthStencil ( PixelFormat  format )

constexpr

Definition at line 414 of file formats_vk.h.

                                                             {
  switch (format) {
    case PixelFormat::kUnknown:
    case PixelFormat::kA8UNormInt:
    case PixelFormat::kR8UNormInt:
    case PixelFormat::kR8G8UNormInt:
    case PixelFormat::kR8G8B8A8UNormInt:
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
    case PixelFormat::kB8G8R8A8UNormInt:
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
    case PixelFormat::kR32G32B32A32Float:
    case PixelFormat::kR16G16B16A16Float:
    case PixelFormat::kB10G10R10XR:
    case PixelFormat::kB10G10R10XRSRGB:
    case PixelFormat::kB10G10R10A10XR:
      return false;
    case PixelFormat::kS8UInt:
    case PixelFormat::kD24UnormS8Uint:
    case PixelFormat::kD32FloatS8UInt:
      return true;
  }
  return false;
}

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

                                                              {
  switch (format) {
    case PixelFormat::kUnknown:
      return "Unknown";
    case PixelFormat::kA8UNormInt:
      return "A8UNormInt";
    case PixelFormat::kR8UNormInt:
      return "R8UNormInt";
    case PixelFormat::kR8G8UNormInt:
      return "R8G8UNormInt";
    case PixelFormat::kR8G8B8A8UNormInt:
      return "R8G8B8A8UNormInt";
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
      return "R8G8B8A8UNormIntSRGB";
    case PixelFormat::kB8G8R8A8UNormInt:
      return "B8G8R8A8UNormInt";
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
      return "B8G8R8A8UNormIntSRGB";
    case PixelFormat::kR32G32B32A32Float:
      return "R32G32B32A32Float";
    case PixelFormat::kR16G16B16A16Float:
      return "R16G16B16A16Float";
    case PixelFormat::kB10G10R10XR:
      return "B10G10R10XR";
    case PixelFormat::kB10G10R10XRSRGB:
      return "B10G10R10XRSRGB";
    case PixelFormat::kB10G10R10A10XR:
      return "B10G10R10A10XR";
    case PixelFormat::kS8UInt:
      return "S8UInt";
    case PixelFormat::kD24UnormS8Uint:
      return "D24UnormS8Uint";
    case PixelFormat::kD32FloatS8UInt:
      return "D32FloatS8UInt";
  }
  FML_UNREACHABLE();
}

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

Referenced by impeller::BlitPass::AddCopy(), impeller::testing::TEST_P(), and TextureDescriptorToString().

PlaygroundBackendToRuntimeStageBackend()

constexpr RuntimeStageBackend impeller::PlaygroundBackendToRuntimeStageBackend ( PlaygroundBackend  backend )

inlineconstexpr

Definition at line 33 of file playground.h.

                               {
  switch (backend) {
    case PlaygroundBackend::kMetal:
      return RuntimeStageBackend::kMetal;
    case PlaygroundBackend::kOpenGLES:
      return RuntimeStageBackend::kOpenGLES;
    case PlaygroundBackend::kVulkan:
      return RuntimeStageBackend::kVulkan;
  }
  FML_UNREACHABLE();
}

References kMetal, kOpenGLES, and kVulkan.

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

PlaygroundBackendToString()

std::string impeller::PlaygroundBackendToString

(

PlaygroundBackend

backend

)

Definition at line 46 of file playground.cc.

                                                               {
  switch (backend) {
    case PlaygroundBackend::kMetal:
      return "Metal";
    case PlaygroundBackend::kOpenGLES:
      return "OpenGLES";
    case PlaygroundBackend::kVulkan:
      return "Vulkan";
  }
  FML_UNREACHABLE();
}

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

                                            {
  if ((key == GLFW_KEY_ESCAPE) && action == GLFW_RELEASE) {
    if (mods & (GLFW_MOD_CONTROL | GLFW_MOD_SUPER | GLFW_MOD_SHIFT)) {
      gShouldOpenNewPlaygrounds = false;
    }
    ::glfwSetWindowShouldClose(window, GLFW_TRUE);
  }
}

References gShouldOpenNewPlaygrounds.

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

PopulateUniformGradientColors()

int impeller::PopulateUniformGradientColors	(	const std::vector< Color > &	colors,
		const std::vector< Scalar > &	stops,
		Vector4	frag_info_colors[kMaxUniformGradientStops],
		Vector4	frag_info_stop_pairs[kMaxUniformGradientStops/2]
	)

Populate 2 arrays with the colors and stop data for a gradient.

The color data is simply converted to a vec4 format, but the stop data is both turned into pairs of {t, inverse_delta} information and also stops are themselves paired up into a vec4 format for efficient packing in the uniform data.

Parameters

colors	colors from gradient
stops	stops from gradient
frag_info_colors	colors for fragment shader in vec4 format
frag_info_stop_pairs	pairs of stop data for shader in vec4 format

Returns

count of colors stored

Definition at line 51 of file gradient_generator.cc.

                                                                {
  FML_DCHECK(stops.size() == colors.size());
 
  Scalar last_stop = 0;
  int index = 0;
  for (auto i = 0u; i < stops.size() && i < kMaxUniformGradientStops; i++) {
    Scalar cur_stop = stops[i];
    Scalar delta = cur_stop - last_stop;
    Scalar inverse_delta = delta == 0.0f ? 0.0 : 1.0 / delta;
    frag_info_colors[index] = colors[i];
    if ((i & 1) == 0) {
      frag_info_stop_pairs[index / 2].x = cur_stop;
      frag_info_stop_pairs[index / 2].y = inverse_delta;
    } else {
      frag_info_stop_pairs[index / 2].z = cur_stop;
      frag_info_stop_pairs[index / 2].w = inverse_delta;
    }
    last_stop = cur_stop;
    index++;
  }
  return index;
}

References kMaxUniformGradientStops.

PrimitiveTopologySupportsPrimitiveRestart()

constexpr bool impeller::PrimitiveTopologySupportsPrimitiveRestart ( PrimitiveType  primitive )

constexpr

Definition at line 380 of file formats_vk.h.

                             {
  switch (primitive) {
    case PrimitiveType::kTriangleStrip:
    case PrimitiveType::kLine:
    case PrimitiveType::kPoint:
    case PrimitiveType::kTriangleFan:
      return true;
    case PrimitiveType::kTriangle:
    case PrimitiveType::kLineStrip:
      return false;
  }
  FML_UNREACHABLE();
}

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

ReadStageInputFormat()

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

static

Definition at line 16 of file vertex_descriptor_mtl.mm.

                                                                            {
  if (input.columns != 1) {
    // All matrix types are unsupported as vertex inputs.
    return MTLVertexFormatInvalid;
  }
 
  switch (input.type) {
    case ShaderType::kFloat: {
      if (input.bit_width == 8 * sizeof(float)) {
        switch (input.vec_size) {
          case 1:
            return MTLVertexFormatFloat;
          case 2:
            return MTLVertexFormatFloat2;
          case 3:
            return MTLVertexFormatFloat3;
          case 4:
            return MTLVertexFormatFloat4;
        }
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kHalfFloat: {
      if (input.bit_width == 8 * sizeof(float) / 2) {
        switch (input.vec_size) {
          case 1:
            return MTLVertexFormatHalf;
          case 2:
            return MTLVertexFormatHalf2;
          case 3:
            return MTLVertexFormatHalf3;
          case 4:
            return MTLVertexFormatHalf4;
        }
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kDouble: {
      // Unsupported.
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kBoolean: {
      if (input.bit_width == 8 * sizeof(bool) && input.vec_size == 1) {
        return MTLVertexFormatChar;
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kSignedByte: {
      if (input.bit_width == 8 * sizeof(char)) {
        switch (input.vec_size) {
          case 1:
            return MTLVertexFormatChar;
          case 2:
            return MTLVertexFormatChar2;
          case 3:
            return MTLVertexFormatChar3;
          case 4:
            return MTLVertexFormatChar4;
        }
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kUnsignedByte: {
      if (input.bit_width == 8 * sizeof(char)) {
        switch (input.vec_size) {
          case 1:
            return MTLVertexFormatUChar;
          case 2:
            return MTLVertexFormatUChar2;
          case 3:
            return MTLVertexFormatUChar3;
          case 4:
            return MTLVertexFormatUChar4;
        }
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kSignedShort: {
      if (input.bit_width == 8 * sizeof(short)) {
        switch (input.vec_size) {
          case 1:
            return MTLVertexFormatShort;
          case 2:
            return MTLVertexFormatShort2;
          case 3:
            return MTLVertexFormatShort3;
          case 4:
            return MTLVertexFormatShort4;
        }
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kUnsignedShort: {
      if (input.bit_width == 8 * sizeof(ushort)) {
        switch (input.vec_size) {
          case 1:
            return MTLVertexFormatUShort;
          case 2:
            return MTLVertexFormatUShort2;
          case 3:
            return MTLVertexFormatUShort3;
          case 4:
            return MTLVertexFormatUShort4;
        }
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kSignedInt: {
      if (input.bit_width == 8 * sizeof(int32_t)) {
        switch (input.vec_size) {
          case 1:
            return MTLVertexFormatInt;
          case 2:
            return MTLVertexFormatInt2;
          case 3:
            return MTLVertexFormatInt3;
          case 4:
            return MTLVertexFormatInt4;
        }
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kUnsignedInt: {
      if (input.bit_width == 8 * sizeof(uint32_t)) {
        switch (input.vec_size) {
          case 1:
            return MTLVertexFormatUInt;
          case 2:
            return MTLVertexFormatUInt2;
          case 3:
            return MTLVertexFormatUInt3;
          case 4:
            return MTLVertexFormatUInt4;
        }
      }
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kSignedInt64: {
      // Unsupported.
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kUnsignedInt64: {
      // Unsupported.
      return MTLVertexFormatInvalid;
    }
    case ShaderType::kAtomicCounter:
    case ShaderType::kStruct:
    case ShaderType::kImage:
    case ShaderType::kSampledImage:
    case ShaderType::kUnknown:
    case ShaderType::kVoid:
    case ShaderType::kSampler:
      return MTLVertexFormatInvalid;
  }
}

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.

                                 {
  std::promise<T> promise;
  auto future = promise.get_future();
  promise.set_value(std::move(t));
  return future;
}

RenderClipRestore()

bool impeller::RenderClipRestore	(	const ContentContext &	renderer,
		RenderPass &	pass,
		uint32_t	clip_depth,
		std::optional< Rect >	restore_coverage
	)

Render a restore clip.

This is is intended to be used for prevent overdraw mechanism. The clip depth should be the depth of the entity that is currently being drawn, and restore_coverage should be its coverage. If restore_coverage is std::nullopt, the render pass coverage is used instead.

Definition at line 153 of file clip_contents.cc.

                                                           {
  using VS = ClipPipeline::VertexShader;
 
  pass.SetCommandLabel("Restore Clip");
  auto options = OptionsFromPass(pass);
  options.blend_mode = BlendMode::kDst;
  options.stencil_mode =
      ContentContextOptions::StencilMode::kOverdrawPreventionRestore;
  options.primitive_type = PrimitiveType::kTriangleStrip;
  pass.SetPipeline(renderer.GetClipPipeline(options));
  pass.SetStencilReference(0);
 
  // Create a rect that covers either the given restore area, or the whole
  // render target texture.
  auto ltrb =
      restore_coverage.value_or(Rect::MakeSize(pass.GetRenderTargetSize()))
          .GetLTRB();
 
  std::array<VS::PerVertexData, 4> vertices = {
      VS::PerVertexData{Point(ltrb[0], ltrb[1])},
      VS::PerVertexData{Point(ltrb[2], ltrb[1])},
      VS::PerVertexData{Point(ltrb[0], ltrb[3])},
      VS::PerVertexData{Point(ltrb[2], ltrb[3])},
  };
  pass.SetVertexBuffer(
      CreateVertexBuffer(vertices, renderer.GetTransientsBuffer()));
 
  VS::FrameInfo info;
  info.depth = GetShaderClipDepth(clip_depth);
  info.mvp = pass.GetOrthographicTransform();
  VS::BindFrameInfo(pass, renderer.GetTransientsBuffer().EmplaceUniform(info));
 
  return pass.Draw().ok();
}

References CreateVertexBuffer(), impeller::RenderPass::Draw(), impeller::HostBuffer::EmplaceUniform(), impeller::ContentContext::GetClipPipeline(), impeller::RenderPass::GetOrthographicTransform(), impeller::RenderPass::GetRenderTargetSize(), GetShaderClipDepth(), impeller::ContentContext::GetTransientsBuffer(), kDst, impeller::ContentContextOptions::kOverdrawPreventionRestore, kTriangleStrip, impeller::TRect< Scalar >::MakeSize(), OptionsFromPass(), impeller::RenderPass::SetCommandLabel(), impeller::RenderPass::SetPipeline(), impeller::RenderPass::SetStencilReference(), and impeller::RenderPass::SetVertexBuffer().

Referenced by impeller::ColorSourceContents::DrawGeometry().

RenderToTarget()

bool impeller::RenderToTarget	(	ContentContext &	context,
		RenderTarget	render_target,
		const sk_sp< flutter::DisplayList > &	display_list,
		Rect	cull_rect,
		bool	reset_host_buffer,
		bool	is_onscreen = true
	)

Render the provided display list to the render target.

If [is_onscreen] is true, then the onscreen command buffer will be submitted via Context::SubmitOnscreen.

Definition at line 1293 of file dl_dispatcher.cc.

                                      {
  FirstPassDispatcher collector(context, impeller::Matrix(), cull_rect);
  display_list->Dispatch(collector, cull_rect);
 
  impeller::CanvasDlDispatcher impeller_dispatcher(
      context,                                   //
      render_target,                             //
      /*is_onscreen=*/is_onscreen,               //
      display_list->root_has_backdrop_filter(),  //
      display_list->max_root_blend_mode(),       //
      IRect::RoundOut(cull_rect)                 //
  );
  const auto& [data, count] = collector.TakeBackdropData();
  impeller_dispatcher.SetBackdropData(data, count);
  context.GetTextShadowCache().MarkFrameStart();
  fml::ScopedCleanupClosure cleanup([&] {
    if (reset_host_buffer) {
      context.GetTransientsBuffer().Reset();
    }
    context.GetTextShadowCache().MarkFrameEnd();
  });
 
  display_list->Dispatch(impeller_dispatcher, cull_rect);
  impeller_dispatcher.FinishRecording();
  context.GetLazyGlyphAtlas()->ResetTextFrames();
 
  return true;
}

References data, impeller::CanvasDlDispatcher::FinishRecording(), impeller::ContentContext::GetLazyGlyphAtlas(), impeller::ContentContext::GetTextShadowCache(), impeller::ContentContext::GetTransientsBuffer(), impeller::TextShadowCache::MarkFrameStart(), impeller::TRect< T >::RoundOut(), impeller::CanvasDlDispatcher::SetBackdropData(), and impeller::FirstPassDispatcher::TakeBackdropData().

Referenced by impeller::interop::Surface::DrawDisplayList(), impeller::AiksPlayground::OpenPlaygroundHere(), and impeller::DlPlayground::OpenPlaygroundHere().

ReportPipelineCreationFeedback()

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

static

Definition at line 106 of file pipeline_vk.cc.

                                                             {
  constexpr bool kReportPipelineCreationFeedbackToLogs = false;
  constexpr bool kReportPipelineCreationFeedbackToTraces = true;
  if (kReportPipelineCreationFeedbackToLogs) {
    ReportPipelineCreationFeedbackToLog(desc, feedback);
  }
  if (kReportPipelineCreationFeedbackToTraces) {
    ReportPipelineCreationFeedbackToTrace(desc, feedback);
  }
}

References ReportPipelineCreationFeedbackToLog(), and ReportPipelineCreationFeedbackToTrace().

ReportPipelineCreationFeedbackToLog() [1/2]

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

static

Definition at line 58 of file pipeline_vk.cc.

                                                             {
  std::stringstream stream;
  stream << std::fixed << std::showpoint << std::setprecision(2);
  stream << std::endl << ">>>>>>" << std::endl;
  stream << "Pipeline '" << desc.GetLabel() << "' ";
  ReportPipelineCreationFeedbackToLog(stream,
                                      *feedback.pPipelineCreationFeedback);
  if (feedback.pipelineStageCreationFeedbackCount != 0) {
    stream << std::endl;
  }
  for (size_t i = 0, count = feedback.pipelineStageCreationFeedbackCount;
       i < count; i++) {
    stream << "\tStage " << i + 1 << ": ";
    ReportPipelineCreationFeedbackToLog(
        stream, feedback.pPipelineStageCreationFeedbacks[i]);
    if (i != count - 1) {
      stream << std::endl;
    }
  }
  stream << std::endl << "<<<<<<" << std::endl;
  FML_LOG(ERROR) << stream.str();
}

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

ReportPipelineCreationFeedbackToLog() [2/2]

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

static

Definition at line 41 of file pipeline_vk.cc.

                                                   {
  const auto pipeline_cache_hit =
      feedback.flags &
      vk::PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit;
  const auto base_pipeline_accl =
      feedback.flags &
      vk::PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration;
  auto duration = std::chrono::duration_cast<MillisecondsF>(
      std::chrono::nanoseconds{feedback.duration});
  stream << "Time: " << duration.count() << "ms"
         << " Cache Hit: " << static_cast<bool>(pipeline_cache_hit)
         << " Base Accel: " << static_cast<bool>(base_pipeline_accl)
         << " Thread: " << std::this_thread::get_id();
}

Referenced by ReportPipelineCreationFeedback(), and ReportPipelineCreationFeedbackToLog().

ReportPipelineCreationFeedbackToTrace()

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

static

Definition at line 83 of file pipeline_vk.cc.

                                                             {
  static int64_t gPipelineCacheHits = 0;
  static int64_t gPipelineCacheMisses = 0;
  static int64_t gPipelines = 0;
  if (feedback.pPipelineCreationFeedback->flags &
      vk::PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit) {
    gPipelineCacheHits++;
  } else {
    gPipelineCacheMisses++;
  }
  gPipelines++;
  static constexpr int64_t kImpellerPipelineTraceID = 1988;
  FML_TRACE_COUNTER("impeller",                                   //
                    "PipelineCache",                              // series name
                    kImpellerPipelineTraceID,                     // series ID
                    "PipelineCacheHits", gPipelineCacheHits,      //
                    "PipelineCacheMisses", gPipelineCacheMisses,  //
                    "TotalPipelines", gPipelines                  //
  );
}

Referenced by ReportPipelineCreationFeedback().

RequiresReadbackForBlends()

static bool impeller::RequiresReadbackForBlends ( const ContentContext &  renderer, flutter::DlBlendMode  max_root_blend_mode  )

static

Subclasses.

Definition at line 941 of file dl_dispatcher.cc.

                                            {
  return !renderer.GetDeviceCapabilities().SupportsFramebufferFetch() &&
         max_root_blend_mode > Entity::kLastPipelineBlendMode;
}

References impeller::ContentContext::GetDeviceCapabilities(), impeller::Entity::kLastPipelineBlendMode, and impeller::Capabilities::SupportsFramebufferFetch().

ResourceIsLive()

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

static

Definition at line 342 of file proc_table_gles.cc.

                                       {
  switch (type) {
    case DebugResourceType::kTexture:
      return gl.IsTexture(name);
    case DebugResourceType::kBuffer:
      return gl.IsBuffer(name);
    case DebugResourceType::kProgram:
      return gl.IsProgram(name);
    case DebugResourceType::kShader:
      return gl.IsShader(name);
    case DebugResourceType::kRenderBuffer:
      return gl.IsRenderbuffer(name);
    case DebugResourceType::kFrameBuffer:
      return gl.IsFramebuffer(name);
    case DebugResourceType::kFence:
      return true;
  }
  FML_UNREACHABLE();
}

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

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.

                                            {
  if (@available(iOS 10, macOS 11.0, *)) {
    return MTLPixelFormatBGR10_XR;
  } else {
    return MTLPixelFormatInvalid;
  }
}

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.

                                                 {
  if (@available(iOS 11, macOS 11.0, *)) {
    return MTLPixelFormatBGR10_XR_sRGB;
  } else {
    return MTLPixelFormatInvalid;
  }
}

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.

                                             {
  if (@available(iOS 10, macOS 11.0, *)) {
    return MTLPixelFormatBGRA10_XR;
  } else {
    return MTLPixelFormatInvalid;
  }
}

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.

                                                         {
#if !FML_OS_IOS
  if (@available(macOS 10.11, *)) {
    return MTLPixelFormatDepth24Unorm_Stencil8;
  }
#endif  // FML_OS_IOS
  return MTLPixelFormatInvalid;
}

Referenced by ToMTLPixelFormat().

Saturation()

static constexpr Scalar impeller::Saturation ( Vector3  color )

inlinestaticconstexpr

Definition at line 89 of file color.cc.

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

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

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

ScalarNearlyEqual()

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

inlineconstexpr

Definition at line 36 of file scalar.h.

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

References ScalarNearlyZero(), and x.

Referenced by impeller::RoundingRadii::AreAllCornersSame(), CreateGradientBuffer(), impeller::Matrix::Equals(), impeller::RoundRect::IsOval(), impeller::RoundSuperellipse::IsOval(), impeller::Color::operator==(), impeller::testing::TEST(), and impeller::Color::Unpremultiply().

ScalarNearlyZero()

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

inlineconstexpr

Definition at line 31 of file scalar.h.

                                                                          {
  return Absolute(x) <= tolerance;
}

References Absolute(), and x.

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

ScalarToHalf()

constexpr InternalHalf impeller::ScalarToHalf ( Scalar  f )

inlineconstexpr

Convert a scalar to a half precision float.

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

Definition at line 32 of file half.h.

                                                     {
#ifdef FML_OS_WIN
  return static_cast<InternalHalf>(0);
#else
  return static_cast<InternalHalf>(f);
#endif
}

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

SetLuminosity()

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

inlinestaticconstexpr

Definition at line 83 of file color.cc.

                                                                 {
  Scalar relative_lum = luminosity - Luminosity(color);
  return ClipColor(color + relative_lum);
}

References ClipColor(), and Luminosity().

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

SetSaturation()

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

inlinestaticconstexpr

Definition at line 94 of file color.cc.

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

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.

                                                {
  static bool swiftshader_preference = false;
  static std::once_flag sOnceInitializer;
  std::call_once(sOnceInitializer, [use_swiftshader]() {
    if (use_swiftshader) {
      FindSwiftShaderICDAtKnownPaths();
      swiftshader_preference = use_swiftshader;
    }
  });
  FML_CHECK(swiftshader_preference == use_swiftshader)
      << "The option to use SwiftShader in a process can only be set once and "
         "may not be changed later.";
}

References FindSwiftShaderICDAtKnownPaths().

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

ShaderLibraryMappingsForPlayground() [1/3]

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

static

Definition at line 106 of file playground_impl_gles.cc.

                                     {
  return {
      std::make_shared<fml::NonOwnedMapping>(
          impeller_entity_shaders_gles_data,
          impeller_entity_shaders_gles_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_modern_shaders_gles_data,
          impeller_modern_shaders_gles_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_framebuffer_blend_shaders_gles_data,
          impeller_framebuffer_blend_shaders_gles_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_fixtures_shaders_gles_data,
          impeller_fixtures_shaders_gles_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_modern_fixtures_shaders_gles_data,
          impeller_modern_fixtures_shaders_gles_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_imgui_shaders_gles_data, impeller_imgui_shaders_gles_length),
  };
}

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

ShaderLibraryMappingsForPlayground() [2/3]

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

static

Definition at line 37 of file playground_impl_mtl.mm.

                                     {
  return {std::make_shared<fml::NonOwnedMapping>(
              impeller_entity_shaders_data, impeller_entity_shaders_length),
          std::make_shared<fml::NonOwnedMapping>(
              impeller_modern_shaders_data, impeller_modern_shaders_length),
          std::make_shared<fml::NonOwnedMapping>(
              impeller_framebuffer_blend_shaders_data,
              impeller_framebuffer_blend_shaders_length),
          std::make_shared<fml::NonOwnedMapping>(
              impeller_fixtures_shaders_data, impeller_fixtures_shaders_length),
          std::make_shared<fml::NonOwnedMapping>(
              impeller_modern_fixtures_shaders_data,
              impeller_modern_fixtures_shaders_length),
          std::make_shared<fml::NonOwnedMapping>(impeller_imgui_shaders_data,
                                                 impeller_imgui_shaders_length),
          std::make_shared<fml::NonOwnedMapping>(
              impeller_compute_shaders_data, impeller_compute_shaders_length)
 
  };
}

ShaderLibraryMappingsForPlayground() [3/3]

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

static

Definition at line 31 of file playground_impl_vk.cc.

                                     {
  return {
      std::make_shared<fml::NonOwnedMapping>(impeller_entity_shaders_vk_data,
                                             impeller_entity_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(impeller_modern_shaders_vk_data,
                                             impeller_modern_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_framebuffer_blend_shaders_vk_data,
          impeller_framebuffer_blend_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_fixtures_shaders_vk_data,
          impeller_fixtures_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_modern_fixtures_shaders_vk_data,
          impeller_modern_fixtures_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(impeller_imgui_shaders_vk_data,
                                             impeller_imgui_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_compute_shaders_vk_data, impeller_compute_shaders_vk_length),
  };
}

SizeToPoint()

Point impeller::SizeToPoint

(

Size

size

)

Definition at line 21 of file text_contents.cc.

                             {
  return Point(size.width, size.height);
}

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

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

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.

                  {
  // Sort the IR so that the uniforms are in declaration order.
  std::vector<spirv_cross::ID> uniforms;
  ir->for_each_typed_id<spirv_cross::SPIRVariable>(
      [&](uint32_t, const spirv_cross::SPIRVariable& var) {
        if (var.storage != spv::StorageClassUniformConstant) {
          return;
        }
        const auto& type = compiler->get_type(var.basetype);
        if (!type_filter.has_value() ||
            (include && type_filter.value() == type.basetype) ||
            (!include && type_filter.value() != type.basetype)) {
          uniforms.push_back(var.self);
        }
      });
 
  auto compare_locations = [&ir](spirv_cross::ID id1, spirv_cross::ID id2) {
    auto& flags1 = ir->get_decoration_bitset(id1);
    auto& flags2 = ir->get_decoration_bitset(id2);
    // Put the uniforms with no location after the ones that have a location.
    if (!flags1.get(spv::Decoration::DecorationLocation)) {
      return false;
    }
    if (!flags2.get(spv::Decoration::DecorationLocation)) {
      return true;
    }
    // Sort in increasing order of location.
    return ir->get_decoration(id1, spv::Decoration::DecorationLocation) <
           ir->get_decoration(id2, spv::Decoration::DecorationLocation);
  };
  std::sort(uniforms.begin(), uniforms.end(), compare_locations);
 
  return uniforms;
}

References type.

SPrintF()

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

Definition at line 12 of file strings.cc.

                                           {
  std::string ret_val;
  va_list list;
  va_list list2;
  va_start(list, format);
  va_copy(list2, list);
  if (auto string_length = ::vsnprintf(nullptr, 0, format, list);
      string_length >= 0) {
    auto buffer = reinterpret_cast<char*>(::malloc(string_length + 1));
    ::vsnprintf(buffer, string_length + 1, format, list2);
    ret_val = std::string{buffer, static_cast<size_t>(string_length)};
    ::free(buffer);
  }
  va_end(list2);
  va_end(list);
  return ret_val;
}

Referenced by impeller::BlitPass::AddCopy(), ColorToString(), CreateCompatRenderPassForPipeline(), DepthAttachmentToString(), impeller::ProcTableGLES::DescribeCurrentFramebuffer(), DrawPlaygroundPoint(), ImGui_ImplImpeller_RenderDrawData(), impeller::ComputePipelineBuilder< ComputeShader_ >::InitializePipelineDescriptorDefaults(), impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::InitializePipelineDescriptorDefaults(), LinkProgram(), impeller::VerticesSimpleBlendContents::Render(), impeller::ContextVK::SetDebugName(), impeller::testing::TEST(), and impeller::RenderTarget::ToString().

StencilAttachmentToString()

std::string impeller::StencilAttachmentToString

(

const StencilAttachment &

stencil

)

Definition at line 137 of file formats.cc.

                                                                      {
  std::stringstream stream;
  stream << AttachmentToString(stencil) << ",";
  stream << "ClearStencil=" << stencil.clear_stencil;
  return stream.str();
}

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

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

StorageModeToString()

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

constexpr

Definition at line 60 of file formats.h.

                                                            {
  switch (mode) {
    case StorageMode::kHostVisible:
      return "HostVisible";
    case StorageMode::kDevicePrivate:
      return "DevicePrivate";
    case StorageMode::kDeviceTransient:
      return "DeviceTransient";
  }
  FML_UNREACHABLE();
}

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.

                                                                  {
  switch (action) {
    case StoreAction::kDontCare:
    case StoreAction::kStore:
      return false;
    case StoreAction::kMultisampleResolve:
    case StoreAction::kStoreAndMultisampleResolve:
      return true;
  }
}

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

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

StoreActionPerformsResolve()

constexpr bool impeller::StoreActionPerformsResolve ( StoreAction  store_action )

constexpr

Definition at line 343 of file formats_vk.h.

                                                                    {
  switch (store_action) {
    case StoreAction::kDontCare:
    case StoreAction::kStore:
      return false;
    case StoreAction::kMultisampleResolve:
    case StoreAction::kStoreAndMultisampleResolve:
      return true;
  }
  FML_UNREACHABLE();
}

References kDontCare, kMultisampleResolve, kStore, and kStoreAndMultisampleResolve.

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

StoreActionToString()

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

constexpr

Definition at line 226 of file formats.h.

                                                              {
  switch (action) {
    case StoreAction::kDontCare:
      return "DontCare";
    case StoreAction::kStore:
      return "Store";
    case StoreAction::kMultisampleResolve:
      return "MultisampleResolve";
    case StoreAction::kStoreAndMultisampleResolve:
      return "StoreAndMultisampleResolve";
  }
}

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.

                                                   {
  if (!HasPrefix(string, to_strip)) {
    return string;
  }
  return string.substr(to_strip.length());
}

References HasPrefix().

Referenced by DetermineVersion().

SubpixelPositionToPoint()

static Point impeller::SubpixelPositionToPoint ( SubpixelPosition  pos )

static

Definition at line 207 of file typographer_context_skia.cc.

                                                           {
  return Point((pos & 0xff) / 4.f, (pos >> 2 & 0xff) / 4.f);
}

Referenced by DrawGlyph().

SupportsLossyTextureCompression()

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

static

Definition at line 40 of file allocator_mtl.mm.

                                                                  {
#ifdef FML_OS_IOS_SIMULATOR
  return false;
#else
  return [device supportsFamily:MTLGPUFamilyApple8];
#endif
}

Tessellate()

IMPELLER_API struct Vertices * impeller::Tessellate	(	PathBuilder *	builder,
		int	fill_type,
		Scalar	tolerance
	)

Definition at line 42 of file tessellator.cc.

                                              {
  builder->SetFillType(static_cast<FillType>(fill_type));
  auto path = builder->CopyPath();
  std::vector<float> points;
  if (TessellatorLibtess{}.Tessellate(
          path, tolerance,
          [&points](const float* vertices, size_t vertices_count,
                    const uint16_t* indices, size_t indices_count) {
            // Results are expected to be re-duplicated.
            std::vector<Point> raw_points;
            for (auto i = 0u; i < vertices_count * 2; i += 2) {
              raw_points.emplace_back(Point{vertices[i], vertices[i + 1]});
            }
            for (auto i = 0u; i < indices_count; i++) {
              auto point = raw_points[indices[i]];
              points.push_back(point.x);
              points.push_back(point.y);
            }
            return true;
          }) != TessellatorLibtess::Result::kSuccess) {
    return nullptr;
  }
 
  Vertices* vertices = new Vertices();
  vertices->points = new float[points.size()];
  if (!vertices->points) {
    return nullptr;
  }
  vertices->length = points.size();
  std::copy(points.begin(), points.end(), vertices->points);
  return vertices;
}

References impeller::TessellatorLibtess::kSuccess, points, and impeller::TessellatorLibtess::Tessellate().

TEST() [1/12]

impeller::TEST	(	RationalTest	,
		DifferentHashes
	)

Definition at line 53 of file rational_unittests.cc.

                                    {
  EXPECT_NE(Rational(2, 2).GetHash(), Rational(2, 4).GetHash());
}

TEST() [2/12]

impeller::TEST	(	RationalTest	,
		EqualsDifferentDen
	)

Definition at line 25 of file rational_unittests.cc.

                                       {
  EXPECT_TRUE(Rational(1, 2) == Rational(2, 4));
}

TEST() [3/12]

impeller::TEST	(	RationalTest	,
		EqualsSameDen
	)

Definition at line 17 of file rational_unittests.cc.

                                  {
  EXPECT_TRUE(Rational(1, 2) == Rational(1, 2));
}

TEST() [4/12]

impeller::TEST	(	RationalTest	,
		LessThanDifferentDen
	)

Definition at line 41 of file rational_unittests.cc.

                                         {
  EXPECT_TRUE(Rational(1, 2) < Rational(25, 23));
}

TEST() [5/12]

impeller::TEST	(	RationalTest	,
		LessThanNegation
	)

Definition at line 37 of file rational_unittests.cc.

                                     {
  EXPECT_TRUE(Rational(-1, 2) < Rational(2, 23));
}

TEST() [6/12]

impeller::TEST	(	RationalTest	,
		LessThanSameDen
	)

Definition at line 33 of file rational_unittests.cc.

                                    {
  EXPECT_TRUE(Rational(1, 2) < Rational(2, 2));
}

TEST() [7/12]

impeller::TEST	(	RationalTest	,
		Make
	)

Definition at line 11 of file rational_unittests.cc.

                         {
  Rational value(1, 2);
  EXPECT_EQ(value.GetNumerator(), 1);
  EXPECT_EQ(value.GetDenominator(), 2u);
}

References value.

TEST() [8/12]

impeller::TEST	(	RationalTest	,
		NegationNotEquals
	)

Definition at line 29 of file rational_unittests.cc.

                                      {
  EXPECT_FALSE(Rational(1, 2) == Rational(-1, 2));
}

TEST() [9/12]

impeller::TEST	(	RationalTest	,
		NotEqualsSameDen
	)

Definition at line 21 of file rational_unittests.cc.

                                     {
  EXPECT_FALSE(Rational(3, 2) == Rational(1, 2));
}

TEST() [10/12]

impeller::TEST	(	RationalTest	,
		NotLessThanDifferentDen
	)

Definition at line 45 of file rational_unittests.cc.

                                            {
  EXPECT_FALSE(Rational(25, 23) < Rational(1, 2));
}

TEST() [11/12]

impeller::TEST	(	RationalTest	,
		SameHashes
	)

Definition at line 49 of file rational_unittests.cc.

                               {
  EXPECT_EQ(Rational(1, 2).GetHash(), Rational(2, 4).GetHash());
}

TEST() [12/12]

impeller::TEST	(	ValidationTest	,
		IsFatal
	)

Definition at line 29 of file main.cc.

                              {
  EXPECT_TRUE(ImpellerValidationErrorsAreFatal());
}

References ImpellerValidationErrorsAreFatal().

TextureDescriptorToString()

std::string impeller::TextureDescriptorToString

(

const TextureDescriptor &

desc

)

Definition at line 11 of file texture_descriptor.cc.

                                                                   {
  std::stringstream stream;
  stream << "StorageMode=" << StorageModeToString(desc.storage_mode) << ",";
  stream << "Type=" << TextureTypeToString(desc.type) << ",";
  stream << "Format=" << PixelFormatToString(desc.format) << ",";
  stream << "Size=" << desc.size << ",";
  stream << "MipCount=" << desc.mip_count << ",";
  stream << "SampleCount=" << static_cast<size_t>(desc.sample_count) << ",";
  stream << "Compression=" << CompressionTypeToString(desc.compression_type);
  return stream.str();
}

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

                                                            {
  switch (type) {
    case TextureType::kTexture2D:
      return "Texture2D";
    case TextureType::kTexture2DMultisample:
      return "Texture2DMultisample";
    case TextureType::kTextureCube:
      return "TextureCube";
    case TextureType::kTextureExternalOES:
      return "TextureExternalOES";
  }
  FML_UNREACHABLE();
}

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

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.

                                                          {
  std::vector<TextureUsage> usages;
  if (mask & TextureUsage::kShaderRead) {
    usages.push_back(TextureUsage::kShaderRead);
  }
  if (mask & TextureUsage::kShaderWrite) {
    usages.push_back(TextureUsage::kShaderWrite);
  }
  if (mask & TextureUsage::kRenderTarget) {
    usages.push_back(TextureUsage::kRenderTarget);
  }
  std::stringstream stream;
  stream << "{ ";
  for (size_t i = 0; i < usages.size(); i++) {
    stream << TextureUsageToString(usages[i]);
    if (i != usages.size() - 1u) {
      stream << ", ";
    }
  }
  stream << " }";
  return stream.str();
}

References kRenderTarget, kShaderRead, kShaderWrite, and TextureUsageToString().

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

TextureUsageToString()

constexpr const char* impeller::TextureUsageToString ( TextureUsage  usage )

constexpr

Definition at line 310 of file formats.h.

                                                               {
  switch (usage) {
    case TextureUsage::kUnknown:
      return "Unknown";
    case TextureUsage::kShaderRead:
      return "ShaderRead";
    case TextureUsage::kShaderWrite:
      return "ShaderWrite";
    case TextureUsage::kRenderTarget:
      return "RenderTarget";
  }
  FML_UNREACHABLE();
}

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.

                                      {
  switch (tile_mode) {
    case Entity::TileMode::kClamp:
      return SamplerAddressMode::kClampToEdge;
      break;
    case Entity::TileMode::kMirror:
      return SamplerAddressMode::kMirror;
      break;
    case Entity::TileMode::kRepeat:
      return SamplerAddressMode::kRepeat;
      break;
    case Entity::TileMode::kDecal:
      if (capabilities.SupportsDecalSamplerAddressMode()) {
        return SamplerAddressMode::kDecal;
      }
      return std::nullopt;
  }
}

References impeller::Entity::kClamp, kClampToEdge, kDecal, impeller::Entity::kDecal, kMirror, impeller::Entity::kMirror, kRepeat, impeller::Entity::kRepeat, and impeller::Capabilities::SupportsDecalSamplerAddressMode().

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

ToAddressMode()

static GLint impeller::ToAddressMode ( SamplerAddressMode  mode, bool  supports_decal_sampler_address_mode  )

static

Definition at line 52 of file sampler_gles.cc.

                                                                     {
  switch (mode) {
    case SamplerAddressMode::kClampToEdge:
      return GL_CLAMP_TO_EDGE;
    case SamplerAddressMode::kRepeat:
      return GL_REPEAT;
    case SamplerAddressMode::kMirror:
      return GL_MIRRORED_REPEAT;
    case SamplerAddressMode::kDecal:
      if (supports_decal_sampler_address_mode) {
        return IMPELLER_GL_CLAMP_TO_BORDER;
      } else {
        return GL_CLAMP_TO_EDGE;
      }
  }
  FML_UNREACHABLE();
}

References IMPELLER_GL_CLAMP_TO_BORDER.

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

ToArrayLayerCount()

constexpr uint32_t impeller::ToArrayLayerCount ( TextureType  type )

constexpr

Definition at line 539 of file formats_vk.h.

                                                       {
  switch (type) {
    case TextureType::kTexture2D:
    case TextureType::kTexture2DMultisample:
      return 1u;
    case TextureType::kTextureCube:
      return 6u;
    case TextureType::kTextureExternalOES:
      VALIDATION_LOG
          << "kTextureExternalOES can not be used with the Vulkan backend.";
  }
  FML_UNREACHABLE();
}

References kTexture2D, kTexture2DMultisample, kTextureCube, kTextureExternalOES, type, 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 598 of file texture_gles.cc.

                                                                {
  switch (point) {
    case TextureGLES::AttachmentType::kColor0:
      return GL_COLOR_ATTACHMENT0;
    case TextureGLES::AttachmentType::kDepth:
      return GL_DEPTH_ATTACHMENT;
    case TextureGLES::AttachmentType::kStencil:
      return GL_STENCIL_ATTACHMENT;
  }
}

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

                                                   {
  switch (factor) {
    case BlendFactor::kZero:
      return GL_ZERO;
    case BlendFactor::kOne:
      return GL_ONE;
    case BlendFactor::kSourceColor:
      return GL_SRC_COLOR;
    case BlendFactor::kOneMinusSourceColor:
      return GL_ONE_MINUS_SRC_COLOR;
    case BlendFactor::kSourceAlpha:
      return GL_SRC_ALPHA;
    case BlendFactor::kOneMinusSourceAlpha:
      return GL_ONE_MINUS_SRC_ALPHA;
    case BlendFactor::kDestinationColor:
      return GL_DST_COLOR;
    case BlendFactor::kOneMinusDestinationColor:
      return GL_ONE_MINUS_DST_COLOR;
    case BlendFactor::kDestinationAlpha:
      return GL_DST_ALPHA;
    case BlendFactor::kOneMinusDestinationAlpha:
      return GL_ONE_MINUS_DST_ALPHA;
    case BlendFactor::kSourceAlphaSaturated:
      return GL_SRC_ALPHA_SATURATE;
    case BlendFactor::kBlendColor:
      return GL_CONSTANT_COLOR;
    case BlendFactor::kOneMinusBlendColor:
      return GL_ONE_MINUS_CONSTANT_COLOR;
    case BlendFactor::kBlendAlpha:
      return GL_CONSTANT_ALPHA;
    case BlendFactor::kOneMinusBlendAlpha:
      return GL_ONE_MINUS_CONSTANT_ALPHA;
  }
  FML_UNREACHABLE();
}

References kBlendAlpha, kBlendColor, kDestinationAlpha, kDestinationColor, kOne, kOneMinusBlendAlpha, kOneMinusBlendColor, kOneMinusDestinationAlpha, kOneMinusDestinationColor, kOneMinusSourceAlpha, kOneMinusSourceColor, kSourceAlpha, kSourceAlphaSaturated, kSourceColor, and kZero.

Referenced by ConfigureBlending().

ToBlendOperation()

constexpr GLenum impeller::ToBlendOperation ( BlendOperation  op )

constexpr

Definition at line 128 of file formats_gles.h.

                                                     {
  switch (op) {
    case BlendOperation::kAdd:
      return GL_FUNC_ADD;
    case BlendOperation::kSubtract:
      return GL_FUNC_SUBTRACT;
    case BlendOperation::kReverseSubtract:
      return GL_FUNC_REVERSE_SUBTRACT;
  }
  FML_UNREACHABLE();
}

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ConfigureBlending().

ToBlurStyle()

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

static

Definition at line 256 of file dl_dispatcher.cc.

                                                                          {
  switch (blur_style) {
    case flutter::DlBlurStyle::kNormal:
      return FilterContents::BlurStyle::kNormal;
    case flutter::DlBlurStyle::kSolid:
      return FilterContents::BlurStyle::kSolid;
    case flutter::DlBlurStyle::kOuter:
      return FilterContents::BlurStyle::kOuter;
    case flutter::DlBlurStyle::kInner:
      return FilterContents::BlurStyle::kInner;
  }
}

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

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

ToClipOperation()

static Entity::ClipOperation impeller::ToClipOperation ( flutter::DlClipOp  clip_op )

static

Definition at line 427 of file dl_dispatcher.cc.

                                                                    {
  switch (clip_op) {
    case flutter::DlClipOp::kDifference:
      return Entity::ClipOperation::kDifference;
    case flutter::DlClipOp::kIntersect:
      return Entity::ClipOperation::kIntersect;
  }
}

References impeller::Entity::kDifference, and impeller::Entity::kIntersect.

Referenced by impeller::DlDispatcherBase::clipOval(), impeller::DlDispatcherBase::clipPath(), impeller::DlDispatcherBase::clipRect(), impeller::DlDispatcherBase::clipRoundRect(), and impeller::DlDispatcherBase::clipRoundSuperellipse().

ToCommitResult()

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

static

Definition at line 153 of file command_buffer_mtl.mm.

                                                                         {
  switch (status) {
    case MTLCommandBufferStatusCompleted:
      return CommandBufferMTL::Status::kCompleted;
    case MTLCommandBufferStatusEnqueued:
      return CommandBufferMTL::Status::kPending;
    default:
      break;
  }
  return CommandBufferMTL::Status::kError;
}

ToCompareFunction()

constexpr GLenum impeller::ToCompareFunction ( CompareFunction  func )

constexpr

Definition at line 70 of file formats_gles.h.

                                                         {
  switch (func) {
    case CompareFunction::kNever:
      return GL_NEVER;
    case CompareFunction::kAlways:
      return GL_ALWAYS;
    case CompareFunction::kLess:
      return GL_LESS;
    case CompareFunction::kEqual:
      return GL_EQUAL;
    case CompareFunction::kLessEqual:
      return GL_LEQUAL;
    case CompareFunction::kGreater:
      return GL_GREATER;
    case CompareFunction::kNotEqual:
      return GL_NOTEQUAL;
    case CompareFunction::kGreaterEqual:
      return GL_GEQUAL;
  }
  FML_UNREACHABLE();
}

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

                                                                     {
  switch (type) {
    case DebugResourceType::kTexture:
      return GL_TEXTURE;
    case DebugResourceType::kBuffer:
      return GL_BUFFER_KHR;
    case DebugResourceType::kProgram:
      return GL_PROGRAM_KHR;
    case DebugResourceType::kShader:
      return GL_SHADER_KHR;
    case DebugResourceType::kRenderBuffer:
      return GL_RENDERBUFFER;
    case DebugResourceType::kFrameBuffer:
      return GL_FRAMEBUFFER;
    case DebugResourceType::kFence:
      return GL_SYNC_FENCE;
  }
  FML_UNREACHABLE();
}

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

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

ToDebugResourceType()

static DebugResourceType impeller::ToDebugResourceType ( HandleType  type )

static

Definition at line 268 of file reactor_gles.cc.

                                                              {
  switch (type) {
    case HandleType::kUnknown:
      FML_UNREACHABLE();
    case HandleType::kTexture:
      return DebugResourceType::kTexture;
    case HandleType::kBuffer:
      return DebugResourceType::kBuffer;
    case HandleType::kProgram:
      return DebugResourceType::kProgram;
    case HandleType::kRenderBuffer:
      return DebugResourceType::kRenderBuffer;
    case HandleType::kFrameBuffer:
      return DebugResourceType::kFrameBuffer;
    case HandleType::kFence:
      return DebugResourceType::kFence;
  }
  FML_UNREACHABLE();
}

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

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

ToDeviceType()

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

constexpr

Definition at line 239 of file driver_info_vk.cc.

                                                                      {
  switch (type) {
    case vk::PhysicalDeviceType::eOther:
      return DeviceTypeVK::kUnknown;
    case vk::PhysicalDeviceType::eIntegratedGpu:
      return DeviceTypeVK::kIntegratedGPU;
    case vk::PhysicalDeviceType::eDiscreteGpu:
      return DeviceTypeVK::kDiscreteGPU;
    case vk::PhysicalDeviceType::eVirtualGpu:
      return DeviceTypeVK::kVirtualGPU;
    case vk::PhysicalDeviceType::eCpu:
      return DeviceTypeVK::kCPU;
      break;
  }
  return DeviceTypeVK::kUnknown;
}

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

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

ToFont()

static Font impeller::ToFont ( const SkTextBlobRunIterator &  run, AxisAlignment  alignment  )

static

Definition at line 25 of file text_frame_skia.cc.

                                                                              {
  auto& font = run.font();
  auto typeface = std::make_shared<TypefaceSkia>(font.refTypeface());
 
  SkFontMetrics sk_metrics;
  font.getMetrics(&sk_metrics);
 
  Font::Metrics metrics;
  metrics.point_size = font.getSize();
  metrics.embolden = font.isEmbolden();
  metrics.skewX = font.getSkewX();
  metrics.scaleX = font.getScaleX();
 
  return Font{std::move(typeface), metrics, alignment};
}

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

                                              {
  switch (type) {
    case TextureGLES::Type::kTexture:
    case TextureGLES::Type::kTextureMultisampled:
      return HandleType::kTexture;
    case TextureGLES::Type::kRenderBuffer:
    case TextureGLES::Type::kRenderBufferMultisampled:
      return HandleType::kRenderBuffer;
  }
  FML_UNREACHABLE();
}

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

ToImageAspectFlags()

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

constexpr

Definition at line 586 of file formats_vk.h.

                                                                    {
  switch (format) {
    case PixelFormat::kUnknown:
      return {};
    case PixelFormat::kA8UNormInt:
    case PixelFormat::kR8UNormInt:
    case PixelFormat::kR8G8UNormInt:
    case PixelFormat::kR8G8B8A8UNormInt:
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
    case PixelFormat::kB8G8R8A8UNormInt:
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
    case PixelFormat::kR32G32B32A32Float:
    case PixelFormat::kR16G16B16A16Float:
    case PixelFormat::kB10G10R10XR:
    case PixelFormat::kB10G10R10XRSRGB:
    case PixelFormat::kB10G10R10A10XR:
      return vk::ImageAspectFlagBits::eColor;
    case PixelFormat::kS8UInt:
      return vk::ImageAspectFlagBits::eStencil;
    case PixelFormat::kD24UnormS8Uint:
    case PixelFormat::kD32FloatS8UInt:
      return vk::ImageAspectFlagBits::eDepth |
             vk::ImageAspectFlagBits::eStencil;
  }
  FML_UNREACHABLE();
}

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

Referenced by impeller::TextureSourceVK::SetLayout().

ToIndexType()

constexpr GLenum impeller::ToIndexType ( IndexType  type )

constexpr

Definition at line 35 of file formats_gles.h.

                                             {
  switch (type) {
    case IndexType::kUnknown:
    case IndexType::kNone:
      FML_UNREACHABLE();
    case IndexType::k16bit:
      return GL_UNSIGNED_SHORT;
    case IndexType::k32bit:
      return GL_UNSIGNED_INT;
  }
  FML_UNREACHABLE();
}

References k16bit, k32bit, kNone, kUnknown, and type.

Referenced by EncodeCommandsInReactor().

ToMode()

constexpr GLenum impeller::ToMode ( PrimitiveType  primitive_type )

constexpr

Definition at line 17 of file formats_gles.h.

                                                      {
  switch (primitive_type) {
    case PrimitiveType::kTriangle:
      return GL_TRIANGLES;
    case PrimitiveType::kTriangleStrip:
      return GL_TRIANGLE_STRIP;
    case PrimitiveType::kLine:
      return GL_LINES;
    case PrimitiveType::kLineStrip:
      return GL_LINE_STRIP;
    case PrimitiveType::kPoint:
      return GL_POINTS;
    case PrimitiveType::kTriangleFan:
      return GL_TRIANGLE_FAN;
  }
  FML_UNREACHABLE();
}

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

Referenced by EncodeCommandsInReactor().

ToMTLBlendFactor()

constexpr MTLBlendFactor impeller::ToMTLBlendFactor ( BlendFactor  type )

constexpr

Definition at line 114 of file formats_mtl.h.

                                                            {
  switch (type) {
    case BlendFactor::kZero:
      return MTLBlendFactorZero;
    case BlendFactor::kOne:
      return MTLBlendFactorOne;
    case BlendFactor::kSourceColor:
      return MTLBlendFactorSourceColor;
    case BlendFactor::kOneMinusSourceColor:
      return MTLBlendFactorOneMinusSourceColor;
    case BlendFactor::kSourceAlpha:
      return MTLBlendFactorSourceAlpha;
    case BlendFactor::kOneMinusSourceAlpha:
      return MTLBlendFactorOneMinusSourceAlpha;
    case BlendFactor::kDestinationColor:
      return MTLBlendFactorDestinationColor;
    case BlendFactor::kOneMinusDestinationColor:
      return MTLBlendFactorOneMinusDestinationColor;
    case BlendFactor::kDestinationAlpha:
      return MTLBlendFactorDestinationAlpha;
    case BlendFactor::kOneMinusDestinationAlpha:
      return MTLBlendFactorOneMinusDestinationAlpha;
    case BlendFactor::kSourceAlphaSaturated:
      return MTLBlendFactorSourceAlphaSaturated;
    case BlendFactor::kBlendColor:
      return MTLBlendFactorBlendColor;
    case BlendFactor::kOneMinusBlendColor:
      return MTLBlendFactorOneMinusBlendColor;
    case BlendFactor::kBlendAlpha:
      return MTLBlendFactorBlendAlpha;
    case BlendFactor::kOneMinusBlendAlpha:
      return MTLBlendFactorOneMinusBlendAlpha;
  }
  return MTLBlendFactorZero;
};

References kBlendAlpha, kBlendColor, kDestinationAlpha, kDestinationColor, kOne, kOneMinusBlendAlpha, kOneMinusBlendColor, kOneMinusDestinationAlpha, kOneMinusDestinationColor, kOneMinusSourceAlpha, kOneMinusSourceColor, kSourceAlpha, kSourceAlphaSaturated, kSourceColor, kZero, and type.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

ToMTLBlendOperation()

constexpr MTLBlendOperation impeller::ToMTLBlendOperation ( BlendOperation  type )

constexpr

Definition at line 201 of file formats_mtl.h.

                                                                     {
  switch (type) {
    case BlendOperation::kAdd:
      return MTLBlendOperationAdd;
    case BlendOperation::kSubtract:
      return MTLBlendOperationSubtract;
    case BlendOperation::kReverseSubtract:
      return MTLBlendOperationReverseSubtract;
  }
  return MTLBlendOperationAdd;
};

References kAdd, kReverseSubtract, kSubtract, and type.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

ToMTLClearColor()

MTLClearColor impeller::ToMTLClearColor ( const Color &  color )

inline

Definition at line 374 of file formats_mtl.h.

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

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

                                                                     {
  MTLColorWriteMask mask = MTLColorWriteMaskNone;
 
  if (type & ColorWriteMaskBits::kRed) {
    mask |= MTLColorWriteMaskRed;
  }
 
  if (type & ColorWriteMaskBits::kGreen) {
    mask |= MTLColorWriteMaskGreen;
  }
 
  if (type & ColorWriteMaskBits::kBlue) {
    mask |= MTLColorWriteMaskBlue;
  }
 
  if (type & ColorWriteMaskBits::kAlpha) {
    mask |= MTLColorWriteMaskAlpha;
  }
 
  return mask;
};

References kAlpha, kBlue, kGreen, kRed, and type.

Referenced by ToMTLRenderPipelineColorAttachmentDescriptor().

ToMTLCompareFunction()

constexpr MTLCompareFunction impeller::ToMTLCompareFunction ( CompareFunction  func )

constexpr

Definition at line 235 of file formats_mtl.h.

                                                                        {
  switch (func) {
    case CompareFunction::kNever:
      return MTLCompareFunctionNever;
    case CompareFunction::kLess:
      return MTLCompareFunctionLess;
    case CompareFunction::kEqual:
      return MTLCompareFunctionEqual;
    case CompareFunction::kLessEqual:
      return MTLCompareFunctionLessEqual;
    case CompareFunction::kGreater:
      return MTLCompareFunctionGreater;
    case CompareFunction::kNotEqual:
      return MTLCompareFunctionNotEqual;
    case CompareFunction::kGreaterEqual:
      return MTLCompareFunctionGreaterEqual;
    case CompareFunction::kAlways:
      return MTLCompareFunctionAlways;
  }
  return MTLCompareFunctionAlways;
};

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

                                                   {
  switch (mode) {
    case CullMode::kNone:
      return MTLCullModeNone;
    case CullMode::kBackFace:
      return MTLCullModeBack;
    case CullMode::kFrontFace:
      return MTLCullModeFront;
  }
  return MTLCullModeNone;
}

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.

                                                   {
  if (!depth) {
    depth = DepthAttachmentDescriptor{
        // Always pass the depth test.
        .depth_compare = CompareFunction::kAlways,
        .depth_write_enabled = false,
    };
  }
 
  auto des = [[MTLDepthStencilDescriptor alloc] init];
 
  // These temporary variables are necessary for clang-tidy (Fuchsia LLVM
  // version 17.0.0git) to not crash.
  auto compare_function = ToMTLCompareFunction(depth->depth_compare);
  auto depth_write_enabled = depth->depth_write_enabled;
 
  des.depthCompareFunction = compare_function;
  des.depthWriteEnabled = depth_write_enabled;
 
  if (front.has_value()) {
    des.frontFaceStencil = ToMTLStencilDescriptor(front.value());
  }
  if (back.has_value()) {
    des.backFaceStencil = ToMTLStencilDescriptor(back.value());
  }
 
  return des;
}

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.

                                                            {
  switch (stage) {
    case ShaderStage::kVertex:
      return MTLFunctionTypeVertex;
    case ShaderStage::kFragment:
      return MTLFunctionTypeFragment;
    case ShaderStage::kUnknown:
    case ShaderStage::kCompute:
      return MTLFunctionTypeKernel;
  }
  FML_UNREACHABLE();
}

ToMTLIndexType()

constexpr MTLIndexType impeller::ToMTLIndexType ( IndexType  type )

constexpr

Definition at line 180 of file formats_mtl.h.

                                                      {
  switch (type) {
    case IndexType::k16bit:
      return MTLIndexTypeUInt16;
    default:
      return MTLIndexTypeUInt32;
  }
}

References k16bit, and type.

ToMTLLoadAction()

constexpr MTLLoadAction impeller::ToMTLLoadAction ( LoadAction  action )

constexpr

Definition at line 279 of file formats_mtl.h.

                                                           {
  switch (action) {
    case LoadAction::kDontCare:
      return MTLLoadActionDontCare;
    case LoadAction::kLoad:
      return MTLLoadActionLoad;
    case LoadAction::kClear:
      return MTLLoadActionClear;
  }
 
  return MTLLoadActionDontCare;
}

References kClear, kDontCare, and kLoad.

Referenced by ConfigureAttachment().

ToMTLPixelFormat()

constexpr MTLPixelFormat impeller::ToMTLPixelFormat ( PixelFormat  format )

constexpr

Definition at line 76 of file formats_mtl.h.

                                                              {
  switch (format) {
    case PixelFormat::kUnknown:
      return MTLPixelFormatInvalid;
    case PixelFormat::kA8UNormInt:
      return MTLPixelFormatA8Unorm;
    case PixelFormat::kR8UNormInt:
      return MTLPixelFormatR8Unorm;
    case PixelFormat::kR8G8UNormInt:
      return MTLPixelFormatRG8Unorm;
    case PixelFormat::kB8G8R8A8UNormInt:
      return MTLPixelFormatBGRA8Unorm;
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
      return MTLPixelFormatBGRA8Unorm_sRGB;
    case PixelFormat::kR8G8B8A8UNormInt:
      return MTLPixelFormatRGBA8Unorm;
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
      return MTLPixelFormatRGBA8Unorm_sRGB;
    case PixelFormat::kR32G32B32A32Float:
      return MTLPixelFormatRGBA32Float;
    case PixelFormat::kR16G16B16A16Float:
      return MTLPixelFormatRGBA16Float;
    case PixelFormat::kS8UInt:
      return MTLPixelFormatStencil8;
    case PixelFormat::kD24UnormS8Uint:
      return SafeMTLPixelFormatDepth24Unorm_Stencil8();
    case PixelFormat::kD32FloatS8UInt:
      return MTLPixelFormatDepth32Float_Stencil8;
    case PixelFormat::kB10G10R10XRSRGB:
      return SafeMTLPixelFormatBGR10_XR_sRGB();
    case PixelFormat::kB10G10R10XR:
      return SafeMTLPixelFormatBGR10_XR();
    case PixelFormat::kB10G10R10A10XR:
      return SafeMTLPixelFormatBGRA10_XR();
  }
  return MTLPixelFormatInvalid;
};

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

Referenced by GetMTLRenderPipelineDescriptor(), impeller::PlaygroundImplMTL::PlaygroundImplMTL(), ToMTLRenderPipelineColorAttachmentDescriptor(), and ToMTLTextureDescriptor().

ToMTLPrimitiveType()

constexpr MTLPrimitiveType impeller::ToMTLPrimitiveType ( PrimitiveType  type )

constexpr

Definition at line 150 of file formats_mtl.h.

                                                                  {
  switch (type) {
    case PrimitiveType::kTriangle:
      return MTLPrimitiveTypeTriangle;
    case PrimitiveType::kTriangleStrip:
      return MTLPrimitiveTypeTriangleStrip;
    case PrimitiveType::kLine:
      return MTLPrimitiveTypeLine;
    case PrimitiveType::kLineStrip:
      return MTLPrimitiveTypeLineStrip;
    case PrimitiveType::kPoint:
      return MTLPrimitiveTypePoint;
    case PrimitiveType::kTriangleFan:
      // Callers are expected to perform a capability check for triangle fan
      // support.
      return MTLPrimitiveTypePoint;
  }
  return MTLPrimitiveTypePoint;
}

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

ToMTLRenderPassDescriptor()

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

static

Definition at line 103 of file render_pass_mtl.mm.

                              {
  auto result = [MTLRenderPassDescriptor renderPassDescriptor];
 
  bool configured_attachment = desc.IterateAllColorAttachments(
      [&result](size_t index, const ColorAttachment& attachment) -> bool {
        return ConfigureColorAttachment(attachment,
                                        result.colorAttachments[index]);
      });
 
  if (!configured_attachment) {
    VALIDATION_LOG << "Could not configure color attachments";
    return nil;
  }
 
  const auto& depth = desc.GetDepthAttachment();
 
  if (depth.has_value() &&
      !ConfigureDepthAttachment(depth.value(), result.depthAttachment)) {
    VALIDATION_LOG << "Could not configure depth attachment.";
    return nil;
  }
 
  const auto& stencil = desc.GetStencilAttachment();
 
  if (stencil.has_value() &&
      !ConfigureStencilAttachment(stencil.value(), result.stencilAttachment)) {
    VALIDATION_LOG << "Could not configure stencil attachment.";
    return nil;
  }
 
  return result;
}

References ConfigureColorAttachment(), ConfigureDepthAttachment(), ConfigureStencilAttachment(), impeller::RenderTarget::GetDepthAttachment(), impeller::RenderTarget::GetStencilAttachment(), impeller::RenderTarget::IterateAllColorAttachments(), and VALIDATION_LOG.

ToMTLRenderPipelineColorAttachmentDescriptor()

MTLRenderPipelineColorAttachmentDescriptor * impeller::ToMTLRenderPipelineColorAttachmentDescriptor

(

ColorAttachmentDescriptor

descriptor

)

Definition at line 15 of file formats_mtl.mm.

                                          {
  auto des = [[MTLRenderPipelineColorAttachmentDescriptor alloc] init];
  des.pixelFormat = ToMTLPixelFormat(descriptor.format);
 
  des.blendingEnabled = descriptor.blending_enabled;
 
  des.sourceRGBBlendFactor =
      ToMTLBlendFactor(descriptor.src_color_blend_factor);
  des.rgbBlendOperation = ToMTLBlendOperation(descriptor.color_blend_op);
  des.destinationRGBBlendFactor =
      ToMTLBlendFactor(descriptor.dst_color_blend_factor);
 
  des.sourceAlphaBlendFactor =
      ToMTLBlendFactor(descriptor.src_alpha_blend_factor);
  des.alphaBlendOperation = ToMTLBlendOperation(descriptor.alpha_blend_op);
  des.destinationAlphaBlendFactor =
      ToMTLBlendFactor(descriptor.dst_alpha_blend_factor);
 
  des.writeMask = ToMTLColorWriteMask(descriptor.write_mask);
  return des;
}

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

                                                                  {
  switch (type) {
    case StorageMode::kHostVisible:
#if FML_OS_IOS
      return MTLResourceStorageModeShared;
#else
      if (supports_uma) {
        return MTLResourceStorageModeShared;
      } else {
        return MTLResourceStorageModeManaged;
      }
#endif
    case StorageMode::kDevicePrivate:
      return MTLResourceStorageModePrivate;
    case StorageMode::kDeviceTransient:
      if (supports_memoryless_targets) {
        // Device may support but the OS has not been updated.
        if (@available(macOS 11.0, *)) {
          return MTLResourceStorageModeMemoryless;
        } else {
          return MTLResourceStorageModePrivate;
        }
      } else {
        return MTLResourceStorageModePrivate;
      }
      FML_UNREACHABLE();
  }
  FML_UNREACHABLE();
}

References kDevicePrivate, kDeviceTransient, kHostVisible, and type.

ToMTLSamplerAddressMode()

constexpr MTLSamplerAddressMode impeller::ToMTLSamplerAddressMode ( SamplerAddressMode  mode )

constexpr

Definition at line 359 of file formats_mtl.h.

                             {
  switch (mode) {
    case SamplerAddressMode::kClampToEdge:
      return MTLSamplerAddressModeClampToEdge;
    case SamplerAddressMode::kRepeat:
      return MTLSamplerAddressModeRepeat;
    case SamplerAddressMode::kMirror:
      return MTLSamplerAddressModeMirrorRepeat;
    case SamplerAddressMode::kDecal:
      return MTLSamplerAddressModeClampToZero;
  }
  return MTLSamplerAddressModeClampToEdge;
}

References kClampToEdge, kDecal, kMirror, and kRepeat.

ToMTLSamplerMinMagFilter()

constexpr MTLSamplerMinMagFilter impeller::ToMTLSamplerMinMagFilter ( MinMagFilter  filter )

constexpr

Definition at line 337 of file formats_mtl.h.

                                                                               {
  switch (filter) {
    case MinMagFilter::kNearest:
      return MTLSamplerMinMagFilterNearest;
    case MinMagFilter::kLinear:
      return MTLSamplerMinMagFilterLinear;
  }
  return MTLSamplerMinMagFilterNearest;
}

References kLinear, and kNearest.

ToMTLSamplerMipFilter()

constexpr MTLSamplerMipFilter impeller::ToMTLSamplerMipFilter ( MipFilter  filter )

constexpr

Definition at line 347 of file formats_mtl.h.

                                                                      {
  switch (filter) {
    case MipFilter::kBase:
      return MTLSamplerMipFilterNotMipmapped;
    case MipFilter::kNearest:
      return MTLSamplerMipFilterNearest;
    case MipFilter::kLinear:
      return MTLSamplerMipFilterLinear;
  }
  return MTLSamplerMipFilterNotMipmapped;
}

References kBase, kLinear, and kNearest.

ToMTLStencilDescriptor()

MTLStencilDescriptor* impeller::ToMTLStencilDescriptor

(

const StencilAttachmentDescriptor &

descriptor

)

Definition at line 38 of file formats_mtl.mm.

                                                   {
  auto des = [[MTLStencilDescriptor alloc] init];
  des.stencilCompareFunction = ToMTLCompareFunction(descriptor.stencil_compare);
  des.stencilFailureOperation =
      ToMTLStencilOperation(descriptor.stencil_failure);
  des.depthFailureOperation = ToMTLStencilOperation(descriptor.depth_failure);
  des.depthStencilPassOperation =
      ToMTLStencilOperation(descriptor.depth_stencil_pass);
 
  des.readMask = descriptor.read_mask;
  des.writeMask = descriptor.write_mask;
 
  return des;
}

References impeller::StencilAttachmentDescriptor::depth_failure, impeller::StencilAttachmentDescriptor::depth_stencil_pass, impeller::StencilAttachmentDescriptor::read_mask, impeller::StencilAttachmentDescriptor::stencil_compare, impeller::StencilAttachmentDescriptor::stencil_failure, ToMTLCompareFunction(), ToMTLStencilOperation(), and impeller::StencilAttachmentDescriptor::write_mask.

Referenced by ToMTLDepthStencilDescriptor().

ToMTLStencilOperation()

constexpr MTLStencilOperation impeller::ToMTLStencilOperation ( StencilOperation  op )

constexpr

Definition at line 257 of file formats_mtl.h.

                                                                         {
  switch (op) {
    case StencilOperation::kKeep:
      return MTLStencilOperationKeep;
    case StencilOperation::kZero:
      return MTLStencilOperationZero;
    case StencilOperation::kSetToReferenceValue:
      return MTLStencilOperationReplace;
    case StencilOperation::kIncrementClamp:
      return MTLStencilOperationIncrementClamp;
    case StencilOperation::kDecrementClamp:
      return MTLStencilOperationDecrementClamp;
    case StencilOperation::kInvert:
      return MTLStencilOperationInvert;
    case StencilOperation::kIncrementWrap:
      return MTLStencilOperationIncrementWrap;
    case StencilOperation::kDecrementWrap:
      return MTLStencilOperationDecrementWrap;
  }
  return MTLStencilOperationKeep;
};

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

                                                          {
  switch (mode) {
    case StorageMode::kHostVisible:
#if FML_OS_IOS
      return MTLStorageModeShared;
#else
      if (supports_uma) {
        return MTLStorageModeShared;
      } else {
        return MTLStorageModeManaged;
      }
#endif
    case StorageMode::kDevicePrivate:
      return MTLStorageModePrivate;
    case StorageMode::kDeviceTransient:
      if (supports_memoryless_targets) {
        // Device may support but the OS has not been updated.
        if (@available(macOS 11.0, *)) {
          return MTLStorageModeMemoryless;
        } else {
          return MTLStorageModePrivate;
        }
      } else {
        return MTLStorageModePrivate;
      }
      FML_UNREACHABLE();
  }
  FML_UNREACHABLE();
}

References kDevicePrivate, kDeviceTransient, and kHostVisible.

ToMTLStoreAction()

constexpr MTLStoreAction impeller::ToMTLStoreAction ( StoreAction  action )

constexpr

Definition at line 307 of file formats_mtl.h.

                                                              {
  switch (action) {
    case StoreAction::kDontCare:
      return MTLStoreActionDontCare;
    case StoreAction::kStore:
      return MTLStoreActionStore;
    case StoreAction::kMultisampleResolve:
      return MTLStoreActionMultisampleResolve;
    case StoreAction::kStoreAndMultisampleResolve:
      return MTLStoreActionStoreAndMultisampleResolve;
  }
  return MTLStoreActionDontCare;
}

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.

                                                                            {
  if (!desc.IsValid()) {
    return nil;
  }
  auto mtl_desc = [[MTLTextureDescriptor alloc] init];
  mtl_desc.textureType = ToMTLTextureType(desc.type);
  mtl_desc.pixelFormat = ToMTLPixelFormat(desc.format);
  mtl_desc.sampleCount = static_cast<NSUInteger>(desc.sample_count);
  mtl_desc.width = desc.size.width;
  mtl_desc.height = desc.size.height;
  mtl_desc.mipmapLevelCount = desc.mip_count;
  mtl_desc.usage = MTLTextureUsageUnknown;
  if (desc.usage & TextureUsage::kUnknown) {
    mtl_desc.usage |= MTLTextureUsageUnknown;
  }
  if (desc.usage & TextureUsage::kShaderRead) {
    mtl_desc.usage |= MTLTextureUsageShaderRead;
  }
  if (desc.usage & TextureUsage::kShaderWrite) {
    mtl_desc.usage |= MTLTextureUsageShaderWrite;
  }
  if (desc.usage & TextureUsage::kRenderTarget) {
    mtl_desc.usage |= MTLTextureUsageRenderTarget;
  }
  return mtl_desc;
}

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

                                                            {
  switch (type) {
    case TextureType::kTexture2D:
      return MTLTextureType2D;
    case TextureType::kTexture2DMultisample:
      return MTLTextureType2DMultisample;
    case TextureType::kTextureCube:
      return MTLTextureTypeCube;
    case TextureType::kTextureExternalOES:
      VALIDATION_LOG
          << "kTextureExternalOES can not be used with the Metal backend.";
  }
  return MTLTextureType2D;
}

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

Referenced by ToMTLTextureDescriptor().

ToMTLTriangleFillMode()

constexpr MTLTriangleFillMode impeller::ToMTLTriangleFillMode ( PolygonMode  mode )

constexpr

Definition at line 170 of file formats_mtl.h.

                                                                      {
  switch (mode) {
    case PolygonMode::kFill:
      return MTLTriangleFillModeFill;
    case PolygonMode::kLine:
      return MTLTriangleFillModeLines;
  }
  return MTLTriangleFillModeFill;
}

References kFill, and kLine.

ToOptRect()

static std::optional<const Rect> impeller::ToOptRect ( const flutter::DlRect *  rect )

static

Definition at line 139 of file dl_dispatcher.cc.

                                                                    {
  if (rect == nullptr) {
    return std::nullopt;
  }
  return *rect;
}

Referenced by impeller::DlDispatcherBase::drawAtlas().

ToParam() [1/2]

static GLint impeller::ToParam ( MinMagFilter  minmag_filter )

static

Definition at line 20 of file sampler_gles.cc.

                                                 {
  switch (minmag_filter) {
    case MinMagFilter::kNearest:
      return GL_NEAREST;
    case MinMagFilter::kLinear:
      return GL_LINEAR;
  }
  FML_UNREACHABLE();
}

ToParam() [2/2]

static GLint impeller::ToParam ( MinMagFilter  minmag_filter, MipFilter  mip_filter  )

static

Definition at line 30 of file sampler_gles.cc.

                                                                       {
  switch (mip_filter) {
    case MipFilter::kBase:
      return ToParam(minmag_filter);
    case MipFilter::kNearest:
      switch (minmag_filter) {
        case MinMagFilter::kNearest:
          return GL_NEAREST_MIPMAP_NEAREST;
        case MinMagFilter::kLinear:
          return GL_LINEAR_MIPMAP_NEAREST;
      }
    case MipFilter::kLinear:
      switch (minmag_filter) {
        case MinMagFilter::kNearest:
          return GL_NEAREST_MIPMAP_LINEAR;
        case MinMagFilter::kLinear:
          return GL_LINEAR_MIPMAP_LINEAR;
      }
  }
  FML_UNREACHABLE();
}

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

ToPixelFormat() [1/2]

constexpr PixelFormat impeller::ToPixelFormat ( android::HardwareBufferFormat  format )

constexpr

Definition at line 13 of file ahb_formats.h.

                                                                        {
  switch (format) {
    case android::HardwareBufferFormat::kR8G8B8A8UNormInt:
      return PixelFormat::kR8G8B8A8UNormInt;
  }
  FML_UNREACHABLE();
}

References kR8G8B8A8UNormInt, and impeller::android::kR8G8B8A8UNormInt.

ToPixelFormat() [2/2]

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

constexpr

Definition at line 183 of file formats_vk.h.

                                                     {
  switch (format) {
    case vk::Format::eUndefined:
      return PixelFormat::kUnknown;
    case vk::Format::eR8G8B8A8Unorm:
      return PixelFormat::kR8G8B8A8UNormInt;
    case vk::Format::eR8G8B8A8Srgb:
      return PixelFormat::kR8G8B8A8UNormIntSRGB;
    case vk::Format::eB8G8R8A8Unorm:
      return PixelFormat::kB8G8R8A8UNormInt;
    case vk::Format::eB8G8R8A8Srgb:
      return PixelFormat::kB8G8R8A8UNormIntSRGB;
    case vk::Format::eR32G32B32A32Sfloat:
      return PixelFormat::kR32G32B32A32Float;
    case vk::Format::eR16G16B16A16Sfloat:
      return PixelFormat::kR16G16B16A16Float;
    case vk::Format::eS8Uint:
      return PixelFormat::kS8UInt;
    case vk::Format::eD24UnormS8Uint:
      return PixelFormat::kD24UnormS8Uint;
    case vk::Format::eD32SfloatS8Uint:
      return PixelFormat::kD32FloatS8UInt;
    case vk::Format::eR8Unorm:
      return PixelFormat::kR8UNormInt;
    case vk::Format::eR8G8Unorm:
      return PixelFormat::kR8G8UNormInt;
    default:
      return PixelFormat::kUnknown;
  }
}

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

Referenced by impeller::AHBSwapchainVK::GetSurfaceFormat(), and ToSwapchainTextureDescriptor().

ToRect()

static Rect impeller::ToRect ( const SkRect &  rect )

static

Definition at line 41 of file text_frame_skia.cc.

                                       {
  return Rect::MakeLTRB(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
}

References impeller::TRect< Scalar >::MakeLTRB().

Referenced by MakeTextFrameFromTextBlobSkia().

ToRenderBufferFormat()

static std::optional<GLenum> impeller::ToRenderBufferFormat ( PixelFormat  format )

static

Definition at line 376 of file texture_gles.cc.

                                                                    {
  switch (format) {
    case PixelFormat::kB8G8R8A8UNormInt:
    case PixelFormat::kR8G8B8A8UNormInt:
      return GL_RGBA8;
    case PixelFormat::kR32G32B32A32Float:
      return GL_RGBA32F;
    case PixelFormat::kR16G16B16A16Float:
      return GL_RGBA16F;
    case PixelFormat::kS8UInt:
      return GL_STENCIL_INDEX8;
    case PixelFormat::kD24UnormS8Uint:
      return GL_DEPTH24_STENCIL8;
    case PixelFormat::kD32FloatS8UInt:
      return GL_DEPTH32F_STENCIL8;
    case PixelFormat::kUnknown:
    case PixelFormat::kA8UNormInt:
    case PixelFormat::kR8UNormInt:
    case PixelFormat::kR8G8UNormInt:
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
    case PixelFormat::kB10G10R10XRSRGB:
    case PixelFormat::kB10G10R10XR:
    case PixelFormat::kB10G10R10A10XR:
      return std::nullopt;
  }
  FML_UNREACHABLE();
}

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

ToRGB()

static constexpr Vector3 impeller::ToRGB ( Color  color )

inlinestaticconstexpr

Definition at line 111 of file color.cc.

                                                   {
  return {color.red, color.green, color.blue};
}

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

Referenced by DoColorBlend().

ToSamplerDescriptor()

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

static

Definition at line 121 of file dl_dispatcher.cc.

                                       {
  impeller::SamplerDescriptor desc;
  switch (options) {
    case flutter::DlFilterMode::kNearest:
      desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kNearest;
      desc.label = "Nearest Sampler";
      break;
    case flutter::DlFilterMode::kLinear:
      desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
      desc.label = "Linear Sampler";
      break;
    default:
      break;
  }
  return desc;
}

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

Referenced by impeller::DlDispatcherBase::drawImageNine().

ToShaderStage() [1/4]

static ShaderStage impeller::ToShaderStage ( ArchiveShaderType  type )

static

Definition at line 17 of file shader_library_gles.cc.

                                                         {
  switch (type) {
    case ArchiveShaderType::kVertex:
      return ShaderStage::kVertex;
    case ArchiveShaderType::kFragment:
      return ShaderStage::kFragment;
    case ArchiveShaderType::kCompute:
      return ShaderStage::kCompute;
  }
  FML_UNREACHABLE();
}

References kCompute, kFragment, kVertex, and type.

ToShaderStage() [2/4]

static ShaderStage impeller::ToShaderStage ( ArchiveShaderType  type )

static

Definition at line 17 of file shader_library_vk.cc.

                                                         {
  switch (type) {
    case ArchiveShaderType::kVertex:
      return ShaderStage::kVertex;
    case ArchiveShaderType::kFragment:
      return ShaderStage::kFragment;
    case ArchiveShaderType::kCompute:
      return ShaderStage::kCompute;
  }
  FML_UNREACHABLE();
}

References kCompute, kFragment, kVertex, and type.

ToShaderStage() [3/4]

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

static

Definition at line 31 of file runtime_stage.cc.

                                                       {
  switch (stage) {
    case fb::Stage::kVertex:
      return RuntimeShaderStage::kVertex;
    case fb::Stage::kFragment:
      return RuntimeShaderStage::kFragment;
    case fb::Stage::kCompute:
      return RuntimeShaderStage::kCompute;
  }
  FML_UNREACHABLE();
}

References kCompute, kFragment, and kVertex.

ToShaderStage() [4/4]

constexpr ShaderStage impeller::ToShaderStage ( RuntimeShaderStage  stage )

constexpr

Definition at line 29 of file shader_types.h.

                                                              {
  switch (stage) {
    case RuntimeShaderStage::kVertex:
      return ShaderStage::kVertex;
    case RuntimeShaderStage::kFragment:
      return ShaderStage::kFragment;
    case RuntimeShaderStage::kCompute:
      return ShaderStage::kCompute;
  }
  FML_UNREACHABLE();
}

References kCompute, kFragment, and kVertex.

Referenced by impeller::RuntimeStagePlayground::RegisterStage(), 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.

                                                        {
  switch (stage) {
    case fb::Stage::kVertex:
      return ArchiveShaderType::kVertex;
    case fb::Stage::kFragment:
      return ArchiveShaderType::kFragment;
    case fb::Stage::kCompute:
      return ArchiveShaderType::kCompute;
  }
  FML_UNREACHABLE();
}

References kCompute, kFragment, and kVertex.

Referenced by impeller::ShaderArchive::ShaderArchive().

ToStage()

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

constexpr

Definition at line 95 of file shader_archive_writer.cc.

                                                  {
  switch (type) {
    case ArchiveShaderType::kVertex:
      return fb::Stage::kVertex;
    case ArchiveShaderType::kFragment:
      return fb::Stage::kFragment;
    case ArchiveShaderType::kCompute:
      return fb::Stage::kCompute;
  }
  FML_UNREACHABLE();
}

References kCompute, kFragment, kVertex, and type.

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

ToStencilOp()

constexpr GLenum impeller::ToStencilOp ( StencilOperation  op )

constexpr

Definition at line 48 of file formats_gles.h.

                                                  {
  switch (op) {
    case StencilOperation::kKeep:
      return GL_KEEP;
    case StencilOperation::kZero:
      return GL_ZERO;
    case StencilOperation::kSetToReferenceValue:
      return GL_REPLACE;
    case StencilOperation::kIncrementClamp:
      return GL_INCR;
    case StencilOperation::kDecrementClamp:
      return GL_DECR;
    case StencilOperation::kInvert:
      return GL_INVERT;
    case StencilOperation::kIncrementWrap:
      return GL_INCR_WRAP;
    case StencilOperation::kDecrementWrap:
      return GL_DECR_WRAP;
  }
  FML_UNREACHABLE();
}

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

                                                    {
  switch (style) {
    case flutter::DlDrawStyle::kFill:
      return Paint::Style::kFill;
    case flutter::DlDrawStyle::kStroke:
      return Paint::Style::kStroke;
    case flutter::DlDrawStyle::kStrokeAndFill:
      UNIMPLEMENTED;
      break;
  }
  return Paint::Style::kFill;
}

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

Referenced by impeller::DlDispatcherBase::setDrawStyle(), and impeller::FirstPassDispatcher::setDrawStyle().

ToSwapchainTextureDescriptor()

static TextureDescriptor impeller::ToSwapchainTextureDescriptor ( const android::HardwareBufferDescriptor &  ahb_desc )

static

Definition at line 17 of file ahb_swapchain_impl_vk.cc.

                                                     {
  TextureDescriptor desc;
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.type = TextureType::kTexture2D;
  desc.format = ToPixelFormat(ahb_desc.format);
  desc.size = ahb_desc.size;
  desc.mip_count = 1u;
  desc.usage = TextureUsage::kRenderTarget;
  desc.sample_count = SampleCount::kCount1;
  desc.compression_type = CompressionType::kLossless;
  return desc;
}

References impeller::TextureDescriptor::compression_type, impeller::TextureDescriptor::format, impeller::android::HardwareBufferDescriptor::format, kCount1, kDevicePrivate, kLossless, kRenderTarget, kTexture2D, impeller::TextureDescriptor::mip_count, impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::android::HardwareBufferDescriptor::size, impeller::TextureDescriptor::storage_mode, ToPixelFormat(), impeller::TextureDescriptor::type, and impeller::TextureDescriptor::usage.

ToTarget()

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

static

Definition at line 78 of file device_buffer_gles.cc.

                                                         {
  switch (type) {
    case DeviceBufferGLES::BindingType::kArrayBuffer:
      return GL_ARRAY_BUFFER;
    case DeviceBufferGLES::BindingType::kElementArrayBuffer:
      return GL_ELEMENT_ARRAY_BUFFER;
    case DeviceBufferGLES::BindingType::kUniformBuffer:
      return GL_UNIFORM_BUFFER;
  }
  FML_UNREACHABLE();
}

References impeller::DeviceBufferGLES::kArrayBuffer, impeller::DeviceBufferGLES::kElementArrayBuffer, impeller::DeviceBufferGLES::kUniformBuffer, and type.

Referenced by impeller::DeviceBufferGLES::BindAndUploadDataIfNecessary().

ToTessWindingRule()

static int impeller::ToTessWindingRule ( FillType  fill_type )

static

Definition at line 47 of file tessellator_libtess.cc.

                                                 {
  switch (fill_type) {
    case FillType::kOdd:
      return TESS_WINDING_ODD;
    case FillType::kNonZero:
      return TESS_WINDING_NONZERO;
  }
  return TESS_WINDING_ODD;
}

References kNonZero, and kOdd.

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

ToTextureTarget()

constexpr std::optional<GLenum> impeller::ToTextureTarget ( TextureType  type )

constexpr

Definition at line 185 of file formats_gles.h.

                                                                {
  switch (type) {
    case TextureType::kTexture2D:
      return GL_TEXTURE_2D;
    case TextureType::kTexture2DMultisample:
      return GL_TEXTURE_2D;
    case TextureType::kTextureCube:
      return GL_TEXTURE_CUBE_MAP;
    case TextureType::kTextureExternalOES:
      return GL_TEXTURE_EXTERNAL_OES;
  }
  FML_UNREACHABLE();
}

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

Referenced by impeller::TextureGLES::Bind(), and impeller::SamplerGLES::ConfigureBoundTexture().

ToTextureType()

constexpr GLenum impeller::ToTextureType ( TextureType  type )

constexpr

Definition at line 171 of file formats_gles.h.

                                                 {
  switch (type) {
    case TextureType::kTexture2D:
      return GL_TEXTURE_2D;
    case TextureType::kTexture2DMultisample:
      return GL_TEXTURE_2D_MULTISAMPLE;
    case TextureType::kTextureCube:
      return GL_TEXTURE_CUBE_MAP;
    case TextureType::kTextureExternalOES:
      return GL_TEXTURE_EXTERNAL_OES;
  }
  FML_UNREACHABLE();
}

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

Referenced by impeller::TextureGLES::GenerateMipmap().

ToType()

static RuntimeUniformType impeller::ToType ( fb::UniformDataType  type )

static

Definition at line 19 of file runtime_stage.cc.

                                                         {
  switch (type) {
    case fb::UniformDataType::kFloat:
      return RuntimeUniformType::kFloat;
    case fb::UniformDataType::kSampledImage:
      return RuntimeUniformType::kSampledImage;
    case fb::UniformDataType::kStruct:
      return RuntimeUniformType::kStruct;
  }
  FML_UNREACHABLE();
}

References kFloat, kSampledImage, kStruct, and type.

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

ToVector()

constexpr Vector4 impeller::ToVector ( Color  color )

inlineconstexpr

Definition at line 190 of file shader_types.h.

                                               {
  return {color.red, color.green, color.blue, color.alpha};
}

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

                                                                  {
  switch (type) {
    case ShaderType::kSignedByte:
      return GL_BYTE;
    case ShaderType::kUnsignedByte:
      return GL_UNSIGNED_BYTE;
    case ShaderType::kSignedShort:
      return GL_SHORT;
    case ShaderType::kUnsignedShort:
      return GL_UNSIGNED_SHORT;
    case ShaderType::kFloat:
      return GL_FLOAT;
    case ShaderType::kUnknown:
    case ShaderType::kVoid:
    case ShaderType::kBoolean:
    case ShaderType::kSignedInt:
    case ShaderType::kUnsignedInt:
    case ShaderType::kSignedInt64:
    case ShaderType::kUnsignedInt64:
    case ShaderType::kAtomicCounter:
    case ShaderType::kHalfFloat:
    case ShaderType::kDouble:
    case ShaderType::kStruct:
    case ShaderType::kImage:
    case ShaderType::kSampledImage:
    case ShaderType::kSampler:
      return std::nullopt;
  }
  FML_UNREACHABLE();
}

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

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

ToVertexDescriptorFormat()

vk::Format impeller::ToVertexDescriptorFormat

(

const ShaderStageIOSlot &

input

)

Definition at line 11 of file vertex_descriptor_vk.cc.

                                                                  {
  if (input.columns != 1) {
    // All matrix types are unsupported as vertex inputs.
    return vk::Format::eUndefined;
  }
 
  switch (input.type) {
    case ShaderType::kFloat: {
      if (input.bit_width == 8 * sizeof(float)) {
        switch (input.vec_size) {
          case 1:
            return vk::Format::eR32Sfloat;
          case 2:
            return vk::Format::eR32G32Sfloat;
          case 3:
            return vk::Format::eR32G32B32Sfloat;
          case 4:
            return vk::Format::eR32G32B32A32Sfloat;
        }
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kHalfFloat: {
      if (input.bit_width == 8 * sizeof(float) / 2) {
        switch (input.vec_size) {
          case 1:
            return vk::Format::eR16Sfloat;
          case 2:
            return vk::Format::eR16G16Sfloat;
          case 3:
            return vk::Format::eR16G16B16Sfloat;
          case 4:
            return vk::Format::eR16G16B16A16Sfloat;
        }
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kDouble: {
      // Unsupported.
      return vk::Format::eUndefined;
    }
    case ShaderType::kBoolean: {
      if (input.bit_width == 8 * sizeof(bool) && input.vec_size == 1) {
        return vk::Format::eR8Uint;
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kSignedByte: {
      if (input.bit_width == 8 * sizeof(char)) {
        switch (input.vec_size) {
          case 1:
            return vk::Format::eR8Sint;
          case 2:
            return vk::Format::eR8G8Sint;
          case 3:
            return vk::Format::eR8G8B8Sint;
          case 4:
            return vk::Format::eR8G8B8A8Sint;
        }
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kUnsignedByte: {
      if (input.bit_width == 8 * sizeof(char)) {
        switch (input.vec_size) {
          case 1:
            return vk::Format::eR8Uint;
          case 2:
            return vk::Format::eR8G8Uint;
          case 3:
            return vk::Format::eR8G8B8Uint;
          case 4:
            return vk::Format::eR8G8B8A8Uint;
        }
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kSignedShort: {
      if (input.bit_width == 8 * sizeof(int16_t)) {
        switch (input.vec_size) {
          case 1:
            return vk::Format::eR16Sint;
          case 2:
            return vk::Format::eR16G16Sint;
          case 3:
            return vk::Format::eR16G16B16Sint;
          case 4:
            return vk::Format::eR16G16B16A16Sint;
        }
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kUnsignedShort: {
      if (input.bit_width == 8 * sizeof(uint16_t)) {
        switch (input.vec_size) {
          case 1:
            return vk::Format::eR16Uint;
          case 2:
            return vk::Format::eR16G16Uint;
          case 3:
            return vk::Format::eR16G16B16Uint;
          case 4:
            return vk::Format::eR16G16B16A16Uint;
        }
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kSignedInt: {
      if (input.bit_width == 8 * sizeof(int32_t)) {
        switch (input.vec_size) {
          case 1:
            return vk::Format::eR32Sint;
          case 2:
            return vk::Format::eR32G32Sint;
          case 3:
            return vk::Format::eR32G32B32Sint;
          case 4:
            return vk::Format::eR32G32B32A32Sint;
        }
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kUnsignedInt: {
      if (input.bit_width == 8 * sizeof(uint32_t)) {
        switch (input.vec_size) {
          case 1:
            return vk::Format::eR32Uint;
          case 2:
            return vk::Format::eR32G32Uint;
          case 3:
            return vk::Format::eR32G32B32Uint;
          case 4:
            return vk::Format::eR32G32B32A32Uint;
        }
      }
      return vk::Format::eUndefined;
    }
    case ShaderType::kSignedInt64: {
      // Unsupported.
      return vk::Format::eUndefined;
    }
    case ShaderType::kUnsignedInt64: {
      // Unsupported.
      return vk::Format::eUndefined;
    }
    case ShaderType::kAtomicCounter:
    case ShaderType::kStruct:
    case ShaderType::kImage:
    case ShaderType::kSampledImage:
    case ShaderType::kUnknown:
    case ShaderType::kVoid:
    case ShaderType::kSampler:
      return vk::Format::eUndefined;
  }
}

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.

ToVKAttachmentLoadOp()

constexpr vk::AttachmentLoadOp impeller::ToVKAttachmentLoadOp ( LoadAction  load_action )

constexpr

Definition at line 306 of file formats_vk.h.

                                                                          {
  switch (load_action) {
    case LoadAction::kLoad:
      return vk::AttachmentLoadOp::eLoad;
    case LoadAction::kClear:
      return vk::AttachmentLoadOp::eClear;
    case LoadAction::kDontCare:
      return vk::AttachmentLoadOp::eDontCare;
  }
 
  FML_UNREACHABLE();
}

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

                                                                               {
  switch (store_action) {
    case StoreAction::kStore:
      // Both MSAA and resolve textures need to be stored. A resolve is NOT
      // performed.
      return vk::AttachmentStoreOp::eStore;
    case StoreAction::kDontCare:
      // Both MSAA and resolve textures can be discarded. A resolve is NOT
      // performed.
      return vk::AttachmentStoreOp::eDontCare;
    case StoreAction::kMultisampleResolve:
      // The resolve texture is stored but the MSAA texture can be discarded. A
      // resolve IS performed.
      return is_resolve_texture ? vk::AttachmentStoreOp::eStore
                                : vk::AttachmentStoreOp::eDontCare;
    case StoreAction::kStoreAndMultisampleResolve:
      // Both MSAA and resolve textures need to be stored. A resolve IS
      // performed.
      return vk::AttachmentStoreOp::eStore;
  }
  FML_UNREACHABLE();
}

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

                                                            {
  switch (factor) {
    case BlendFactor::kZero:
      return vk::BlendFactor::eZero;
    case BlendFactor::kOne:
      return vk::BlendFactor::eOne;
    case BlendFactor::kSourceColor:
      return vk::BlendFactor::eSrcColor;
    case BlendFactor::kOneMinusSourceColor:
      return vk::BlendFactor::eOneMinusSrcColor;
    case BlendFactor::kSourceAlpha:
      return vk::BlendFactor::eSrcAlpha;
    case BlendFactor::kOneMinusSourceAlpha:
      return vk::BlendFactor::eOneMinusSrcAlpha;
    case BlendFactor::kDestinationColor:
      return vk::BlendFactor::eDstColor;
    case BlendFactor::kOneMinusDestinationColor:
      return vk::BlendFactor::eOneMinusDstColor;
    case BlendFactor::kDestinationAlpha:
      return vk::BlendFactor::eDstAlpha;
    case BlendFactor::kOneMinusDestinationAlpha:
      return vk::BlendFactor::eOneMinusDstAlpha;
    case BlendFactor::kSourceAlphaSaturated:
      return vk::BlendFactor::eSrcAlphaSaturate;
    case BlendFactor::kBlendColor:
      return vk::BlendFactor::eConstantColor;
    case BlendFactor::kOneMinusBlendColor:
      return vk::BlendFactor::eOneMinusConstantColor;
    case BlendFactor::kBlendAlpha:
      return vk::BlendFactor::eConstantAlpha;
    case BlendFactor::kOneMinusBlendAlpha:
      return vk::BlendFactor::eOneMinusConstantAlpha;
  }
  FML_UNREACHABLE();
}

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

                                                   {
  switch (op) {
    case BlendOperation::kAdd:
      return vk::BlendOp::eAdd;
    case BlendOperation::kSubtract:
      return vk::BlendOp::eSubtract;
    case BlendOperation::kReverseSubtract:
      return vk::BlendOp::eReverseSubtract;
  }
  FML_UNREACHABLE();
}

References kAdd, kReverseSubtract, and kSubtract.

Referenced by ToVKPipelineColorBlendAttachmentState().

ToVKBufferMemoryPropertyFlags()

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

staticconstexpr

Definition at line 24 of file allocator_vk.cc.

                                                {
  switch (mode) {
    case StorageMode::kHostVisible:
      return vk::MemoryPropertyFlagBits::eHostVisible;
    case StorageMode::kDevicePrivate:
      return vk::MemoryPropertyFlagBits::eDeviceLocal;
    case StorageMode::kDeviceTransient:
      return vk::MemoryPropertyFlagBits::eLazilyAllocated;
  }
  FML_UNREACHABLE();
}

References kDevicePrivate, kDeviceTransient, and kHostVisible.

Referenced by CreateBufferPool().

ToVKColorComponentFlags()

constexpr vk::ColorComponentFlags impeller::ToVKColorComponentFlags ( ColorWriteMask  type )

constexpr

Definition at line 90 of file formats_vk.h.

                                                                             {
  vk::ColorComponentFlags mask;
 
  if (type & ColorWriteMaskBits::kRed) {
    mask |= vk::ColorComponentFlagBits::eR;
  }
 
  if (type & ColorWriteMaskBits::kGreen) {
    mask |= vk::ColorComponentFlagBits::eG;
  }
 
  if (type & ColorWriteMaskBits::kBlue) {
    mask |= vk::ColorComponentFlagBits::eB;
  }
 
  if (type & ColorWriteMaskBits::kAlpha) {
    mask |= vk::ColorComponentFlagBits::eA;
  }
 
  return mask;
}

References kAlpha, kBlue, kGreen, kRed, and type.

Referenced by ToVKPipelineColorBlendAttachmentState().

ToVKCompareOp()

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

constexpr

Definition at line 453 of file formats_vk.h.

                                                        {
  switch (op) {
    case CompareFunction::kNever:
      return vk::CompareOp::eNever;
    case CompareFunction::kAlways:
      return vk::CompareOp::eAlways;
    case CompareFunction::kLess:
      return vk::CompareOp::eLess;
    case CompareFunction::kEqual:
      return vk::CompareOp::eEqual;
    case CompareFunction::kLessEqual:
      return vk::CompareOp::eLessOrEqual;
    case CompareFunction::kGreater:
      return vk::CompareOp::eGreater;
    case CompareFunction::kNotEqual:
      return vk::CompareOp::eNotEqual;
    case CompareFunction::kGreaterEqual:
      return vk::CompareOp::eGreaterOrEqual;
  }
  FML_UNREACHABLE();
}

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

                                                           {
  switch (mode) {
    case CullMode::kNone:
      return vk::CullModeFlagBits::eNone;
    case CullMode::kFrontFace:
      return vk::CullModeFlagBits::eFront;
    case CullMode::kBackFace:
      return vk::CullModeFlagBits::eBack;
  }
  FML_UNREACHABLE();
}

References kBackFace, kFrontFace, and kNone.

ToVKDescriptorSetLayoutBinding()

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

constexpr

Definition at line 296 of file formats_vk.h.

                                       {
  vk::DescriptorSetLayoutBinding binding;
  binding.binding = layout.binding;
  binding.descriptorCount = 1u;
  binding.descriptorType = ToVKDescriptorType(layout.descriptor_type);
  binding.stageFlags = ToVkShaderStage(layout.shader_stage);
  return binding;
}

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

                                                                   {
  return static_cast<vk::DescriptorType>(type);
}

References type.

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

ToVKFrontFace()

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

constexpr

Definition at line 31 of file pipeline_vk.cc.

                                                        {
  switch (order) {
    case WindingOrder::kClockwise:
      return vk::FrontFace::eClockwise;
    case WindingOrder::kCounterClockwise:
      return vk::FrontFace::eCounterClockwise;
  }
  FML_UNREACHABLE();
}

References kClockwise, and kCounterClockwise.

ToVKImageAspectFlags()

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

constexpr

Definition at line 513 of file formats_vk.h.

                                                                      {
  switch (format) {
    case PixelFormat::kUnknown:
    case PixelFormat::kA8UNormInt:
    case PixelFormat::kR8UNormInt:
    case PixelFormat::kR8G8UNormInt:
    case PixelFormat::kR8G8B8A8UNormInt:
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
    case PixelFormat::kB8G8R8A8UNormInt:
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
    case PixelFormat::kR32G32B32A32Float:
    case PixelFormat::kR16G16B16A16Float:
    case PixelFormat::kB10G10R10XR:
    case PixelFormat::kB10G10R10XRSRGB:
    case PixelFormat::kB10G10R10A10XR:
      return vk::ImageAspectFlagBits::eColor;
    case PixelFormat::kS8UInt:
      return vk::ImageAspectFlagBits::eStencil;
    case PixelFormat::kD24UnormS8Uint:
    case PixelFormat::kD32FloatS8UInt:
      return vk::ImageAspectFlagBits::eDepth |
             vk::ImageAspectFlagBits::eStencil;
  }
  FML_UNREACHABLE();
}

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

                                                                    {
  switch (type) {
    case TextureType::kTexture2D:
    case TextureType::kTexture2DMultisample:
      return {};
    case TextureType::kTextureCube:
      return vk::ImageCreateFlagBits::eCubeCompatible;
    case TextureType::kTextureExternalOES:
      VALIDATION_LOG
          << "kTextureExternalOES can not be used with the Vulkan backend.";
  }
  FML_UNREACHABLE();
}

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

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

ToVKImageFormat()

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

constexpr

Definition at line 146 of file formats_vk.h.

                                                       {
  switch (format) {
    case PixelFormat::kUnknown:
    case PixelFormat::kB10G10R10XR:
    case PixelFormat::kB10G10R10A10XR:
    case PixelFormat::kB10G10R10XRSRGB:
      return vk::Format::eUndefined;
    case PixelFormat::kA8UNormInt:
      // TODO(csg): This is incorrect. Don't depend on swizzle support for GLES.
      return vk::Format::eR8Unorm;
    case PixelFormat::kR8G8B8A8UNormInt:
      return vk::Format::eR8G8B8A8Unorm;
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
      return vk::Format::eR8G8B8A8Srgb;
    case PixelFormat::kB8G8R8A8UNormInt:
      return vk::Format::eB8G8R8A8Unorm;
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
      return vk::Format::eB8G8R8A8Srgb;
    case PixelFormat::kR32G32B32A32Float:
      return vk::Format::eR32G32B32A32Sfloat;
    case PixelFormat::kR16G16B16A16Float:
      return vk::Format::eR16G16B16A16Sfloat;
    case PixelFormat::kS8UInt:
      return vk::Format::eS8Uint;
    case PixelFormat::kD24UnormS8Uint:
      return vk::Format::eD24UnormS8Uint;
    case PixelFormat::kD32FloatS8UInt:
      return vk::Format::eD32SfloatS8Uint;
    case PixelFormat::kR8UNormInt:
      return vk::Format::eR8Unorm;
    case PixelFormat::kR8G8UNormInt:
      return vk::Format::eR8G8Unorm;
  }
 
  FML_UNREACHABLE();
}

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::AHBSwapchainVK::GetSurfaceFormat(), 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 553 of file formats_vk.h.

                                                              {
  switch (type) {
    case TextureType::kTexture2D:
    case TextureType::kTexture2DMultisample:
      return vk::ImageViewType::e2D;
    case TextureType::kTextureCube:
      return vk::ImageViewType::eCube;
    case TextureType::kTextureExternalOES:
      VALIDATION_LOG
          << "kTextureExternalOES can not be used with the Vulkan backend.";
  }
  FML_UNREACHABLE();
}

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

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

ToVKIndexType()

constexpr vk::IndexType impeller::ToVKIndexType ( IndexType  index_type )

constexpr

Definition at line 355 of file formats_vk.h.

                                                          {
  switch (index_type) {
    case IndexType::k16bit:
      return vk::IndexType::eUint16;
    case IndexType::k32bit:
      return vk::IndexType::eUint32;
    case IndexType::kUnknown:
      return vk::IndexType::eUint32;
    case IndexType::kNone:
      FML_UNREACHABLE();
  }
 
  FML_UNREACHABLE();
}

References k16bit, k32bit, kNone, and kUnknown.

ToVKPipelineColorBlendAttachmentState()

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

constexpr

Definition at line 113 of file formats_vk.h.

                                                                             {
  vk::PipelineColorBlendAttachmentState res;
 
  res.setBlendEnable(desc.blending_enabled);
 
  res.setSrcColorBlendFactor(ToVKBlendFactor(desc.src_color_blend_factor));
  res.setColorBlendOp(ToVKBlendOp(desc.color_blend_op));
  res.setDstColorBlendFactor(ToVKBlendFactor(desc.dst_color_blend_factor));
 
  res.setSrcAlphaBlendFactor(ToVKBlendFactor(desc.src_alpha_blend_factor));
  res.setAlphaBlendOp(ToVKBlendOp(desc.alpha_blend_op));
  res.setDstAlphaBlendFactor(ToVKBlendFactor(desc.dst_alpha_blend_factor));
 
  res.setColorWriteMask(ToVKColorComponentFlags(desc.write_mask));
 
  return res;
}

References impeller::ColorAttachmentDescriptor::alpha_blend_op, impeller::ColorAttachmentDescriptor::blending_enabled, impeller::ColorAttachmentDescriptor::color_blend_op, impeller::ColorAttachmentDescriptor::dst_alpha_blend_factor, impeller::ColorAttachmentDescriptor::dst_color_blend_factor, impeller::ColorAttachmentDescriptor::src_alpha_blend_factor, impeller::ColorAttachmentDescriptor::src_color_blend_factor, ToVKBlendFactor(), ToVKBlendOp(), ToVKColorComponentFlags(), and impeller::ColorAttachmentDescriptor::write_mask.

ToVKPipelineDepthStencilStateCreateInfo()

vk::PipelineDepthStencilStateCreateInfo impeller::ToVKPipelineDepthStencilStateCreateInfo	(	std::optional< DepthAttachmentDescriptor >	depth,
		std::optional< StencilAttachmentDescriptor >	front,
		std::optional< StencilAttachmentDescriptor >	back
	)

Definition at line 9 of file formats_vk.cc.

                                                   {
  vk::PipelineDepthStencilStateCreateInfo info;
 
  if (depth.has_value()) {
    info.depthTestEnable = true;
    info.depthWriteEnable = depth->depth_write_enabled;
    info.depthCompareOp = ToVKCompareOp(depth->depth_compare);
    info.minDepthBounds = 0.0f;
    info.maxDepthBounds = 1.0f;
  }
 
  if (front.has_value()) {
    info.stencilTestEnable = true;
    info.front = ToVKStencilOpState(*front);
  }
 
  if (back.has_value()) {
    info.stencilTestEnable = true;
    info.back = ToVKStencilOpState(*back);
  }
 
  return info;
}

References ToVKCompareOp(), and ToVKStencilOpState().

ToVKPolygonMode()

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

constexpr

Definition at line 370 of file formats_vk.h.

                                                          {
  switch (mode) {
    case PolygonMode::kFill:
      return vk::PolygonMode::eFill;
    case PolygonMode::kLine:
      return vk::PolygonMode::eLine;
  }
  FML_UNREACHABLE();
}

References kFill, and kLine.

ToVKPrimitiveTopology()

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

constexpr

Definition at line 395 of file formats_vk.h.

                                                                             {
  switch (primitive) {
    case PrimitiveType::kTriangle:
      return vk::PrimitiveTopology::eTriangleList;
    case PrimitiveType::kTriangleStrip:
      return vk::PrimitiveTopology::eTriangleStrip;
    case PrimitiveType::kLine:
      return vk::PrimitiveTopology::eLineList;
    case PrimitiveType::kLineStrip:
      return vk::PrimitiveTopology::eLineStrip;
    case PrimitiveType::kPoint:
      return vk::PrimitiveTopology::ePointList;
    case PrimitiveType::kTriangleFan:
      return vk::PrimitiveTopology::eTriangleFan;
  }
 
  FML_UNREACHABLE();
}

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

ToVKSampleCount()

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

constexpr

Definition at line 214 of file formats_vk.h.

                                                                          {
  switch (sample_count) {
    case SampleCount::kCount1:
      return vk::SampleCountFlagBits::e1;
    case SampleCount::kCount4:
      return vk::SampleCountFlagBits::e4;
  }
 
  FML_UNREACHABLE();
}

References e1, 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 32 of file formats_vk.h.

                                                                           {
  switch (count) {
    case SampleCount::kCount1:
      return vk::SampleCountFlagBits::e1;
    case SampleCount::kCount4:
      return vk::SampleCountFlagBits::e4;
  }
  FML_UNREACHABLE();
}

References e1, kCount1, and kCount4.

ToVKSamplerAddressMode()

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

constexpr

Definition at line 248 of file formats_vk.h.

                             {
  switch (mode) {
    case SamplerAddressMode::kRepeat:
      return vk::SamplerAddressMode::eRepeat;
    case SamplerAddressMode::kMirror:
      return vk::SamplerAddressMode::eMirroredRepeat;
    case SamplerAddressMode::kClampToEdge:
      return vk::SamplerAddressMode::eClampToEdge;
    case SamplerAddressMode::kDecal:
      return vk::SamplerAddressMode::eClampToBorder;
  }
 
  FML_UNREACHABLE();
}

References kClampToEdge, kDecal, kMirror, and kRepeat.

Referenced by CreateSampler().

ToVKSamplerMinMagFilter()

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

constexpr

Definition at line 225 of file formats_vk.h.

                                                                {
  switch (filter) {
    case MinMagFilter::kNearest:
      return vk::Filter::eNearest;
    case MinMagFilter::kLinear:
      return vk::Filter::eLinear;
  }
 
  FML_UNREACHABLE();
}

References kLinear, and kNearest.

Referenced by CreateSampler().

ToVKSamplerMipmapMode()

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

constexpr

Definition at line 236 of file formats_vk.h.

                                                                      {
  switch (filter) {
    case MipFilter::kBase:
    case MipFilter::kNearest:
      return vk::SamplerMipmapMode::eNearest;
    case MipFilter::kLinear:
      return vk::SamplerMipmapMode::eLinear;
  }
 
  FML_UNREACHABLE();
}

References kBase, kLinear, and kNearest.

ToVkShaderStage()

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

constexpr

Definition at line 264 of file formats_vk.h.

                                                                {
  switch (stage) {
    case ShaderStage::kUnknown:
      return vk::ShaderStageFlagBits::eAll;
    case ShaderStage::kFragment:
      return vk::ShaderStageFlagBits::eFragment;
    case ShaderStage::kCompute:
      return vk::ShaderStageFlagBits::eCompute;
    case ShaderStage::kVertex:
      return vk::ShaderStageFlagBits::eVertex;
  }
 
  FML_UNREACHABLE();
}

References kCompute, kFragment, kUnknown, and kVertex.

Referenced by ToVKDescriptorSetLayoutBinding().

ToVKShaderStageFlagBits()

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

constexpr

Definition at line 131 of file formats_vk.h.

                       {
  switch (stage) {
    case ShaderStage::kUnknown:
      return std::nullopt;
    case ShaderStage::kVertex:
      return vk::ShaderStageFlagBits::eVertex;
    case ShaderStage::kFragment:
      return vk::ShaderStageFlagBits::eFragment;
    case ShaderStage::kCompute:
      return vk::ShaderStageFlagBits::eCompute;
  }
  FML_UNREACHABLE();
}

References kCompute, kFragment, kUnknown, and kVertex.

ToVKStencilOp()

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

constexpr

Definition at line 475 of file formats_vk.h.

                                                         {
  switch (op) {
    case StencilOperation::kKeep:
      return vk::StencilOp::eKeep;
    case StencilOperation::kZero:
      return vk::StencilOp::eZero;
    case StencilOperation::kSetToReferenceValue:
      return vk::StencilOp::eReplace;
    case StencilOperation::kIncrementClamp:
      return vk::StencilOp::eIncrementAndClamp;
    case StencilOperation::kDecrementClamp:
      return vk::StencilOp::eDecrementAndClamp;
    case StencilOperation::kInvert:
      return vk::StencilOp::eInvert;
    case StencilOperation::kIncrementWrap:
      return vk::StencilOp::eIncrementAndWrap;
    case StencilOperation::kDecrementWrap:
      return vk::StencilOp::eDecrementAndWrap;
      break;
  }
  FML_UNREACHABLE();
}

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

                                             {
  vk::StencilOpState state;
  state.failOp = ToVKStencilOp(desc.stencil_failure);
  state.passOp = ToVKStencilOp(desc.depth_stencil_pass);
  state.depthFailOp = ToVKStencilOp(desc.depth_failure);
  state.compareOp = ToVKCompareOp(desc.stencil_compare);
  state.compareMask = desc.read_mask;
  state.writeMask = desc.write_mask;
  // This is irrelevant as the stencil references are always dynamic state and
  // will be set in the render pass.
  state.reference = 1988;
  return state;
}

References impeller::StencilAttachmentDescriptor::depth_failure, impeller::StencilAttachmentDescriptor::depth_stencil_pass, impeller::StencilAttachmentDescriptor::read_mask, impeller::StencilAttachmentDescriptor::stencil_compare, impeller::StencilAttachmentDescriptor::stencil_failure, ToVKCompareOp(), ToVKStencilOp(), and impeller::StencilAttachmentDescriptor::write_mask.

Referenced by ToVKPipelineDepthStencilStateCreateInfo().

ToVKTextureMemoryPropertyFlags()

static constexpr vk::Flags<vk::MemoryPropertyFlagBits> impeller::ToVKTextureMemoryPropertyFlags ( StorageMode  mode, bool  supports_memoryless_textures  )

staticconstexpr

Definition at line 256 of file allocator_vk.cc.

                                                                  {
  switch (mode) {
    case StorageMode::kHostVisible:
      return vk::MemoryPropertyFlagBits::eHostVisible |
             vk::MemoryPropertyFlagBits::eDeviceLocal;
    case StorageMode::kDevicePrivate:
      return vk::MemoryPropertyFlagBits::eDeviceLocal;
    case StorageMode::kDeviceTransient:
      if (supports_memoryless_textures) {
        return vk::MemoryPropertyFlagBits::eLazilyAllocated |
               vk::MemoryPropertyFlagBits::eDeviceLocal;
      }
      return vk::MemoryPropertyFlagBits::eDeviceLocal;
  }
  FML_UNREACHABLE();
}

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

ToVmaAllocationBufferCreateFlags()

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

static

Definition at line 36 of file allocator_vk.cc.

                   {
  VmaAllocationCreateFlags flags = 0;
  switch (mode) {
    case StorageMode::kHostVisible:
      if (!readback) {
        flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
      } else {
        flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;
      }
      flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
      return flags;
    case StorageMode::kDevicePrivate:
      FML_DCHECK(!readback);
      return flags;
    case StorageMode::kDeviceTransient:
      FML_DCHECK(!readback);
      return flags;
  }
  FML_UNREACHABLE();
}

References kDevicePrivate, kDeviceTransient, and kHostVisible.

Referenced by CreateBufferPool().

ToVmaAllocationCreateFlags()

static VmaAllocationCreateFlags impeller::ToVmaAllocationCreateFlags ( StorageMode  mode )

static

Definition at line 274 of file allocator_vk.cc.

                                                                             {
  VmaAllocationCreateFlags flags = 0;
  switch (mode) {
    case StorageMode::kHostVisible:
      return flags;
    case StorageMode::kDevicePrivate:
      return flags;
    case StorageMode::kDeviceTransient:
      return flags;
  }
  FML_UNREACHABLE();
}

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

ToVMAMemoryUsage()

static constexpr VmaMemoryUsage impeller::ToVMAMemoryUsage ( )

staticconstexpr

Definition at line 251 of file allocator_vk.cc.

                                                   {
  return VMA_MEMORY_USAGE_AUTO;
}

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

UpdateAtlasBitmap()

static bool impeller::UpdateAtlasBitmap ( const GlyphAtlas &  atlas, std::shared_ptr< BlitPass > &  blit_pass, HostBuffer &  host_buffer, const std::shared_ptr< Texture > &  texture, const std::vector< FontGlyphPair > &  new_pairs, size_t  start_index, size_t  end_index  )

static

Definition at line 324 of file typographer_context_skia.cc.

                                                {
  TRACE_EVENT0("impeller", __FUNCTION__);
 
  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
 
  for (size_t i = start_index; i < end_index; i++) {
    const FontGlyphPair& pair = new_pairs[i];
    auto data = atlas.FindFontGlyphBounds(pair);
    if (!data.has_value()) {
      continue;
    }
    auto [pos, bounds, placeholder] = data.value();
    FML_DCHECK(!placeholder);
 
    Size size = pos.GetSize();
    if (size.IsEmpty()) {
      continue;
    }
    // The uploaded bitmap is expanded by 1px of padding
    // on each side.
    size.width += 2;
    size.height += 2;
 
    SkBitmap bitmap;
    bitmap.setInfo(GetImageInfo(atlas, size));
    if (!bitmap.tryAllocPixels()) {
      return false;
    }
 
    auto surface = SkSurfaces::WrapPixels(bitmap.pixmap());
    if (!surface) {
      return false;
    }
    auto canvas = surface->getCanvas();
    if (!canvas) {
      return false;
    }
 
    DrawGlyph(canvas, SkPoint::Make(1, 1), pair.scaled_font, pair.glyph, bounds,
              pair.glyph.properties, has_color);
 
    // Writing to a malloc'd buffer and then copying to the staging buffers
    // benchmarks as substantially faster on a number of Android devices.
    BufferView buffer_view = host_buffer.Emplace(
        bitmap.getAddr(0, 0),
        size.Area() * BytesPerPixelForPixelFormat(
                          atlas.GetTexture()->GetTextureDescriptor().format),
        host_buffer.GetMinimumUniformAlignment());
 
    // convert_to_read is set to false so that the texture remains in a transfer
    // dst layout until we finish writing to it below. This only has an impact
    // on Vulkan where we are responsible for managing image layouts.
    if (!blit_pass->AddCopy(std::move(buffer_view),  //
                            texture,                 //
                            IRect::MakeXYWH(pos.GetLeft() - 1, pos.GetTop() - 1,
                                            size.width, size.height),  //
                            /*label=*/"",                              //
                            /*mip_level=*/0,                           //
                            /*slice=*/0,                               //
                            /*convert_to_read=*/false                  //
                            )) {
      return false;
    }
  }
  return blit_pass->ConvertTextureToShaderRead(texture);
}

References impeller::TSize< T >::Area(), buffer_view, BytesPerPixelForPixelFormat(), data, DrawGlyph(), impeller::HostBuffer::Emplace(), impeller::GlyphAtlas::FindFontGlyphBounds(), GetImageInfo(), impeller::HostBuffer::GetMinimumUniformAlignment(), impeller::GlyphAtlas::GetTexture(), impeller::GlyphAtlas::GetType(), impeller::FontGlyphPair::glyph, impeller::TSize< T >::height, impeller::TSize< T >::IsEmpty(), impeller::GlyphAtlas::kColorBitmap, impeller::TRect< T >::MakeXYWH(), impeller::SubpixelGlyph::properties, impeller::FontGlyphPair::scaled_font, and impeller::TSize< T >::width.

Referenced by impeller::TypographerContextSkia::CreateGlyphAtlas().

ValidateBlendModes()

static constexpr bool impeller::ValidateBlendModes ( )

inlinestaticconstexpr

Definition at line 28 of file color.cc.

                                                  {
  std::underlying_type_t<BlendMode> i = 0;
  // Ensure the order of the blend modes match.
  IMPELLER_FOR_EACH_BLEND_MODE(_IMPELLER_ASSERT_BLEND_MODE)
  // Ensure the total number of blend modes match.
  if (i - 1 !=
      static_cast<std::underlying_type_t<BlendMode>>(BlendMode::kLastMode)) {
    return false;
  }
  return true;
}

References _IMPELLER_ASSERT_BLEND_MODE, IMPELLER_FOR_EACH_BLEND_MODE, and kLastMode.

VendorToString()

constexpr const char* impeller::VendorToString ( VendorVK  vendor )

constexpr

Definition at line 193 of file driver_info_vk.cc.

                                                      {
  switch (vendor) {
    case VendorVK::kUnknown:
      return "Unknown";
    case VendorVK::kGoogle:
      return "Google";
    case VendorVK::kQualcomm:
      return "Qualcomm";
    case VendorVK::kARM:
      return "ARM";
    case VendorVK::kImgTec:
      return "ImgTec PowerVR";
    case VendorVK::kAMD:
      return "AMD";
    case VendorVK::kNvidia:
      return "Nvidia";
    case VendorVK::kIntel:
      return "Intel";
    case VendorVK::kMesa:
      return "Mesa";
    case VendorVK::kApple:
      return "Apple";
    case VendorVK::kHuawei:
      return "Huawei";
    case VendorVK::kSamsung:
      return "Samsung";
  }
  FML_UNREACHABLE();
}

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

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

VKClearValueFromColor()

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

static

Definition at line 37 of file render_pass_vk.cc.

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

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

Referenced by GetVKClearValues().

VKClearValueFromDepthStencil()

static vk::ClearDepthStencilValue impeller::VKClearValueFromDepthStencil ( uint32_t  stencil, Scalar  depth  )

static

Definition at line 44 of file render_pass_vk.cc.

                                                                             {
  vk::ClearDepthStencilValue value;
  value.depth = depth;
  value.stencil = stencil;
  return value;
}

References value.

Referenced by GetVKClearValues().

VkFormatToImpellerFormat()

constexpr std::optional<PixelFormat> impeller::VkFormatToImpellerFormat ( vk::Format  format )

constexpr

Definition at line 20 of file formats_vk.h.

                     {
  switch (format) {
    case vk::Format::eR8G8B8A8Unorm:
      return PixelFormat::kR8G8B8A8UNormInt;
    case vk::Format::eB8G8R8A8Unorm:
      return PixelFormat::kB8G8R8A8UNormInt;
    default:
      return std::nullopt;
  }
}

References kB8G8R8A8UNormInt, and kR8G8B8A8UNormInt.

VKShaderNameToShaderKeyName()

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

static

Definition at line 29 of file shader_library_vk.cc.

                                                                  {
  std::stringstream stream;
  stream << name;
  switch (stage) {
    case ShaderStage::kUnknown:
      stream << "_unknown_";
      break;
    case ShaderStage::kVertex:
      stream << "_vertex_";
      break;
    case ShaderStage::kFragment:
      stream << "_fragment_";
      break;
    case ShaderStage::kCompute:
      stream << "_compute_";
      break;
  }
  stream << "main";
  return stream.str();
}

References kCompute, kFragment, kUnknown, and kVertex.

WrapInput()

std::shared_ptr< FilterContents > impeller::WrapInput	(	const flutter::DlImageFilter *	filter,
		const FilterInput::Ref &	input
	)

Generate a new FilterContents using this filter's configuration.

Definition at line 18 of file image_filter.cc.

                                                                       {
  FML_DCHECK(filter);
 
  switch (filter->type()) {
    case flutter::DlImageFilterType::kBlur: {
      auto blur_filter = filter->asBlur();
      FML_DCHECK(blur_filter);
 
      return FilterContents::MakeGaussianBlur(
          input,                                                    //
          Sigma(blur_filter->sigma_x()),                            //
          Sigma(blur_filter->sigma_y()),                            //
          static_cast<Entity::TileMode>(blur_filter->tile_mode()),  //
          FilterContents::BlurStyle::kNormal                        //
      );
    }
    case flutter::DlImageFilterType::kDilate: {
      auto dilate_filter = filter->asDilate();
      FML_DCHECK(dilate_filter);
 
      return FilterContents::MakeMorphology(
          input,                              //
          Radius(dilate_filter->radius_x()),  //
          Radius(dilate_filter->radius_y()),  //
          FilterContents::MorphType::kDilate  //
      );
    }
    case flutter::DlImageFilterType::kErode: {
      auto erode_filter = filter->asErode();
      FML_DCHECK(erode_filter);
 
      return FilterContents::MakeMorphology(
          input,                             //
          Radius(erode_filter->radius_x()),  //
          Radius(erode_filter->radius_y()),  //
          FilterContents::MorphType::kErode  //
      );
    }
    case flutter::DlImageFilterType::kMatrix: {
      auto matrix_filter = filter->asMatrix();
      FML_DCHECK(matrix_filter);
 
      auto matrix = matrix_filter->matrix();
      auto desc =
          skia_conversions::ToSamplerDescriptor(matrix_filter->sampling());
      return FilterContents::MakeMatrixFilter(input, matrix, desc);
    }
    case flutter::DlImageFilterType::kLocalMatrix: {
      auto matrix_filter = filter->asLocalMatrix();
      FML_DCHECK(matrix_filter);
      FML_DCHECK(matrix_filter->image_filter());
 
      auto matrix = matrix_filter->matrix();
      return FilterContents::MakeLocalMatrixFilter(
          FilterInput::Make(
              WrapInput(matrix_filter->image_filter().get(), input)),
          matrix);
    }
    case flutter::DlImageFilterType::kColorFilter: {
      auto image_color_filter = filter->asColorFilter();
      FML_DCHECK(image_color_filter);
      auto color_filter = image_color_filter->color_filter();
      FML_DCHECK(color_filter);
 
      // When color filters are used as image filters, set the color filter's
      // "absorb opacity" flag to false. For image filters, the snapshot
      // opacity needs to be deferred until the result of the filter chain is
      // being blended with the layer.
      return WrapWithGPUColorFilter(color_filter.get(), input,
                                    ColorFilterContents::AbsorbOpacity::kNo);
    }
    case flutter::DlImageFilterType::kCompose: {
      auto compose = filter->asCompose();
      FML_DCHECK(compose);
 
      auto outer_dl_filter = compose->outer();
      auto inner_dl_filter = compose->inner();
      if (!outer_dl_filter) {
        return WrapInput(inner_dl_filter.get(), input);
      }
      if (!inner_dl_filter) {
        return WrapInput(outer_dl_filter.get(), input);
      }
      FML_DCHECK(outer_dl_filter && inner_dl_filter);
 
      return WrapInput(
          outer_dl_filter.get(),
          FilterInput::Make(WrapInput(inner_dl_filter.get(), input)));
    }
    case flutter::DlImageFilterType::kRuntimeEffect: {
      const flutter::DlRuntimeEffectImageFilter* runtime_filter =
          filter->asRuntimeEffectFilter();
      FML_DCHECK(runtime_filter);
      std::shared_ptr<impeller::RuntimeStage> runtime_stage =
          runtime_filter->runtime_effect()->runtime_stage();
 
      std::vector<RuntimeEffectContents::TextureInput> texture_inputs;
      size_t index = 0;
      for (const std::shared_ptr<flutter::DlColorSource>& sampler :
           runtime_filter->samplers()) {
        if (index == 0 && sampler == nullptr) {
          // Insert placeholder for filter.
          texture_inputs.push_back(
              {.sampler_descriptor = skia_conversions::ToSamplerDescriptor({}),
               .texture = nullptr});
          continue;
        }
        if (sampler == nullptr) {
          return nullptr;
        }
        auto* image = sampler->asImage();
        if (!image) {
          return nullptr;
        }
        FML_DCHECK(image->image()->impeller_texture());
        index++;
        texture_inputs.push_back({
            .sampler_descriptor =
                skia_conversions::ToSamplerDescriptor(image->sampling()),
            .texture = image->image()->impeller_texture(),
        });
      }
      return FilterContents::MakeRuntimeEffect(input, std::move(runtime_stage),
                                               runtime_filter->uniform_data(),
                                               std::move(texture_inputs));
    }
  }
  FML_UNREACHABLE();
}

References impeller::FilterContents::kDilate, impeller::FilterContents::kErode, impeller::ColorFilterContents::kNo, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), impeller::FilterContents::MakeGaussianBlur(), impeller::FilterContents::MakeLocalMatrixFilter(), impeller::FilterContents::MakeMatrixFilter(), impeller::FilterContents::MakeMorphology(), impeller::FilterContents::MakeRuntimeEffect(), impeller::skia_conversions::ToSamplerDescriptor(), and WrapWithGPUColorFilter().

Referenced by impeller::Canvas::SaveLayer(), and impeller::Paint::WithImageFilter().

WrappedResolver()

ProcTableGLES::Resolver impeller::WrappedResolver

(

const ProcTableGLES::Resolver &

resolver

)

Definition at line 52 of file proc_table_gles.cc.

                                           {
  return [resolver](const char* function_name) -> void* {
    auto resolved = resolver(function_name);
    if (resolved) {
      return resolved;
    }
    // If there are certain known suffixes (usually for extensions), strip them
    // out and try to resolve the same proc addresses again.
    auto function = std::string{function_name};
    if (function.find("KHR", function.size() - 3) != std::string::npos) {
      auto truncated = function.substr(0u, function.size() - 3);
      return resolver(truncated.c_str());
    }
    if (function.find("EXT", function.size() - 3) != std::string::npos) {
      auto truncated = function.substr(0u, function.size() - 3);
      return resolver(truncated.c_str());
    }
    return nullptr;
  };
}

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

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

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.

                                                                           {
  auto texture = (__bridge id<MTLTexture>)mtl_texture;
  desc.format = FromMTLPixelFormat(texture.pixelFormat);
  return TextureMTL::Wrapper(desc, texture, std::move(deletion_proc));
}

References impeller::TextureDescriptor::format, FromMTLPixelFormat(), and impeller::TextureMTL::Wrapper().

WrapTextureWithRenderTarget()

static std::optional<RenderTarget> impeller::WrapTextureWithRenderTarget ( const std::shared_ptr< SwapchainTransientsMTL > &  transients, id< MTLTexture >  texture, bool  requires_blit, std::optional< IRect >  clip_rect  )

static

Definition at line 51 of file surface_mtl.mm.

                                  {
  ISize root_size = {static_cast<ISize::Type>(texture.width),
                     static_cast<ISize::Type>(texture.height)};
  PixelFormat format = FromMTLPixelFormat(texture.pixelFormat);
  if (format == PixelFormat::kUnknown) {
    VALIDATION_LOG << "Unknown drawable color format.";
    return std::nullopt;
  }
 
  transients->SetSizeAndFormat(root_size, format);
 
  TextureDescriptor resolve_tex_desc;
  resolve_tex_desc.format = FromMTLPixelFormat(texture.pixelFormat);
  resolve_tex_desc.size = root_size;
  resolve_tex_desc.usage =
      TextureUsage::kRenderTarget | TextureUsage::kShaderRead;
  resolve_tex_desc.sample_count = SampleCount::kCount1;
  resolve_tex_desc.storage_mode = StorageMode::kDevicePrivate;
 
  // Create color resolve texture.
  std::shared_ptr<Texture> resolve_tex;
  if (requires_blit) {
    resolve_tex = transients->GetResolveTexture();
  } else {
    resolve_tex = TextureMTL::Create(resolve_tex_desc, texture);
  }
 
  ColorAttachment color0;
  color0.texture = transients->GetMSAATexture();
  color0.clear_color = Color::DarkSlateGray();
  color0.load_action = LoadAction::kClear;
  color0.store_action = StoreAction::kMultisampleResolve;
  color0.resolve_texture = std::move(resolve_tex);
 
  DepthAttachment depth0;
  depth0.load_action =
      RenderTarget::kDefaultStencilAttachmentConfig.load_action;
  depth0.store_action =
      RenderTarget::kDefaultStencilAttachmentConfig.store_action;
  depth0.clear_depth = 0u;
  depth0.texture = transients->GetDepthStencilTexture();
 
  StencilAttachment stencil0;
  stencil0.load_action =
      RenderTarget::kDefaultStencilAttachmentConfig.load_action;
  stencil0.store_action =
      RenderTarget::kDefaultStencilAttachmentConfig.store_action;
  stencil0.clear_stencil = 0u;
  stencil0.texture = transients->GetDepthStencilTexture();
 
  RenderTarget render_target;
  render_target.SetColorAttachment(color0, 0u);
  render_target.SetDepthAttachment(std::move(depth0));
  render_target.SetStencilAttachment(std::move(stencil0));
 
  return render_target;
}

References impeller::ColorAttachment::clear_color, impeller::DepthAttachment::clear_depth, impeller::StencilAttachment::clear_stencil, impeller::TextureMTL::Create(), impeller::Color::DarkSlateGray(), impeller::TextureDescriptor::format, FromMTLPixelFormat(), kClear, kCount1, impeller::RenderTarget::kDefaultStencilAttachmentConfig, kDevicePrivate, kMultisampleResolve, kRenderTarget, kShaderRead, kUnknown, impeller::Attachment::load_action, impeller::RenderTarget::AttachmentConfig::load_action, impeller::Attachment::resolve_texture, impeller::TextureDescriptor::sample_count, impeller::RenderTarget::SetColorAttachment(), impeller::RenderTarget::SetDepthAttachment(), impeller::RenderTarget::SetStencilAttachment(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, impeller::RenderTarget::AttachmentConfig::store_action, impeller::Attachment::texture, impeller::TextureDescriptor::usage, and VALIDATION_LOG.

Referenced by impeller::SurfaceMTL::MakeFromTexture().

WrapWithGPUColorFilter()

std::shared_ptr< ColorFilterContents > impeller::WrapWithGPUColorFilter	(	const flutter::DlColorFilter *	filter,
		const std::shared_ptr< FilterInput > &	input,
		ColorFilterContents::AbsorbOpacity	absorb_opacity
	)

Definition at line 24 of file color_filter.cc.

                                                     {
  FML_DCHECK(filter);
 
  switch (filter->type()) {
    case flutter::DlColorFilterType::kBlend: {
      const flutter::DlBlendColorFilter* blend_filter = filter->asBlend();
      FML_DCHECK(blend_filter);
 
      auto filter = ColorFilterContents::MakeBlend(
          static_cast<BlendMode>(blend_filter->mode()), {input},
          skia_conversions::ToColor(blend_filter->color()));
      filter->SetAbsorbOpacity(absorb_opacity);
      return filter;
    }
    case flutter::DlColorFilterType::kMatrix: {
      const flutter::DlMatrixColorFilter* matrix_filter = filter->asMatrix();
      FML_DCHECK(matrix_filter);
 
      impeller::ColorMatrix color_matrix;
      matrix_filter->get_matrix(color_matrix.array);
      auto filter = ColorFilterContents::MakeColorMatrix({input}, color_matrix);
      filter->SetAbsorbOpacity(absorb_opacity);
      return filter;
    }
    case flutter::DlColorFilterType::kSrgbToLinearGamma: {
      auto filter = ColorFilterContents::MakeSrgbToLinearFilter({input});
      filter->SetAbsorbOpacity(absorb_opacity);
      return filter;
    }
    case flutter::DlColorFilterType::kLinearToSrgbGamma: {
      auto filter = ColorFilterContents::MakeLinearToSrgbFilter({input});
      filter->SetAbsorbOpacity(absorb_opacity);
      return filter;
    }
  }
 
  FML_UNREACHABLE();
}

References impeller::ColorMatrix::array, impeller::ColorFilterContents::MakeBlend(), impeller::ColorFilterContents::MakeColorMatrix(), impeller::ColorFilterContents::MakeLinearToSrgbFilter(), impeller::ColorFilterContents::MakeSrgbToLinearFilter(), and impeller::skia_conversions::ToColor().

Referenced by impeller::Paint::CreateContents(), impeller::Paint::MaskBlurDescriptor::CreateMaskBlur(), and WrapInput().

WrapWithInvertColors()

std::shared_ptr< ColorFilterContents > impeller::WrapWithInvertColors	(	const std::shared_ptr< FilterInput > &	input,
		ColorFilterContents::AbsorbOpacity	absorb_opacity
	)

Definition at line 16 of file color_filter.cc.

                                                     {
  auto filter = ColorFilterContents::MakeColorMatrix({input}, kColorInversion);
  filter->SetAbsorbOpacity(absorb_opacity);
  return filter;
}

References kColorInversion, and impeller::ColorFilterContents::MakeColorMatrix().

Referenced by impeller::Paint::CreateContents(), and impeller::Paint::MaskBlurDescriptor::CreateMaskBlur().

Variable Documentation

g_all_pools_map_mutex

Mutex impeller::g_all_pools_map_mutex

static

Definition at line 172 of file command_pool_vk.cc.

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

gHasValidationLayers

bool impeller::gHasValidationLayers = false

static

Definition at line 51 of file context_vk.cc.

Referenced by HasValidationLayers().

gShouldOpenNewPlaygrounds

std::atomic_bool impeller::gShouldOpenNewPlaygrounds = true

static

Definition at line 162 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::testing::TEST(), and impeller::testing::TEST_P().

kAdrenoVersions

const std::unordered_map<std::string_view, AdrenoGPU> impeller::kAdrenoVersions

Definition at line 16 of file driver_info_vk.cc.

Referenced by GetAdrenoVersion().

kAlloc

const TESSalloc impeller::kAlloc

static

Initial value:

= {
    HeapAlloc, HeapRealloc, HeapFree, 0, 
    16,                                  
    16,                                  
    16,                                  
    16,                                  
    16,                                  
    0                                    
}

Definition at line 25 of file tessellator_libtess.cc.

Referenced by impeller::TessellatorLibtess::TessellatorLibtess().

kAllocatorBlockSize

constexpr size_t impeller::kAllocatorBlockSize = 1024000

constexpr

Definition at line 19 of file host_buffer.cc.

kAngleInputAttachmentPrefix

constexpr std::string_view impeller::kAngleInputAttachmentPrefix

staticconstexpr

Initial value:

=
    "ANGLEInputAttachment"

Definition at line 24 of file buffer_bindings_gles.cc.

kBlendModeNames

constexpr const char* impeller::kBlendModeNames[]

staticconstexpr

Initial value:

= {
    IMPELLER_FOR_EACH_BLEND_MODE(_IMPELLER_BLEND_MODE_NAME_LIST)}

Definition at line 44 of file color.cc.

Referenced by BlendModeToString().

kColorInversion

constexpr const ColorMatrix impeller::kColorInversion

staticconstexpr

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 16 of file color_filter.h.

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

kDefaultBindingSize

constexpr const DescriptorPoolSize impeller::kDefaultBindingSize

staticconstexpr

Initial value:

=
    DescriptorPoolSize{
        .buffer_bindings = 512u,   
        .texture_bindings = 256u,  
        .storage_bindings = 32,
        .subpass_bindings = 4u  
    }

Descriptor pools are always allocated with the following sizes.

Definition at line 21 of file descriptor_pool_vk.cc.

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

Referenced by impeller::Color::Blend(), ClipColor(), impeller::LineGeometry::ComputeAlongVector(), impeller::SolidRRectLikeBlurContents::Render(), impeller::TextureContents::RenderToSnapshot(), impeller::Tessellator::RoundCapLine(), impeller::testing::TEST(), and impeller::testing::TEST_P().

kEmptyResult

const GeometryResult impeller::kEmptyResult

static

Initial value:

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

Definition at line 43 of file geometry.h.

kFramebufferFetchExt

constexpr const char* impeller::kFramebufferFetchExt

staticconstexpr

Initial value:

=
    "GL_EXT_shader_framebuffer_fetch"

Definition at line 13 of file capabilities_gles.cc.

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

kGaussianBlurMaxKernelSize

constexpr int32_t impeller::kGaussianBlurMaxKernelSize = 50

staticconstexpr

Definition at line 17 of file gaussian_blur_filter_contents.h.

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

kHostBufferArenaSize

constexpr const size_t impeller::kHostBufferArenaSize = 4u

staticconstexpr

Approximately the same size as the max frames in flight.

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

kInstanceLayer

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

staticconstexpr

Definition at line 17 of file capabilities_vk.cc.

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

kKernelRadiusPerSigma

constexpr static float impeller::kKernelRadiusPerSigma = 1.73205080757f

staticconstexpr

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

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

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

Definition at line 24 of file sigma.h.

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

kLog10E

constexpr float impeller::kLog10E = 0.43429448190325182765f

constexpr

Definition at line 17 of file constants.h.

kLog2E

constexpr float impeller::kLog2E = 1.4426950408889634074f

constexpr

Definition at line 14 of file constants.h.

kLogE10

constexpr float impeller::kLogE10 = 2.30258509299404568402f

constexpr

Definition at line 23 of file constants.h.

kLogE2

constexpr float impeller::kLogE2 = 0.69314718055994530942f

constexpr

Definition at line 20 of file constants.h.

kMagicSubpassInputBinding

constexpr size_t impeller::kMagicSubpassInputBinding = 64u

staticconstexpr

Definition at line 35 of file render_pass_vk.cc.

kMaliVersions

const std::unordered_map<std::string_view, MaliGPU> impeller::kMaliVersions

Definition at line 71 of file driver_info_vk.cc.

Referenced by GetMaliVersion().

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.

kMaxAttachments

constexpr size_t impeller::kMaxAttachments

staticconstexpr

Initial value:

=
    (kMaxColorAttachments * 2) + 1

Definition at line 18 of file render_pass_builder_vk.h.

kMaxBindings

constexpr size_t impeller::kMaxBindings = 32

staticconstexpr

Definition at line 23 of file pipeline_vk.h.

kMaxColorAttachments

constexpr size_t impeller::kMaxColorAttachments = 16

staticconstexpr

Definition at line 17 of file render_pass_builder_vk.h.

kMaxFramesInFlight

constexpr size_t impeller::kMaxFramesInFlight = 2u

staticconstexpr

Definition at line 21 of file khr_swapchain_impl_vk.cc.

kMaxPendingPresents

constexpr const size_t impeller::kMaxPendingPresents = 2u

staticconstexpr

Definition at line 26 of file ahb_swapchain_impl_vk.h.

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

kMaxSigmaDenominator

constexpr int32_t impeller::kMaxSigmaDenominator = 10

staticconstexpr

Definition at line 16 of file text_shadow_cache.cc.

kMaxTextScale

constexpr Scalar impeller::kMaxTextScale = 250

staticconstexpr

Definition at line 1658 of file canvas.cc.

Referenced by impeller::Canvas::DrawTextFrame().

kMaxUniformGradientStops

constexpr uint32_t impeller::kMaxUniformGradientStops = 256u

staticconstexpr

Definition at line 47 of file gradient_generator.h.

Referenced by PopulateUniformGradientColors(), impeller::ConicalGradientContents::Render(), impeller::LinearGradientContents::Render(), impeller::RadialGradientContents::Render(), and impeller::SweepGradientContents::Render().

kMaxVertexBuffers

constexpr size_t impeller::kMaxVertexBuffers = 16

constexpr

Definition at line 13 of file vertex_buffer.h.

Referenced by impeller::RenderPass::ValidateVertexBuffers().

kMinStrokeSize

constexpr Scalar impeller::kMinStrokeSize = 1.0f

staticconstexpr

Definition at line 19 of file geometry.h.

Referenced by impeller::LineGeometry::ComputePixelHalfWidth(), impeller::Geometry::ComputeStrokeAlphaCoverage(), impeller::StrokeRectGeometry::GetPositionBuffer(), and impeller::StrokeSegmentsGeometry::GetStrokeCoverage().

kMultisampledRenderToTexture2Ext

constexpr const char* impeller::kMultisampledRenderToTexture2Ext

staticconstexpr

Initial value:

=
    "GL_EXT_multisampled_render_to_texture2"

Definition at line 26 of file capabilities_gles.cc.

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

kMultisampledRenderToTextureExt

constexpr const char* impeller::kMultisampledRenderToTextureExt

staticconstexpr

Initial value:

=
    "GL_EXT_multisampled_render_to_texture"

Definition at line 22 of file capabilities_gles.cc.

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

kNullGlyphAtlas

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

static

Definition at line 18 of file lazy_glyph_atlas.cc.

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

kNvidiaTextureBorderClampExt

constexpr const char* impeller::kNvidiaTextureBorderClampExt

staticconstexpr

Initial value:

=
    "GL_NV_texture_border_clamp"

Definition at line 18 of file capabilities_gles.cc.

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

kPadding

constexpr auto impeller::kPadding = 2

constexpr

Definition at line 48 of file typographer_context_skia.cc.

Referenced by AppendToExistingAtlas(), and PairsFitInAtlasOfSize().

kPhi

constexpr float impeller::kPhi = 1.61803398874989484820f

constexpr

Definition at line 54 of file constants.h.

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

kPi

constexpr float impeller::kPi = 3.14159265358979323846f

constexpr

Definition at line 26 of file constants.h.

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

kPiOver2

constexpr float impeller::kPiOver2 = 1.57079632679489661923f

constexpr

Definition at line 32 of file constants.h.

Referenced by impeller::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 impeller::testing::TEST().

kPipelineCacheFileName

constexpr const char* impeller::kPipelineCacheFileName

staticconstexpr

Initial value:

=
    "flutter.impeller.vkcache"

Definition at line 13 of file pipeline_cache_data_vk.cc.

Referenced by PipelineCacheDataPersist(), and PipelineCacheDataRetrieve().

kPointArenaSize

constexpr size_t impeller::kPointArenaSize = 4096u

staticconstexpr

The size of the point arena buffer stored on the tessellator.

Definition at line 25 of file tessellator.h.

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

kPoolSize

constexpr uint32_t impeller::kPoolSize = 128u

staticconstexpr

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

kQuadrantAxes

constexpr impeller::Vector2 impeller::kQuadrantAxes[4]

staticconstexpr

Initial value:

= {
    {1.0f, 0.0f},
    {0.0f, 1.0f},
    {-1.0f, 0.0f},
    {0.0f, -1.0f},
}

Definition at line 335 of file point.h.

Referenced by impeller::Arc::ComputeIterations(), and impeller::Arc::GetTightArcBounds().

kSelfDependencyDstAccessMask

constexpr auto impeller::kSelfDependencyDstAccessMask

constexpr

Initial value:

=
    vk::AccessFlagBits::eInputAttachmentRead

Definition at line 29 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 27 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 32 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 24 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 22 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 69 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.

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

kSqrt2Over2

constexpr float impeller::kSqrt2Over2 = 0.70710678118654752440f

constexpr

Definition at line 51 of file constants.h.

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

kTextureBorderClampExt

constexpr const char* impeller::kTextureBorderClampExt

staticconstexpr

Initial value:

=
    "GL_EXT_texture_border_clamp"

Definition at line 16 of file capabilities_gles.cc.

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

kTwoOverSqrtPi

Scalar impeller::kTwoOverSqrtPi = 2.0 / std::sqrt(kPi)

static

Definition at line 56 of file solid_rrect_like_blur_contents.cc.

Referenced by computeErf7().

kUnusedAttachmentReference

constexpr vk::AttachmentReference impeller::kUnusedAttachmentReference

staticconstexpr

Initial value:

= {
    VK_ATTACHMENT_UNUSED, vk::ImageLayout::eUndefined}

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

sValidationFailureCallback

ValidationFailureCallback impeller::sValidationFailureCallback

static

Definition at line 15 of file validation.cc.

Referenced by ImpellerValidationBreak(), and ImpellerValidationErrorsSetCallback().

sValidationLogsAreFatal

std::atomic_int32_t impeller::sValidationLogsAreFatal = 0

static

Definition at line 14 of file validation.cc.

Referenced by 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

TessellatorLibtess impeller::tess

static

Definition at line 38 of file geometry_benchmarks.cc.

tls_command_pool_map

thread_local std::unique_ptr<CommandPoolMap> impeller::tls_command_pool_map

static

Definition at line 168 of file command_pool_vk.cc.

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