Namespaces
namespace	android

namespace	compiler

namespace	egl

namespace	saturated

namespace	scene

namespace	skia_conversions

namespace	testing

Classes
class	AHBTextureSourceVK
	A texture source that wraps an instance of AHardwareBuffer. More...

class	AiksContext

class	AiksInspector

class	AiksPlayground

class	AllocatedTextureSourceVK

class	Allocation

class	Allocator
	An object that allocates device memory. More...

class	AllocatorGLES

class	AllocatorMTL

class	AllocatorVK

struct	AllocatorVMATraits

class	AnonymousContents

class	AtlasContents

struct	Attachment

struct	AutoErrorCheck

class	BackendCast

class	BackgroundCommandPoolVK

class	BackgroundDescriptorPoolVK

struct	BarrierVK
	Defines an operations and memory access barrier on a resource. More...

struct	Bindings

class	BitmapSTB

class	BlendColorFilter

class	BlendFilterContents

struct	BlitCommand

struct	BlitCopyBufferToTextureCommand

struct	BlitCopyBufferToTextureCommandMTL

struct	BlitCopyBufferToTextureCommandVK

struct	BlitCopyTextureToBufferCommand

struct	BlitCopyTextureToBufferCommandGLES

struct	BlitCopyTextureToBufferCommandMTL

struct	BlitCopyTextureToBufferCommandVK

struct	BlitCopyTextureToTextureCommand

struct	BlitCopyTextureToTextureCommandGLES

struct	BlitCopyTextureToTextureCommandMTL

struct	BlitCopyTextureToTextureCommandVK

struct	BlitEncodeGLES
	Mixin for dispatching GLES commands. More...

struct	BlitEncodeMTL
	Mixin for dispatching Metal commands. More...

struct	BlitEncodeVK
	Mixin for dispatching Vulkan commands. More...

struct	BlitGenerateMipmapCommand

struct	BlitGenerateMipmapCommandGLES

struct	BlitGenerateMipmapCommandMTL

struct	BlitGenerateMipmapCommandVK

class	BlitPass
	Blit passes encode blit into the underlying command buffer. More...

class	BlitPassGLES

class	BlitPassMTL

class	BlitPassVK

class	BlurImageFilter

struct	BlurParameters

class	BorderMaskBlurFilterContents

struct	BufferAndUniformSlot
	combines the buffer resource and its uniform slot information. More...

class	BufferBindingsGLES
	Sets up stage bindings for single draw call in the OpenGLES backend. More...

struct	BufferView

struct	BufferVMA

struct	BufferVMATraits

class	Canvas

struct	CanvasStackEntry

class	Capabilities

class	CapabilitiesBuilder

class	CapabilitiesGLES
	The Vulkan layers and extensions wrangler. More...

class	CapabilitiesVK
	The Vulkan layers and extensions wrangler. More...

class	Capture

class	CaptureContext

struct	CaptureCursorListElement

struct	CaptureElement

class	CapturePlaybackList

struct	CaptureProcTable

struct	CaptureProperty
	A capturable property type. More...

class	CheckerboardContents

class	CircleGeometry

class	ClipContents

struct	ClipCoverageLayer

class	ClipRestoreContents

struct	Color

struct	ColorAttachment

struct	ColorAttachmentDescriptor
	Describe the color attachment that will be used with this pipeline. More...

class	ColorFilter

class	ColorFilterContents

struct	ColorHSB

class	ColorImageFilter

struct	ColorMatrix

class	ColorMatrixFilterContents

class	ColorSource

class	ColorSourceContents

struct	Command
	An object used to specify work to the GPU along with references to resources the GPU will used when doing said work. More...

class	CommandBuffer
	A collection of encoded commands to be submitted to the GPU for execution. A command buffer is obtained from a graphics `Context`. More...

class	CommandBufferGLES

class	CommandBufferMTL

class	CommandBufferVK

class	CommandEncoderFactoryVK

class	CommandEncoderVK

class	CommandPoolRecyclerVK
	Creates and manages the lifecycle of \|vk::CommandPool\| objects. More...

class	CommandPoolVK
	Manages the lifecycle of a single \|vk::CommandPool\|. More...

class	CommandQueue
	An interface for submitting command buffers to the GPU for encoding and execution. More...

class	CommandQueueVK

class	Comparable

class	ComparableBase

struct	ComparableEqual

struct	ComparableHash

class	ComposedColorFilter
	Applies color filters as f(g(x)), where x is the input color. More...

class	ComposeImageFilter

class	CompressedImage

class	CompressedImageSkia

class	ComputePass
	Compute passes encode compute shader into the underlying command buffer. More...

struct	ComputePassBindingsCacheMTL
	Ensures that bindings on the pass are not redundantly set or updated. Avoids making the driver do additional checks and makes the frame insights during profiling and instrumentation not complain about the same. More...

class	ComputePassMTL

class	ComputePassVK

struct	ComputePipelineBuilder
	An optional (but highly recommended) utility for creating pipelines from reflected shader information. More...

class	ComputePipelineDescriptor

class	ComputePipelineHandle

class	ComputePipelineMTL

class	ComputePipelineVK

class	ComputePlaygroundTest

class	ComputeTessellator
	A utility that generates triangles of the specified fill type given a path. More...

class	ConditionVariable
	A condition variable exactly similar to the one in libcxx with two major differences: More...

class	ConicalGradientContents

struct	ConicalGradientData

class	ContentContext

struct	ContentContextOptions

class	Contents

class	ContentsFilterInput

class	Context
	To do anything rendering related with Impeller, you need a context. More...

class	ContextGLES

class	ContextMTL

class	ContextVK

struct	ContourComponent

class	CoverGeometry
	A geometry that implements "drawPaint" like behavior by covering the entire render pass area. More...

struct	CubicPathComponent

class	DebugReportVK

class	DecompressedImage

class	DefaultEntityPassDelegate

struct	Degrees

struct	DepthAttachment

struct	DepthAttachmentDescriptor

struct	DepthRange

class	DescriptionGLES

class	DescriptorPoolRecyclerVK
	Creates and manages the lifecycle of \|vk::DescriptorPoolVK\| objects. More...

struct	DescriptorPoolSize

class	DescriptorPoolVK
	A per-frame descriptor pool. Descriptors from this pool don't need to be freed individually. Instead, the pool must be collected after all the descriptors allocated from it are done being used. More...

struct	DescriptorSetLayout

class	DeviceBuffer

struct	DeviceBufferDescriptor

class	DeviceBufferGLES

class	DeviceBufferMTL

class	DeviceBufferVK

class	DeviceHolderVK
	Holds a strong reference to the underlying logical Vulkan device. This comes in handy when the context is being torn down and the various components on different threads may need to orchestrate safe shutdown. More...

class	DilateImageFilter

class	DirectionalMorphologyFilterContents

class	DlDispatcher

class	DlDispatcherBase

class	DlImageImpeller

class	DlPlayground

class	DriverInfoVK
	Get information about the Vulkan driver. More...

struct	EGLImageKHRWithDisplay

struct	EGLImageKHRWithDisplayTraits

struct	EGLImageWithDisplay

struct	EGLImageWithDisplayTraits

class	EllipseGeometry

class	Entity

class	EntityPass

class	EntityPassClipStack
	A class that tracks all clips that have been recorded in the current entity pass stencil. More...

class	EntityPassDelegate

class	EntityPassTarget

class	EntityPlayground

class	ErodeImageFilter

class	ExperimentalCanvas

class	ExperimentalDlDispatcher

class	FenceWaiterVK

class	FillPathGeometry
	A geometry that is created from a filled path object. More...

class	FilterContents

class	FilterContentsFilterInput

class	FilterInput

class	Font
	Describes a typeface along with any modifications to its intrinsic properties. More...

class	FontGlyphAtlas
	An object that can look up glyph locations within the GlyphAtlas for a particular typeface. More...

struct	FontGlyphPair
	A font along with a glyph in that font rendered at a particular scale. More...

class	FramebufferBlendContents

class	GaussianBlurFilterContents

class	Geometry

struct	GeometryResult

struct	GLProc

struct	GLTexture

struct	GLTextureTraits

struct	Glyph
	The glyph index in the typeface. More...

class	GlyphAtlas
	A texture containing the bitmap representation of glyphs in different fonts along with the ability to query the location of specific font glyphs within the texture. More...

class	GlyphAtlasContext
	A container for caching a glyph atlas across frames. More...

class	GlyphAtlasContextSkia
	A container for caching a glyph atlas across frames. More...

class	GlyphAtlasContextSTB

class	GoldenPlaygroundTest

class	GPUProbe

class	GPUTracerGLES
	Trace GPU execution times using GL_EXT_disjoint_timer_query on GLES. More...

class	GPUTracerMTL
	Approximate the GPU frame time by computing a difference between the smallest GPUStartTime and largest GPUEndTime for all command buffers submitted in a frame workload. More...

class	GPUTracerVK
	A class that uses timestamp queries to record the approximate GPU execution time. More...

struct	GradientData

struct	Half
	A storage only class for half precision floating point. More...

struct	HalfVector2
	A storage only class for half precision floating point vector 2. More...

struct	HalfVector3
	A storage only class for half precision floating point vector 3. More...

struct	HalfVector4
	A storage only class for half precision floating point vector 4. More...

struct	HandleGLES

class	HostBuffer

class	Image

struct	ImageData

class	ImageFilter

class	ImageFilterVisitor

struct	ImageVMA

struct	ImageVMATraits

struct	ImmutableSamplerKeyVK

class	ImpellerBenchmarkAccessor

class	ImpellerEntityUnitTestAccessor

class	InlinePassContext

struct	IPoint16

struct	KHRFrameSynchronizerVK

class	KHRSwapchainImageVK

class	KHRSwapchainImplVK
	An instance of a swapchain that does NOT adapt to going out of date with the underlying surface. Errors will be indicated when the next drawable is acquired from this implementation of the swapchain. If the error is due the swapchain going out of date, the caller must recreate another instance by optionally stealing this implementations guts. More...

class	KHRSwapchainVK
	A swapchain implemented backed by VK_KHR_swapchain and VK_KHR_surface. More...

class	LazyGlyphAtlas

class	LinearGradientContents

struct	LinearGradientData

struct	LinearPathComponent

class	LinearToSrgbColorFilter

class	LinearToSrgbFilterContents

class	LineGeometry

class	LocalMatrixFilterContents

class	LocalMatrixImageFilter

class	Lock

struct	Mask
	A mask of typed enums. More...

struct	MaskTraits

struct	Matrix
	A 4x4 matrix using column-major storage. More...

class	MatrixColorFilter

struct	MatrixDecomposition

class	MatrixFilterContents

class	MatrixImageFilter

struct	MixedOp_

class	MultiArchShaderArchive

class	MultiArchShaderArchiveWriter

class	NinePatchConverter

class	NoExceptionPromise

class	OpacityPeepholePassDelegate

struct	Padded
	Struct used for padding uniform buffer array elements. More...

struct	Padding

struct	Paint

class	PaintPassDelegate

struct	PassBindingsCacheMTL
	Ensures that bindings on the pass are not redundantly set or updated. Avoids making the driver do additional checks and makes the frame insights during profiling and instrumentation not complain about the same. More...

class	Path
	Paths are lightweight objects that describe a collection of linear, quadratic, or cubic segments. These segments may be broken up by move commands, which are effectively linear commands that pick up the pen rather than continuing to draw. More...

class	PathBuilder

struct	PathComponentEndDirectionVisitor

struct	PathComponentStartDirectionVisitor

struct	Picture

class	PictureRecorder

class	Pipeline
	Describes the fixed function and programmable aspects of rendering and compute operations performed by commands submitted to the GPU via a command buffer. More...

struct	PipelineBuilder
	An optional (but highly recommended) utility for creating pipelines from reflected shader information. More...

class	PipelineCacheVK

class	PipelineDescriptor

struct	PipelineFuture

class	PipelineGLES

class	PipelineLibrary

class	PipelineLibraryGLES

class	PipelineLibraryMTL

class	PipelineLibraryVK

class	PipelineMTL

class	PipelineVK

class	PlaceholderFilterInput

class	Playground

class	PlaygroundImpl

class	PlaygroundImplGLES

class	PlaygroundImplMTL

class	PlaygroundImplVK

struct	PlaygroundPoint

struct	PlaygroundSwitches

class	PlaygroundTest

class	PointFieldGeometry

class	Pool
	A thread-safe pool with a limited byte size. More...

struct	PoolVMA

struct	PoolVMATraits

class	ProcTableGLES

struct	QuadraticPathComponent

struct	Quaternion

struct	QueueIndexVK

struct	QueuesVK
	The collection of queues used by the context. The queues may all be the same. More...

class	QueueVK
	A thread safe object that can be used to access device queues. If multiple objects are created with the same underlying queue, then the external synchronization guarantees of Vulkan queues cannot be met. So care must be taken the same device queue doesn't form the basis of multiple `QueueVK`s. More...

class	RadialGradientContents

struct	RadialGradientData

struct	Radians

struct	Radius
	For convolution filters, the "radius" is the size of the convolution kernel to use on the local space pixel grid of the filter input. For Gaussian blur kernels, this unit has a linear relationship with `Sigma`. See `kKernelRadiusPerSigma` for details on how this relationship works. More...

struct	Range

class	ReactorGLES
	The reactor attempts to make thread-safe usage of OpenGL ES easier to reason about. More...

class	ReaderLock

class	RecordingRenderPass

class	RectanglePacker
	Packs rectangles into a specified area without rotating them. More...

class	RectGeometry

class	Renderer

class	RenderPass
	Render passes encode render commands directed as one specific render target into an underlying command buffer. More...

class	RenderPassBuilderVK

struct	RenderPassData
	Encapsulates data that will be needed in the reactor for the encoding of commands for this render pass. More...

class	RenderPassGLES

class	RenderPassMTL

class	RenderPassVK

class	RenderPipelineHandle

class	RenderTarget

class	RenderTargetAllocator
	a wrapper around the impeller [Allocator] instance that can be used to provide caching of allocated render target textures. More...

class	RenderTargetCache
	An implementation of the [RenderTargetAllocator] that caches all allocated texture data for one frame. More...

struct	RenderTargetConfig

struct	Resource

struct	ResourceBinder
	An interface for binding resources. This is implemented by \|Command\| and \|ComputeCommand\| to make GPU resources available to a given command's pipeline. More...

class	ResourceManagerVK
	A resource manager controls how resources are allocated and reclaimed. More...

class	ResourceVK
	A resource that may be reclaimed by a \|ResourceManagerVK\|. More...

class	ResourceVKT
	An internal type that is used to move a resource reference. More...

class	RoundRectGeometry

class	RuntimeEffectContents

struct	RuntimeEffectData

class	RuntimeStage

class	RuntimeStagePlayground

struct	RuntimeUniformDescription

struct	RuntimeUniformDimensions

struct	SampledImageSlot
	Metadata required to bind a combined texture and sampler. More...

class	Sampler

struct	SamplerDescriptor

class	SamplerGLES

class	SamplerLibrary

class	SamplerLibraryGLES

class	SamplerLibraryMTL

class	SamplerLibraryVK

class	SamplerMTL

class	SamplerVK

struct	ScaledFont
	A font and a scale. Used as a key that represents a typeface within a glyph atlas. More...

class	SceneContents

struct	ScopedValidationDisable

struct	ScopedValidationFatal

class	ShaderArchive

class	ShaderArchiveWriter

class	ShaderFunction

class	ShaderFunctionGLES

class	ShaderFunctionMTL

class	ShaderFunctionVK

struct	ShaderKey

class	ShaderLibrary

class	ShaderLibraryGLES

class	ShaderLibraryMTL

class	ShaderLibraryVK

struct	ShaderMetadata

struct	ShaderStageBufferLayout

class	ShaderStageCompatibilityChecker

class	ShaderStageCompatibilityChecker< CheckerboardVertexShader, FragmentShaderT >

class	ShaderStageCompatibilityChecker< ClipVertexShader, FragmentShaderT >

struct	ShaderStageIOSlot

struct	ShaderStructMemberMetadata

struct	ShaderUniformSlot
	Metadata required to bind a buffer. More...

class	SharedObjectVK

class	SharedObjectVKT

struct	Shear

struct	Sigma
	In filters that use Gaussian distributions, "sigma" is a size of one standard deviation in terms of the local space pixel grid of the filter input. In other words, this determines how wide the distribution stretches. More...

class	SkylineRectanglePacker

struct	Snapshot
	Represents a texture and its intended draw transform/sampler configuration. More...

class	SolidColorContents

class	SolidRRectBlurContents
	Draws a fast solid color blur of an rounded rectangle. Only supports RRects with fully symmetrical radii. Also produces correct results for rectangles (corner_radius=0) and circles (corner_radius=width/2=height/2). More...

class	SrgbToLinearColorFilter

class	SrgbToLinearFilterContents

class	StandardCapabilities

struct	StencilAttachment

struct	StencilAttachmentDescriptor

struct	StopData

class	StrokePathGeometry
	A geometry that is created from a stroked path object. More...

class	Surface

class	SurfaceContextVK

class	SurfaceGLES

class	SurfaceMTL

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

class	SweepGradientContents

struct	SweepGradientData

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

class	TestImpellerAllocator

class	TestImpellerContext

class	TestImpellerDeviceBuffer

class	TestImpellerTexture

struct	TexImage2DData

class	TextContents

class	TextFrame
	Represents a collection of shaped text runs. More...

class	TextFrameDispatcher
	Performs a first pass over the display list to collect all text frames. More...

class	TextRun
	Represents a collection of positioned glyphs from a specific font. More...

class	Texture

struct	TextureAndSampler
	combines the texture, sampler and sampler slot information. More...

class	TextureContents

struct	TextureDescriptor
	A lightweight object that describes the attributes of a texture that can then used an allocator to create that texture. More...

class	TextureFilterInput

class	TextureGLES

class	TextureMTL

class	TextureSourceVK
	Abstract base class that represents a vkImage and an vkImageView. More...

class	TextureVK

class	TiledTextureContents

struct	TPoint

class	TraceSerializer

class	TrackedObjectsVK
	A per-frame object used to track resource lifetimes and allocate command buffers and descriptor sets. More...

struct	TRect

struct	Trig
	A structure to store the sine and cosine of an angle. More...

struct	TSize

class	Typeface
	A typeface, usually obtained from a font-file, on disk describes the intrinsic properties of the font. Typefaces are rarely used directly. Instead, font refer to typefaces along with any modifications applied to its intrinsic properties. More...

class	TypefaceSkia

class	TypefaceSTB

class	TypographerContext
	The graphics context necessary to render text. More...

class	TypographerContextSkia

class	TypographerContextSTB

struct	UniqueID

class	UniqueResourceVKT
	A unique handle to a resource which will be reclaimed by the specified resource manager. More...

class	ValidationLog

struct	Vector3

struct	Vector4

struct	Version

struct	VertexBuffer

class	VertexBufferBuilder

class	VertexDescriptor
	Describes the format and layout of vertices expected by the pipeline. While it is possible to construct these descriptors manually, it would be tedious to do so. These are usually constructed using shader information reflected using `impellerc`. The usage of this class is indirectly via `PipelineBuilder<VS, FS>`. More...

class	VertexDescriptorMTL

struct	Vertices

class	VerticesGeometry
	A geometry that is created from a vertices object. More...

class	VerticesSimpleBlendContents

struct	Viewport

class	WaitSetEntry

class	WriterLock

struct	YUVConversionDescriptorVKEqual

struct	YUVConversionDescriptorVKHash

class	YUVConversionLibraryVK
	Due the way the Vulkan spec. treats "identically defined" conversions, creating two conversion with identical descriptors, using one with the image and the other with the sampler, is invalid use. More...

class	YUVConversionVK
	It is sometimes necessary to deal with formats not native to Vulkan. In such cases, extra information is necessary to access images. A YUV conversion object is needed in such instances. More...

class	YUVToRGBFilterContents

Typedefs
using	CanvasType = Canvas

using	ColorSourceData = std::variant< LinearGradientData, RadialGradientData, ConicalGradientData, SweepGradientData, ImageData, RuntimeEffectData, std::monostate >

using	MyMask = Mask< MyMaskBits >

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

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

using	Clock = std::chrono::high_resolution_clock

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

using	TextureUsageMask = Mask< TextureUsage >

using	ColorWriteMask = Mask< ColorWriteMaskBits >

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

using	LinearGradientFillPipeline = RenderPipelineHandle< GradientFillVertexShader, LinearGradientFillFragmentShader >

using	SolidFillPipeline = RenderPipelineHandle< SolidFillVertexShader, SolidFillFragmentShader >

using	RadialGradientFillPipeline = RenderPipelineHandle< GradientFillVertexShader, RadialGradientFillFragmentShader >

using	ConicalGradientFillPipeline = RenderPipelineHandle< GradientFillVertexShader, ConicalGradientFillFragmentShader >

using	SweepGradientFillPipeline = RenderPipelineHandle< GradientFillVertexShader, SweepGradientFillFragmentShader >

using	LinearGradientSSBOFillPipeline = RenderPipelineHandle< GradientFillVertexShader, LinearGradientSsboFillFragmentShader >

using	ConicalGradientSSBOFillPipeline = RenderPipelineHandle< GradientFillVertexShader, ConicalGradientSsboFillFragmentShader >

using	RadialGradientSSBOFillPipeline = RenderPipelineHandle< GradientFillVertexShader, RadialGradientSsboFillFragmentShader >

using	SweepGradientSSBOFillPipeline = RenderPipelineHandle< GradientFillVertexShader, SweepGradientSsboFillFragmentShader >

using	RRectBlurPipeline = RenderPipelineHandle< RrectBlurVertexShader, RrectBlurFragmentShader >

using	TexturePipeline = RenderPipelineHandle< TextureFillVertexShader, TextureFillFragmentShader >

using	TextureStrictSrcPipeline = RenderPipelineHandle< TextureFillVertexShader, TextureFillStrictSrcFragmentShader >

using	TiledTexturePipeline = RenderPipelineHandle< TextureUvFillVertexShader, TiledTextureFillFragmentShader >

using	GaussianBlurPipeline = RenderPipelineHandle< FilterPositionUvVertexShader, GaussianFragmentShader >

using	BorderMaskBlurPipeline = RenderPipelineHandle< FilterPositionUvVertexShader, BorderMaskBlurFragmentShader >

using	MorphologyFilterPipeline = RenderPipelineHandle< FilterPositionUvVertexShader, MorphologyFilterFragmentShader >

using	ColorMatrixColorFilterPipeline = RenderPipelineHandle< FilterPositionVertexShader, ColorMatrixColorFilterFragmentShader >

using	LinearToSrgbFilterPipeline = RenderPipelineHandle< FilterPositionVertexShader, LinearToSrgbFilterFragmentShader >

using	SrgbToLinearFilterPipeline = RenderPipelineHandle< FilterPositionVertexShader, SrgbToLinearFilterFragmentShader >

using	YUVToRGBFilterPipeline = RenderPipelineHandle< FilterPositionVertexShader, YuvToRgbFilterFragmentShader >

using	GlyphAtlasPipeline = RenderPipelineHandle< GlyphAtlasVertexShader, GlyphAtlasFragmentShader >

using	PorterDuffBlendPipeline = RenderPipelineHandle< PorterDuffBlendVertexShader, PorterDuffBlendFragmentShader >

using	ClipPipeline = RenderPipelineHandle< ClipVertexShader, ClipFragmentShader >

using	BlendColorPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendColorBurnPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendColorDodgePipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendDarkenPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendDifferencePipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendExclusionPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendHardLightPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendHuePipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendLightenPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendLuminosityPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendMultiplyPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendOverlayPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendSaturationPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendScreenPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	BlendSoftLightPipeline = RenderPipelineHandle< AdvancedBlendVertexShader, AdvancedBlendFragmentShader >

using	FramebufferBlendColorPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendColorBurnPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendColorDodgePipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendDarkenPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendDifferencePipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendExclusionPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendHardLightPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendHuePipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendLightenPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendLuminosityPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendMultiplyPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendOverlayPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendSaturationPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendScreenPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	FramebufferBlendSoftLightPipeline = RenderPipelineHandle< FramebufferBlendVertexShader, FramebufferBlendFragmentShader >

using	VerticesUberShader = RenderPipelineHandle< PorterDuffBlendVertexShader, VerticesUberFragmentShader >
	Draw Vertices/Atlas Uber Shader.

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

using	GaussianBlurVertexShader = GaussianBlurPipeline::VertexShader

using	GaussianBlurFragmentShader = GaussianBlurPipeline::FragmentShader

using	VS = SolidFillVertexShader

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

using	Point = TPoint< Scalar >

using	IPoint = TPoint< int64_t >

using	IPoint32 = TPoint< int32_t >

using	UintPoint32 = TPoint< uint32_t >

using	Vector2 = Point

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

using	Rect = TRect< Scalar >

using	IRect = TRect< int64_t >

using	Scalar = float

using	Size = TSize< Scalar >

using	ISize = TSize< int64_t >

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

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

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

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

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

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

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

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

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

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

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

using	BufferResource = Resource< BufferView >

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

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

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

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

using	TessellatedVertexProc = Tessellator::TessellatedVertexProc

using	EllipticalVertexGenerator = Tessellator::EllipticalVertexGenerator

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

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

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

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

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

Enumerations
enum class	PointStyle { kRound , kSquare }

enum class	SourceRectConstraint { kFast , kStrict }
	Controls the behavior of the source rectangle given to DrawImageRect. More...

enum	CanvasRecorderOp : uint16_t { kNew , kSave , kSaveLayer , kRestore , kRestoreToCount , kResetTransform , kTransform , kConcat , kPreConcat , kTranslate , kScale2 , kScale3 , kSkew , kRotate , kDrawPath , kDrawPaint , kDrawLine , kDrawRect , kDrawOval , kDrawRRect , kDrawCircle , kDrawPoints , kDrawImage , kDrawImageRect , kClipPath , kClipRect , kClipOval , kClipRRect , kDrawTextFrame , kDrawVertices , kDrawAtlas }

enum 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 }
	Decides how backend draws pixels based on input vertices. More...

enum class	PolygonMode { kFill , kLine }

enum class	MinMagFilter { kNearest , kLinear }

enum class	MipFilter { kNearest , kLinear }

enum class	SamplerAddressMode { 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 , 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 { kUniformBuffer , kStorageBuffer , kSampledImage , kImage , kSampler , kInputAttachment }

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	BlendSelectValues { kScreen = 0 , kOverlay , kDarken , kLighten , kColorDodge , kColorBurn , kHardLight , kSoftLight , kDifference , kExclusion , kMultiply , kHue , kSaturation , kColor , kLuminosity }

enum class	ContentBoundsPromise { kUnknown , kContainsContents , kMayClipContents }

enum class	YUVColorSpace { kBT601LimitedRange , kBT601FullRange }

enum class	BlendMode : uint8_t { kClear = 0 , kSource , kDestination , kSourceOver , kDestinationOver , kSourceIn , kDestinationIn , kSourceOut , kDestinationOut , kSourceATop , kDestinationATop , kXor , kPlus , kModulate , kScreen , kOverlay , kDarken , kLighten , kColorDodge , kColorBurn , kHardLight , kSoftLight , kDifference , kExclusion , kMultiply , kHue , kSaturation , kColor , kLuminosity , kLast = kLuminosity }

enum class	Cap { kButt , kRound , kSquare }

enum class	Join { kMiter , kRound , kBevel }

enum class	FillType { kNonZero , kOdd }

enum class	Convexity { kUnknown , kConvex }

enum class	PlaygroundBackend { kMetal , kOpenGLES , kVulkan }

enum class	HandleType { kUnknown , kTexture , kBuffer , kProgram , kRenderBuffer , kFrameBuffer }

enum class	DebugResourceType { kTexture , kBuffer , kProgram , kShader , kRenderBuffer , kFrameBuffer }

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	OptionalDeviceExtensionVK : uint32_t { kEXTPipelineCreationFeedback , kVKKHRPortabilitySubset , kLast }
	A device extension enabled if available. Subsystems cannot assume availability and must check if these extensions are available. More...

enum class	VendorVK { kUnknown , kGoogle , kQualcomm , kARM , kImgTec , kPowerVR = kImgTec , kAMD , kNvidia , kIntel , kMesa , kApple }

enum class	DeviceTypeVK { kUnknown , kIntegratedGPU , kDiscreteGPU , kVirtualGPU , kCPU }

enum class	ArchiveShaderType { kVertex , kFragment , kCompute }

enum class	ArchiveRenderingBackend { kMetal , kVulkan , kOpenGLES }

Functions
static bool	UseColorSourceContents (const std::shared_ptr< VerticesGeometry > &vertices, const Paint &paint)

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

	BENCHMARK_CAPTURE (BM_CanvasRecord, draw_rect, &DrawRect)

	BENCHMARK_CAPTURE (BM_CanvasRecord, draw_circle, &DrawCircle)

	BENCHMARK_CAPTURE (BM_CanvasRecord, draw_line, &DrawLine)

static void	ApplyFramebufferBlend (Entity &entity)

static std::unique_ptr< EntityPassTarget >	CreateRenderTarget (ContentContext &renderer, ISize size, int mip_count, const Color &clear_color)

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

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

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

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

	IMPELLER_ENUM_IS_MASK (MyMaskBits)

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

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

void	ImpellerUnimplemented (const char method, const char file, int line)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class	IPLR_CAPABILITY ("mutex") Mutex

void	ImpellerValidationErrorsSetFatal (bool fatal)

void	ImpellerValidationBreak (const char *message)

bool	ImpellerValidationErrorsAreFatal ()

std::vector< spirv_cross::ID >	SortUniforms (const spirv_cross::ParsedIR ir, const spirv_cross::Compiler compiler, std::optional< spirv_cross::SPIRType::BaseType > type_filter=std::nullopt, bool include=true)
	Sorts uniform declarations in an IR according to decoration order.

	_FOR_EACH_CAPTURE_PROPERTY (_CAPTURE_PROPERTY_CAST_DEFINITION)

	_FOR_EACH_CAPTURE_PROPERTY (_CAPTURE_PROPERTY_DEFINITION)

	_FOR_EACH_CAPTURE_PROPERTY (_CAPTURE_PROPERTY_DECLARATION)

constexpr bool	StoreActionNeedsResolveTexture (StoreAction action)

std::string	TextureUsageMaskToString (TextureUsageMask mask)

std::string	AttachmentToString (const Attachment &attachment)

std::string	ColorAttachmentToString (const ColorAttachment &color)

std::string	DepthAttachmentToString (const DepthAttachment &depth)

std::string	StencilAttachmentToString (const StencilAttachment &stencil)

constexpr const char *	StorageModeToString (StorageMode mode)

constexpr bool	IsDepthWritable (PixelFormat format)

constexpr bool	IsStencilWritable (PixelFormat format)

constexpr const char *	PixelFormatToString (PixelFormat format)

constexpr const char *	LoadActionToString (LoadAction action)

constexpr const char *	StoreActionToString (StoreAction action)

constexpr bool	CanClearAttachment (LoadAction action)

constexpr bool	CanDiscardAttachmentWhenDone (StoreAction action)

constexpr const char *	TextureTypeToString (TextureType type)

constexpr bool	IsMultisampleCapable (TextureType type)

	IMPELLER_ENUM_IS_MASK (TextureUsage)

constexpr const char *	TextureUsageToString (TextureUsage usage)

	IMPELLER_ENUM_IS_MASK (ColorWriteMaskBits)

constexpr size_t	BytesPerPixelForPixelFormat (PixelFormat format)

constexpr size_t	DefaultUniformAlignment ()

constexpr ShaderStage	ToShaderStage (RuntimeShaderStage stage)

constexpr Vector4	ToVector (Color color)

std::string	TextureDescriptorToString (const TextureDescriptor &desc)

constexpr const char *	CompressionTypeToString (CompressionType type)

static BlendMode	ToBlendMode (flutter::DlBlendMode mode)

static Entity::TileMode	ToTileMode (flutter::DlTileMode tile_mode)

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

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

static Matrix	ToMatrix (const SkMatrix &m)

static Paint::Style	ToStyle (flutter::DlDrawStyle style)

static std::vector< Color >	ToColors (const flutter::DlColor colors[], int count)

static std::optional< ColorSource::Type >	ToColorSourceType (flutter::DlColorSourceType type)

static std::shared_ptr< ColorFilter >	ToColorFilter (const flutter::DlColorFilter *filter)

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

static std::shared_ptr< ImageFilter >	ToImageFilter (const flutter::DlImageFilter *filter)

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

static Rect	ToRect (const SkRect &rect)

static VerticesGeometry::VertexMode	ToVertexMode (flutter::DlVertexMode mode)

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

static Scalar	GetShaderClipDepth (const Entity &entity)

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

ContentContextOptions	OptionsFromPass (const RenderPass &pass)

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

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

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

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

GaussianBlurPipeline::FragmentShader::KernelSamples	GenerateBlurInfo (BlurParameters parameters)

GaussianBlurPipeline::FragmentShader::KernelSamples	LerpHackKernelSamples (GaussianBlurPipeline::FragmentShader::KernelSamples parameters)

std::shared_ptr< Texture >	CreateGradientTexture (const GradientData &gradient_data, const std::shared_ptr< impeller::Context > &context)
	Create a host visible texture that contains the gradient defined by the provided gradient data.

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.

static ShaderType	GetShaderType (RuntimeUniformType type)

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

template<typename T >
T::VertInfo *	GetVertInfo (const Command &command)
	Retrieve the [VertInfo] struct data from the provided [command].

template<typename T >
T::FragInfo *	GetFragInfo (const Command &command)
	Retrieve the [FragInfo] struct data from the provided [command].

static std::optional< SamplerAddressMode >	TileModeToAddressMode (Entity::TileMode tile_mode, const Capabilities &capabilities)

static EntityPassTarget	CreateRenderTarget (ContentContext &renderer, ISize size, int mip_count, const Color &clear_color)

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

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

static constexpr bool	ValidateBlendModes ()

const char *	BlendModeToString (BlendMode blend_mode)

static constexpr Color	Min (Color c, float threshold)

static constexpr Scalar	Luminosity (Vector3 color)

static constexpr Vector3	ClipColor (Vector3 color)

static constexpr Vector3	SetLuminosity (Vector3 color, Scalar luminosity)

static constexpr Scalar	Saturation (Vector3 color)

static constexpr Vector3	SetSaturation (Vector3 color, Scalar saturation)

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

static constexpr Vector3	ToRGB (Color color)

static constexpr Color	FromRGB (Vector3 color, Scalar alpha)

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

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

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

std::string	ColorToString (const Color &color)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	MAKE_STROKE_BENCHMARK_CAPTURE (RRect, Butt, Bevel,,,)

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.

constexpr InternalHalf	ScalarToHalf (Scalar f)
	Convert a scalar to a half precision float.

static Scalar	LinearSolve (Scalar t, Scalar p0, Scalar p1)

static Scalar	QuadraticSolve (Scalar t, Scalar p0, Scalar p1, Scalar p2)

static Scalar	QuadraticSolveDerivative (Scalar t, Scalar p0, Scalar p1, Scalar p2)

static Scalar	CubicSolve (Scalar t, Scalar p0, Scalar p1, Scalar p2, Scalar p3)

static Scalar	CubicSolveDerivative (Scalar t, Scalar p0, Scalar p1, Scalar p2, Scalar p3)

static bool	NearEqual (Scalar a, Scalar b, Scalar epsilon)

static bool	NearZero (Scalar a)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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	ComputeQuadradicSubdivisions (Scalar scale_factor, const QuadraticPathComponent &quad)

Scalar	ComputeCubicSubdivisions (float scale_factor, const CubicPathComponent &cub)

	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.

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

static size_t	GetBytesPerPixel (DecompressedImage::Format format)

std::string	PlaygroundBackendToString (PlaygroundBackend backend)

static void	InitializeGLFWOnce ()

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

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

constexpr RuntimeStageBackend	PlaygroundBackendToRuntimeStageBackend (PlaygroundBackend backend)

Point	DrawPlaygroundPoint (PlaygroundPoint &point)

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

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

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

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

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

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

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

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

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

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

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

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

static GLenum	ToTarget (DeviceBufferGLES::BindingType type)

std::string	DebugToFramebufferError (int status)

constexpr GLenum	ToMode (PrimitiveType primitive_type)

constexpr GLenum	ToIndexType (IndexType type)

constexpr GLenum	ToStencilOp (StencilOperation op)

constexpr GLenum	ToCompareFunction (CompareFunction func)

constexpr GLenum	ToBlendFactor (BlendFactor factor)

constexpr GLenum	ToBlendOperation (BlendOperation op)

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

constexpr GLenum	ToTextureType (TextureType type)

constexpr std::optional< GLenum >	ToTextureTarget (TextureType type)

std::string	HandleTypeToString (HandleType type)

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

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

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

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

const char *	GLErrorToString (GLenum value)

bool	GLErrorIsFatal (GLenum value)

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

static const char *	FramebufferStatusToString (GLenum status)

static const char *	AttachmentTypeString (GLint type)

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

static std::optional< GLenum >	ToDebugIdentifier (DebugResourceType type)

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

void()	glClearDepthf (GLfloat depth)

void()	glDepthRangef (GLfloat n, GLfloat f)

void()	glClearDepth (GLdouble depth)

void()	glDepthRange (GLdouble n, GLdouble f)

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

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

static DebugResourceType	ToDebugResourceType (HandleType type)

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

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

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

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

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

static GLint	ToAddressMode (SamplerAddressMode mode, bool supports_decal_sampler_address_mode)

static ShaderStage	ToShaderStage (ArchiveShaderType type)

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

static bool	IsDepthStencilFormat (PixelFormat format)

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

HandleType	ToHandleType (TextureGLES::Type type)

static std::optional< GLenum >	ToRenderBufferFormat (PixelFormat format)

static GLenum	ToAttachmentType (TextureGLES::AttachmentType point)

static bool	DeviceSupportsDeviceTransientTargets (id< MTLDevice > device)

static bool	DeviceHasUnifiedMemoryArchitecture (id< MTLDevice > device)

static ISize	DeviceMaxTextureSizeSupported (id< MTLDevice > device)

static bool	SupportsLossyTextureCompression (id< MTLDevice > device)

static MTLResourceOptions	ToMTLResourceOptions (StorageMode type, bool supports_memoryless_targets, bool supports_uma)

static MTLStorageMode	ToMTLStorageMode (StorageMode mode, bool supports_memoryless_targets, bool supports_uma)

	API_AVAILABLE (ios(14.0), macos(11.0)) static NSString *MTLCommandEncoderErrorStateToString(MTLCommandEncoderErrorState state)

static NSString *	MTLCommandBufferErrorToString (MTLCommandBufferError code)

static bool	LogMTLCommandBufferErrorIfPresent (id< MTLCommandBuffer > buffer)

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

static CommandBuffer::Status	ToCommitResult (MTLCommandBufferStatus status)

static bool	DeviceSupportsFramebufferFetch (id< MTLDevice > device)

static bool	DeviceSupportsComputeSubgroups (id< MTLDevice > device)

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

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

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

static id< MTLDevice >	CreateMetalDevice ()

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

constexpr PixelFormat	FromMTLPixelFormat (MTLPixelFormat format)

MTLPixelFormat	SafeMTLPixelFormatDepth24Unorm_Stencil8 ()

MTLPixelFormat	SafeMTLPixelFormatBGR10_XR_sRGB ()

MTLPixelFormat	SafeMTLPixelFormatBGR10_XR ()

MTLPixelFormat	SafeMTLPixelFormatBGRA10_XR ()

constexpr MTLPixelFormat	ToMTLPixelFormat (PixelFormat format)

constexpr MTLBlendFactor	ToMTLBlendFactor (BlendFactor type)

constexpr MTLPrimitiveType	ToMTLPrimitiveType (PrimitiveType type)

constexpr MTLTriangleFillMode	ToMTLTriangleFillMode (PolygonMode mode)

constexpr MTLIndexType	ToMTLIndexType (IndexType type)

constexpr MTLCullMode	ToMTLCullMode (CullMode mode)

constexpr MTLBlendOperation	ToMTLBlendOperation (BlendOperation type)

constexpr MTLColorWriteMask	ToMTLColorWriteMask (ColorWriteMask type)

constexpr MTLCompareFunction	ToMTLCompareFunction (CompareFunction func)

constexpr MTLStencilOperation	ToMTLStencilOperation (StencilOperation op)

constexpr MTLLoadAction	ToMTLLoadAction (LoadAction action)

constexpr LoadAction	FromMTLLoadAction (MTLLoadAction action)

constexpr MTLStoreAction	ToMTLStoreAction (StoreAction action)

constexpr StoreAction	FromMTLStoreAction (MTLStoreAction action)

constexpr MTLSamplerMinMagFilter	ToMTLSamplerMinMagFilter (MinMagFilter filter)

constexpr MTLSamplerMipFilter	ToMTLSamplerMipFilter (MipFilter filter)

constexpr MTLSamplerAddressMode	ToMTLSamplerAddressMode (SamplerAddressMode mode)

MTLClearColor	ToMTLClearColor (const Color &color)

constexpr MTLTextureType	ToMTLTextureType (TextureType type)

MTLRenderPipelineColorAttachmentDescriptor *	ToMTLRenderPipelineColorAttachmentDescriptor (ColorAttachmentDescriptor descriptor)

MTLDepthStencilDescriptor *	ToMTLDepthStencilDescriptor (std::optional< DepthAttachmentDescriptor > depth, std::optional< StencilAttachmentDescriptor > front, std::optional< StencilAttachmentDescriptor > back)

MTLTextureDescriptor *	ToMTLTextureDescriptor (const TextureDescriptor &desc)

MTLStencilDescriptor *	ToMTLStencilDescriptor (const StencilAttachmentDescriptor &descriptor)

std::shared_future< id< CAMetalDrawable > >	GetDrawableDeferred (CAMetalLayer *layer)
	Create a deferred drawable from a CAMetalLayer.

std::shared_ptr< TextureMTL >	CreateTextureFromDrawableFuture (TextureDescriptor desc, const std::shared_future< id< CAMetalDrawable > > &drawble_future)
	Create a TextureMTL from a deferred drawable.

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

static MTLComputePipelineDescriptor *	GetMTLComputePipelineDescriptor (const ComputePipelineDescriptor &desc)

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

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

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

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

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

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

static MTLRenderPassDescriptor *	ToMTLRenderPassDescriptor (const RenderTarget &desc)

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

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

static MTLFunctionType	ToMTLFunctionType (ShaderStage stage)

static std::optional< RenderTarget >	WrapTextureWithRenderTarget (Allocator &allocator, id< MTLTexture > texture, bool requires_blit, std::optional< IRect > clip_rect)

std::shared_ptr< Texture >	WrapperMTL (TextureDescriptor desc, const void *mtl_texture, std::function< void()> deletion_proc)

std::shared_ptr< Texture >	WrapTextureMTL (TextureDescriptor desc, const void *mtl_texture, std::function< void()> deletion_proc=nullptr)

static MTLVertexFormat	ReadStageInputFormat (const ShaderStageIOSlot &input)

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

static VmaAllocationCreateFlags	ToVmaAllocationBufferCreateFlags (StorageMode mode, bool readback)

static PoolVMA	CreateBufferPool (VmaAllocator allocator)

static constexpr VmaMemoryUsage	ToVMAMemoryUsage ()

static constexpr vk::Flags< vk::MemoryPropertyFlagBits >	ToVKTextureMemoryPropertyFlags (StorageMode mode, bool supports_memoryless_textures)

static VmaAllocationCreateFlags	ToVmaAllocationCreateFlags (StorageMode mode)

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

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

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

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

static PixelFormat	ToPixelFormat (AHardwareBuffer_Format format)

static TextureType	ToTextureType (const AHardwareBuffer_Desc &ahb_desc)

static TextureDescriptor	ToTextureDescriptor (const AHardwareBuffer_Desc &ahb_desc)

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

static const char *	GetExtensionName (RequiredCommonDeviceExtensionVK ext)

static const char *	GetExtensionName (RequiredAndroidDeviceExtensionVK ext)

static const char *	GetExtensionName (OptionalDeviceExtensionVK ext)

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

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

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

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

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

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

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

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

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

bool	HasValidationLayers ()

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

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

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

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

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

constexpr VendorVK	IdentifyVendor (uint32_t vendor)

constexpr 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 vk::SampleCountFlagBits	ToVKSampleCountFlagBits (SampleCount count)

constexpr vk::BlendFactor	ToVKBlendFactor (BlendFactor factor)

constexpr vk::BlendOp	ToVKBlendOp (BlendOperation op)

constexpr vk::ColorComponentFlags	ToVKColorComponentFlags (ColorWriteMask type)

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

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

constexpr vk::Format	ToVKImageFormat (PixelFormat format)

constexpr PixelFormat	ToPixelFormat (vk::Format format)

constexpr vk::SampleCountFlagBits	ToVKSampleCount (SampleCount sample_count)

constexpr vk::Filter	ToVKSamplerMinMagFilter (MinMagFilter filter)

constexpr vk::SamplerMipmapMode	ToVKSamplerMipmapMode (MipFilter filter)

constexpr vk::SamplerAddressMode	ToVKSamplerAddressMode (SamplerAddressMode mode)

constexpr vk::ShaderStageFlags	ToVkShaderStage (ShaderStage stage)

constexpr vk::DescriptorType	ToVKDescriptorType (DescriptorType type)

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

constexpr vk::AttachmentLoadOp	ToVKAttachmentLoadOp (LoadAction load_action)

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

constexpr bool	StoreActionPerformsResolve (StoreAction store_action)

constexpr vk::IndexType	ToVKIndexType (IndexType index_type)

constexpr vk::PolygonMode	ToVKPolygonMode (PolygonMode mode)

constexpr vk::PrimitiveTopology	ToVKPrimitiveTopology (PrimitiveType primitive)

constexpr bool	PixelFormatIsDepthStencil (PixelFormat format)

constexpr vk::CullModeFlags	ToVKCullModeFlags (CullMode mode)

constexpr vk::CompareOp	ToVKCompareOp (CompareFunction op)

constexpr vk::StencilOp	ToVKStencilOp (StencilOperation op)

constexpr vk::StencilOpState	ToVKStencilOpState (const StencilAttachmentDescriptor &desc)

constexpr vk::ImageAspectFlags	ToVKImageAspectFlags (PixelFormat format)

constexpr uint32_t	ToArrayLayerCount (TextureType type)

constexpr vk::ImageViewType	ToVKImageViewType (TextureType type)

constexpr vk::ImageCreateFlags	ToVKImageCreateFlags (TextureType type)

constexpr vk::ImageAspectFlags	ToImageAspectFlags (PixelFormat format)

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

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

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

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

static vk::PipelineCreationFeedbackEXT	EmptyFeedback ()

constexpr vk::FrontFace	ToVKFrontFace (WindingOrder order)

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

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

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

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

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

void	InsertBarrierForInputAttachmentRead (const vk::CommandBuffer &buffer, const vk::Image &image)
	Inserts the appropriate barriers to ensure that subsequent commands can read from the specified image (itself a framebuffer attachment) as an input attachment.

static vk::ClearColorValue	VKClearValueFromColor (Color color)

static vk::ClearDepthStencilValue	VKClearValueFromDepthStencil (uint32_t stencil, Scalar depth)

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

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

static ShaderStage	ToShaderStage (ArchiveShaderType type)

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

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

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

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

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

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

vk::Format	ToVertexDescriptorFormat (const ShaderStageIOSlot &input)

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

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

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

fml::Status	AddMipmapGeneration (const std::shared_ptr< CommandBuffer > &command_buffer, const std::shared_ptr< Context > &context, const std::shared_ptr< Texture > &texture)
	Adds a blit command to the render pass.

static RuntimeUniformType	ToType (fb::UniformDataType type)

static RuntimeShaderStage	ToShaderStage (fb::Stage stage)

constexpr ArchiveRenderingBackend	ToArchiveRenderingBackend (fb::RenderingBackend backend)

constexpr fb::RenderingBackend	ToRenderingBackend (ArchiveRenderingBackend backend)

constexpr ArchiveShaderType	ToShaderType (fb::Stage stage)

bool	Main (const fml::CommandLine &command_line)

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

constexpr fb::Stage	ToStage (ArchiveShaderType type)

PathBuilder *	CreatePathBuilder ()

void	DestroyPathBuilder (PathBuilder *builder)

void	MoveTo (PathBuilder *builder, Scalar x, Scalar y)

void	LineTo (PathBuilder *builder, Scalar x, Scalar y)

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

void	Close (PathBuilder *builder)

struct Vertices *	Tessellate (PathBuilder *builder, int fill_type, Scalar tolerance)

void	DestroyVertices (Vertices *vertices)

static size_t	ComputeQuadrantDivisions (Scalar pixel_radius)

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)

static Rect	ToRect (const SkRect &rect)

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

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

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

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

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

static bool	UpdateAtlasBitmap (const GlyphAtlas &atlas, const std::shared_ptr< SkBitmap > &bitmap, const std::vector< FontGlyphPair > &new_pairs)

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

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

static std::shared_ptr< Texture >	UploadGlyphTextureAtlas (const std::shared_ptr< Allocator > &allocator, std::shared_ptr< SkBitmap > bitmap, const ISize &atlas_size, PixelFormat format)

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

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

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

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

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

static bool	UpdateAtlasBitmap (const GlyphAtlas &atlas, const std::shared_ptr< BitmapSTB > &bitmap, const std::vector< FontGlyphPair > &new_pairs)

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

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

static std::shared_ptr< Texture >	UploadGlyphTextureAtlas (const std::shared_ptr< Allocator > &allocator, std::shared_ptr< BitmapSTB > &bitmap, const ISize &atlas_size, PixelFormat format)

Variables
static const char *	kElementsWindowName = "Elements"

static const char *	kPropertiesWindowName = "Properties"

static const std::initializer_list< std::string >	kSupportedDocuments

static const auto	kPropertiesProcTable

static const constexpr RenderTarget::AttachmentConfig	kDefaultStencilConfig

constexpr ColorMatrix	kColorInversion
	A color matrix which inverts colors.

static std::atomic_size_t	sLastID

static std::atomic_int32_t	sValidationLogsDisabledCount = 0

static std::atomic_int32_t	sValidationLogsAreFatal = 0

constexpr size_t	kAllocatorBlockSize = 1024000

static const constexpr size_t	kHostBufferArenaSize = 3u
	Approximately the same size as the max frames in flight.

constexpr std::array< std::array< Scalar, 5 >, 15 >	kPorterDuffCoefficients

constexpr Matrix	kMatrixBT601LimitedRange

constexpr Matrix	kMatrixBT601FullRange

static const constexpr RenderTarget::AttachmentConfig	kDefaultStencilConfig

static const GeometryResult	kEmptyResult

static constexpr const char *	kBlendModeNames []

constexpr float	kE = 2.7182818284590452354f

constexpr float	kLog2E = 1.4426950408889634074f

constexpr float	kLog10E = 0.43429448190325182765f

constexpr float	kLogE2 = 0.69314718055994530942f

constexpr float	kLogE10 = 2.30258509299404568402f

constexpr float	kPi = 3.14159265358979323846f

constexpr float	k2Pi = 6.28318530717958647693f

constexpr float	kPiOver2 = 1.57079632679489661923f

constexpr float	kPiOver4 = 0.78539816339744830962f

constexpr float	k1OverPi = 0.31830988618379067154f

constexpr float	k2OverPi = 0.63661977236758134308f

constexpr float	k2OverSqrtPi = 1.12837916709551257390f

constexpr float	kSqrt2 = 1.41421356237309504880f

constexpr float	k1OverSqrt2 = 0.70710678118654752440f

constexpr float	kPhi = 1.61803398874989484820f

constexpr float	kEhCloseEnough = 1e-3f

static TessellatorLibtess	tess

static constexpr float	kKernelRadiusPerSigma = 1.73205080757

static const std::vector< std::string >	kSkipTests

static std::atomic_bool	gShouldOpenNewPlaygrounds = true

static constexpr std::string_view	kAngleInputAttachmentPrefix

static const constexpr char *	kFramebufferFetchExt

static const constexpr char *	kTextureBorderClampExt

static const constexpr char *	kNvidiaTextureBorderClampExt

static const constexpr char *	kMultisampledRenderToTextureExt

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

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

static constexpr const char *	kInstanceLayer = "ImpellerInstance"

static thread_local std::unique_ptr< CommandPoolMap >	tls_command_pool_map

static Mutex	g_all_pools_map_mutex

static bool	gHasValidationLayers = false

static const constexpr DescriptorPoolSize	kDefaultBindingSize
	Descriptor pools are always allocated with the following sizes.

static constexpr vk::AttachmentReference	kUnusedAttachmentReference

static constexpr uint32_t	kPoolSize = 128u

constexpr size_t	kImageSizeThresholdForDedicatedMemoryAllocation

static constexpr const char *	kPipelineCacheFileName

static constexpr size_t	kMaxBindings = 32

constexpr auto	kSelfDependencySrcStageMask

constexpr auto	kSelfDependencySrcAccessMask

constexpr auto	kSelfDependencyDstStageMask

constexpr auto	kSelfDependencyDstAccessMask

constexpr auto	kSelfDependencyFlags = vk::DependencyFlagBits::eByRegion

static constexpr size_t	kMagicSubpassInputBinding = 64u

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

static constexpr size_t	kMaxFramesInFlight = 3u

static constexpr size_t	kPollFramesForOrientation = 1u

static constexpr int	kPrecomputedDivisionCount = 1024

static int	kPrecomputedDivisions [kPrecomputedDivisionCount]

static const TESSalloc	kAlloc

static constexpr Scalar	kScaleSize = 100000.0f

constexpr auto	kPadding = 2

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

Typedef Documentation

◆ AHBProperties

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

Definition at line 14 of file ahb_texture_source_vk.cc.

◆ BlendColorBurnPipeline

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

Definition at line 160 of file content_context.h.

◆ BlendColorDodgePipeline

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

Definition at line 163 of file content_context.h.

◆ BlendColorPipeline

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

Definition at line 158 of file content_context.h.

◆ BlendDarkenPipeline

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

Definition at line 166 of file content_context.h.

◆ BlendDifferencePipeline

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

Definition at line 168 of file content_context.h.

◆ BlendExclusionPipeline

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

Definition at line 171 of file content_context.h.

◆ BlendHardLightPipeline

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

Definition at line 174 of file content_context.h.

◆ BlendHuePipeline

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

Definition at line 177 of file content_context.h.

◆ BlendLightenPipeline

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

Definition at line 179 of file content_context.h.

◆ BlendLuminosityPipeline

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

Definition at line 181 of file content_context.h.

◆ BlendMultiplyPipeline

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

Definition at line 184 of file content_context.h.

◆ BlendOverlayPipeline

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

Definition at line 186 of file content_context.h.

◆ BlendSaturationPipeline

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

Definition at line 188 of file content_context.h.

◆ BlendScreenPipeline

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

Definition at line 191 of file content_context.h.

◆ BlendSoftLightPipeline

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

Definition at line 193 of file content_context.h.

◆ BorderMaskBlurPipeline

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

Definition at line 130 of file content_context.h.

◆ BufferResource

using impeller::BufferResource = typedef Resource<BufferView>

Definition at line 57 of file command.h.

◆ Callback

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

Definition at line 26 of file pipeline_library_mtl.mm.

◆ CanvasType

using impeller::CanvasType = typedef Canvas

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

Definition at line 20 of file canvas_type.h.

◆ ClipPipeline

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

Definition at line 155 of file content_context.h.

◆ Clock

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

Definition at line 14 of file timing.h.

◆ ColorMatrixColorFilterPipeline

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

Definition at line 136 of file content_context.h.

◆ ColorSourceData

using impeller::ColorSourceData = typedef std::variant<LinearGradientData, RadialGradientData, ConicalGradientData, SweepGradientData, ImageData, RuntimeEffectData, std::monostate>

Definition at line 88 of file color_source.h.

◆ ColorWriteMask

using impeller::ColorWriteMask = typedef Mask<ColorWriteMaskBits>

Definition at line 446 of file formats.h.

◆ CommandPoolMap

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

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

◆ ConicalGradientFillPipeline

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

Definition at line 100 of file content_context.h.

◆ ConicalGradientSSBOFillPipeline

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

Definition at line 109 of file content_context.h.

◆ CTessellator

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

Definition at line 20 of file tessellator_libtess.h.

◆ EllipticalVertexGenerator

using impeller::EllipticalVertexGenerator = typedef Tessellator::EllipticalVertexGenerator

Definition at line 241 of file tessellator.cc.

◆ FontGlyphMap

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

Definition at line 29 of file font_glyph_pair.h.

◆ FramebufferBlendColorBurnPipeline

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

Definition at line 200 of file content_context.h.

◆ FramebufferBlendColorDodgePipeline

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

Definition at line 203 of file content_context.h.

◆ FramebufferBlendColorPipeline

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

Definition at line 197 of file content_context.h.

◆ FramebufferBlendDarkenPipeline

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

Definition at line 206 of file content_context.h.

◆ FramebufferBlendDifferencePipeline

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

Definition at line 209 of file content_context.h.

◆ FramebufferBlendExclusionPipeline

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

Definition at line 212 of file content_context.h.

◆ FramebufferBlendHardLightPipeline

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

Definition at line 215 of file content_context.h.

◆ FramebufferBlendHuePipeline

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

Definition at line 218 of file content_context.h.

◆ FramebufferBlendLightenPipeline

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

Definition at line 221 of file content_context.h.

◆ FramebufferBlendLuminosityPipeline

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

Definition at line 224 of file content_context.h.

◆ FramebufferBlendMultiplyPipeline

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

Definition at line 227 of file content_context.h.

◆ FramebufferBlendOverlayPipeline

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

Definition at line 230 of file content_context.h.

◆ FramebufferBlendSaturationPipeline

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

Definition at line 233 of file content_context.h.

◆ FramebufferBlendScreenPipeline

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

Definition at line 236 of file content_context.h.

◆ FramebufferBlendSoftLightPipeline

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

Definition at line 239 of file content_context.h.

◆ GaussianBlurFragmentShader

using impeller::GaussianBlurFragmentShader = typedef GaussianBlurPipeline::FragmentShader

Definition at line 20 of file gaussian_blur_filter_contents.cc.

◆ GaussianBlurPipeline

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

Definition at line 128 of file content_context.h.

◆ GaussianBlurVertexShader

using impeller::GaussianBlurVertexShader = typedef GaussianBlurPipeline::VertexShader

Definition at line 19 of file gaussian_blur_filter_contents.cc.

◆ GlyphAtlasPipeline

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

Definition at line 149 of file content_context.h.

◆ IPoint

using impeller::IPoint = typedef TPoint<int64_t>

Definition at line 317 of file point.h.

◆ IPoint32

using impeller::IPoint32 = typedef TPoint<int32_t>

Definition at line 318 of file point.h.

◆ IRect

using impeller::IRect = typedef TRect<int64_t>

Definition at line 747 of file rect.h.

◆ ISize

using impeller::ISize = typedef TSize<int64_t>

Definition at line 138 of file size.h.

◆ LinearGradientFillPipeline

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

Definition at line 92 of file content_context.h.

◆ LinearGradientSSBOFillPipeline

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

Definition at line 106 of file content_context.h.

◆ LinearToSrgbFilterPipeline

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

Definition at line 139 of file content_context.h.

◆ MillisecondsF

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

Definition at line 12 of file timing.h.

◆ MixedOp

template<class F , class I >

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

Definition at line 19 of file type_traits.h.

◆ MorphologyFilterPipeline

using impeller::MorphologyFilterPipeline = typedef RenderPipelineHandle<FilterPositionUvVertexShader, MorphologyFilterFragmentShader>

Definition at line 133 of file content_context.h.

◆ MyMask

using impeller::MyMask = typedef Mask<MyMaskBits>

Definition at line 20 of file base_unittests.cc.

◆ PathComponentVariant

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

Definition at line 141 of file path_component.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 std::shared_ptr<Pipeline<PipelineDescriptor> > ( ContentContext::*)(ContentContextOptions) const

Definition at line 72 of file blend_filter_contents.cc.

◆ Point

using impeller::Point = typedef TPoint<Scalar>

Definition at line 316 of file point.h.

◆ PorterDuffBlendPipeline

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

Definition at line 152 of file content_context.h.

◆ Quad

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

Definition at line 321 of file point.h.

◆ RadialGradientFillPipeline

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

Definition at line 97 of file content_context.h.

◆ RadialGradientSSBOFillPipeline

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

Definition at line 112 of file content_context.h.

◆ Rect

using impeller::Rect = typedef TRect<Scalar>

Definition at line 746 of file rect.h.

◆ RRectBlurPipeline

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

Definition at line 118 of file content_context.h.

◆ SamplerMap

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

Definition at line 32 of file sampler.h.

◆ Scalar

using impeller::Scalar = typedef float

Definition at line 18 of file scalar.h.

◆ SecondsF

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

Definition at line 13 of file timing.h.

◆ ShaderFunctionMap

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

Definition at line 40 of file shader_key.h.

◆ SharedHandleVK

template<class T >

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

Definition at line 52 of file shared_object_vk.h.

◆ Size

using impeller::Size = typedef TSize<Scalar>

Definition at line 137 of file size.h.

◆ SolidFillPipeline

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

Definition at line 95 of file content_context.h.

◆ SrgbToLinearFilterPipeline

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

Definition at line 142 of file content_context.h.

◆ SweepGradientFillPipeline

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

Definition at line 103 of file content_context.h.

◆ SweepGradientSSBOFillPipeline

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

Definition at line 115 of file content_context.h.

◆ TessellatedVertexProc

using impeller::TessellatedVertexProc = typedef Tessellator::TessellatedVertexProc

Definition at line 240 of file tessellator.cc.

◆ TexturePipeline

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

Definition at line 120 of file content_context.h.

◆ TextureResource

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

Definition at line 58 of file command.h.

◆ TextureStrictSrcPipeline

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

Definition at line 122 of file content_context.h.

◆ TextureUsageMask

using impeller::TextureUsageMask = typedef Mask<TextureUsage>

Definition at line 309 of file formats.h.

◆ TiledTexturePipeline

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

Definition at line 125 of file content_context.h.

◆ TimePoint

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

Definition at line 15 of file timing.h.

◆ UintPoint32

using impeller::UintPoint32 = typedef TPoint<uint32_t>

Definition at line 319 of file point.h.

◆ UniqueAllocatorVMA

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

Definition at line 31 of file vma.h.

◆ UniqueBufferVMA

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

Definition at line 98 of file vma.h.

◆ UniqueEGLImage

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

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

◆ Vector2

using impeller::Vector2 = typedef Point

Definition at line 320 of file point.h.

◆ VerticesUberShader

using impeller::VerticesUberShader = typedef RenderPipelineHandle<PorterDuffBlendVertexShader, VerticesUberFragmentShader>

Draw Vertices/Atlas Uber Shader.

Definition at line 244 of file content_context.h.

◆ VS

using impeller::VS = typedef SolidFillVertexShader

Definition at line 14 of file stroke_path_geometry.cc.

◆ WaitSet

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

Definition at line 25 of file fence_waiter_vk.h.

◆ YUVConversionDescriptorVK

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

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

Definition at line 23 of file yuv_conversion_vk.h.

◆ YUVToRGBFilterPipeline

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

Definition at line 145 of file content_context.h.

Enumeration Type Documentation

◆ ArchiveRenderingBackend

enum class impeller::ArchiveRenderingBackend

strong

Enumerator
kMetal
kVulkan
kOpenGLES

Definition at line 16 of file shader_archive_types.h.

                                   {
  kMetal,
  kVulkan,
  kOpenGLES,
};

◆ ArchiveShaderType

enum class impeller::ArchiveShaderType

strong

Enumerator
kVertex
kFragment
kCompute

Definition at line 10 of file shader_archive_types.h.

                             {
  kVertex,
  kFragment,
  kCompute,
};

◆ BlendFactor

enum class impeller::BlendFactor

strong

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

Definition at line 179 of file formats.h.

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

◆ BlendMode

enum class impeller::BlendMode : uint8_t

strong

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

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

Definition at line 59 of file color.h.

                     : uint8_t {
  // The following blend modes are able to be used as pipeline blend modes or
  // via `BlendFilterContents`.
  kClear = 0,
  kSource,
  kDestination,
  kSourceOver,
  kDestinationOver,
  kSourceIn,
  kDestinationIn,
  kSourceOut,
  kDestinationOut,
  kSourceATop,
  kDestinationATop,
  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,
 
  kLast = kLuminosity,
};

◆ BlendOperation

enum class impeller::BlendOperation

strong

Enumerator
kAdd
kSubtract
kReverseSubtract

Definition at line 197 of file formats.h.

                          {
  kAdd,
  kSubtract,
  kReverseSubtract,
};

◆ BlendSelectValues

enum class 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,
};

◆ CanvasRecorderOp

enum impeller::CanvasRecorderOp : uint16_t

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

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

Definition at line 19 of file canvas_recorder.h.

                      : uint16_t {
  kNew,
  kSave,
  kSaveLayer,
  kRestore,
  kRestoreToCount,
  kResetTransform,
  kTransform,
  kConcat,
  kPreConcat,
  kTranslate,
  kScale2,
  kScale3,
  kSkew,
  kRotate,
  kDrawPath,
  kDrawPaint,
  kDrawLine,
  kDrawRect,
  kDrawOval,
  kDrawRRect,
  kDrawCircle,
  kDrawPoints,
  kDrawImage,
  kDrawImageRect,
  kClipPath,
  kClipRect,
  kClipOval,
  kClipRRect,
  kDrawTextFrame,
  kDrawVertices,
  kDrawAtlas,
};

◆ Cap

enum class impeller::Cap

strong

Enumerator
kButt
kRound
kSquare

Definition at line 17 of file path.h.

               {
  kButt,
  kRound,
  kSquare,
};

◆ ColorWriteMaskBits

enum class impeller::ColorWriteMaskBits : uint64_t

strong

Enumerator
kNone
kRed
kGreen
kBlue
kAlpha
kAll

Definition at line 436 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 class impeller::CompareFunction : uint8_t

strong

Enumerator
kNever	Comparison test never passes.
kAlways	Comparison test passes always passes.
kLess	Comparison test passes if new_value < current_value.
kEqual	Comparison test passes if new_value == current_value.
kLessEqual	Comparison test passes if new_value <= current_value.
kGreater	Comparison test passes if new_value > current_value.
kNotEqual	Comparison test passes if new_value != current_value.
kGreaterEqual	Comparison test passes if new_value >= current_value.

Definition at line 534 of file formats.h.

                           : 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 class impeller::CompressionType

strong

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

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

Enumerator
kLossless
kLossy

Definition at line 18 of file texture_descriptor.h.

                           {
  kLossless,
  kLossy,
};

◆ ContentBoundsPromise

enum class impeller::ContentBoundsPromise

strong

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

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

Definition at line 28 of file entity_pass.h.

                                {
  /// @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 class impeller::Convexity

strong

Enumerator
kUnknown
kConvex

Definition at line 34 of file path.h.

                     {
  kUnknown,
  kConvex,
};

◆ CullMode

enum class impeller::CullMode

strong

Enumerator
kNone
kFrontFace
kBackFace

Definition at line 338 of file formats.h.

                    {
  kNone,
  kFrontFace,
  kBackFace,
};

◆ DebugResourceType

enum class impeller::DebugResourceType

strong

Enumerator
kTexture
kBuffer
kProgram
kShader
kRenderBuffer
kFrameBuffer

Definition at line 220 of file proc_table_gles.h.

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

◆ DescriptorType

enum class impeller::DescriptorType

strong

Enumerator
kUniformBuffer
kStorageBuffer
kSampledImage
kImage
kSampler
kInputAttachment

Definition at line 153 of file shader_types.h.

                          {
  kUniformBuffer,
  kStorageBuffer,
  kSampledImage,
  kImage,
  kSampler,
  kInputAttachment,
};

◆ DeviceTypeVK

enum class impeller::DeviceTypeVK

strong

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

Definition at line 36 of file driver_info_vk.h.

                        {
  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 class impeller::FillType

strong

Enumerator
kNonZero
kOdd

Definition at line 29 of file path.h.

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

◆ HandleType

enum class impeller::HandleType

strong

Enumerator
kUnknown
kTexture
kBuffer
kProgram
kRenderBuffer
kFrameBuffer

Definition at line 22 of file handle_gles.h.

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

◆ IndexType

enum class impeller::IndexType

strong

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

Definition at line 344 of file formats.h.

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

◆ Join

enum class impeller::Join

strong

Enumerator
kMiter
kRound
kBevel

Definition at line 23 of file path.h.

                {
  kMiter,
  kRound,
  kBevel,
};

◆ LoadAction

enum class impeller::LoadAction

strong

Enumerator
kDontCare
kLoad
kClear

Definition at line 203 of file formats.h.

                      {
  kDontCare,
  kLoad,
  kClear,
};

◆ MinMagFilter

enum class impeller::MinMagFilter

strong

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

Definition at line 407 of file formats.h.

                        {
  /// 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 class impeller::MipFilter

strong

Enumerator
kNearest	Sample from the nearest mip level.
kLinear	Sample from the two nearest mip levels and linearly interpolate between them.

Definition at line 415 of file formats.h.

                     {
  /// Sample from the nearest mip level.
  kNearest,
  /// Sample from the two nearest mip levels and linearly interpolate between
  /// them.
  kLinear,
};

◆ MyMaskBits

enum class 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,
};

◆ OptionalDeviceExtensionVK

enum class impeller::OptionalDeviceExtensionVK : uint32_t

strong

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

See also: CapabilitiesVK::HasExtension.

Enumerator

kEXTPipelineCreationFeedback

To instrument and profile PSO creation.

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

kVKKHRPortabilitySubset

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

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

kLast

Definition at line 91 of file capabilities_vk.h.

                                     : 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,
 
  kLast,
};

◆ PixelFormat

enum class impeller::PixelFormat : uint8_t

strong

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

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

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

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

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

Definition at line 100 of file formats.h.

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

◆ PlaygroundBackend

enum class impeller::PlaygroundBackend

strong

Enumerator
kMetal
kOpenGLES
kVulkan

Definition at line 29 of file playground.h.

                             {
  kMetal,
  kOpenGLES,
  kVulkan,
};

◆ PointStyle

enum class impeller::PointStyle

strong

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

Definition at line 42 of file canvas.h.

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

◆ PolygonMode

enum class impeller::PolygonMode

strong

Enumerator
kFill
kLine

Definition at line 384 of file formats.h.

                       {
  kFill,
  kLine,
};

◆ PrimitiveType

enum class impeller::PrimitiveType : uint8_t

strong

Decides how backend draws pixels based on input vertices.

Enumerator
kTriangle	Draws a triage for each separate set of three vertices. Vertices [A, B, C, D, E, F] will produce triages [ABC, DEF].
kTriangleStrip	Draws a triage for every adjacent three vertices. Vertices [A, B, C, D, E, F] will produce triages [ABC, BCD, CDE, DEF].
kLine	Draws a line for each separate set of two vertices. Vertices [A, B, C] will produce discontinued line [AB, BC].
kLineStrip	Draws a continuous line that connect every input vertices Vertices [A, B, C] will produce one continuous line [ABC].
kPoint	Draws a point at each input vertex.

Definition at line 353 of file formats.h.

                         : uint8_t {
  /// Draws a triage for each separate set of three vertices.
  ///
  /// Vertices [A, B, C, D, E, F] will produce triages
  /// [ABC, DEF].
  kTriangle,
 
  /// Draws a triage for every adjacent three vertices.
  ///
  /// Vertices [A, B, C, D, E, F] will produce triages
  /// [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,
  // Triangle fans are implementation dependent and need extra extensions
  // checks. Hence, they are not supported here.
};

◆ RequiredAndroidDeviceExtensionVK

enum class impeller::RequiredAndroidDeviceExtensionVK : uint32_t

strong

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

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

Enumerator
kANDROIDExternalMemoryAndroidHardwareBuffer	For importing hardware buffers used in external texture composition. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_ANDROID_external_memory_android_hardware_buffer.html
kKHRSamplerYcbcrConversion	Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_sampler_ycbcr_conversion.html
kKHRExternalMemory	Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_memory.html
kEXTQueueFamilyForeign	Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_queue_family_foreign.html
kKHRDedicatedAllocation	Dependency of kANDROIDExternalMemoryAndroidHardwareBuffer. https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_KHR_dedicated_allocation.html
kLast

Definition at line 45 of file capabilities_vk.h.

                                            : 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 class impeller::RequiredCommonDeviceExtensionVK : uint32_t

strong

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

Enumerator

kKHRSwapchain

For displaying content in the window system.

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

kLast

Definition at line 26 of file capabilities_vk.h.

                                           : 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 class impeller::RuntimeShaderStage

strong

Enumerator
kVertex
kFragment
kCompute

Definition at line 28 of file runtime_types.h.

                              {
  kVertex,
  kFragment,
  kCompute,
};

◆ RuntimeStageBackend

enum class impeller::RuntimeStageBackend

strong

Enumerator
kSkSL
kMetal
kOpenGLES
kVulkan

Definition at line 15 of file runtime_types.h.

                               {
  kSkSL,
  kMetal,
  kOpenGLES,
  kVulkan,
};

◆ RuntimeUniformType

enum impeller::RuntimeUniformType

Enumerator
kFloat
kSampledImage
kStruct

Definition at line 22 of file runtime_types.h.

                        {
  kFloat,
  kSampledImage,
  kStruct,
};

◆ SampleCount

enum class impeller::SampleCount : uint8_t

strong

Enumerator
kCount1
kCount4

Definition at line 296 of file formats.h.

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

◆ SamplerAddressMode

enum class impeller::SamplerAddressMode

strong

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

Definition at line 423 of file formats.h.

                              {
  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 class impeller::ShaderStage

strong

Enumerator
kUnknown
kVertex
kFragment
kCompute

Definition at line 22 of file shader_types.h.

                       {
  kUnknown,
  kVertex,
  kFragment,
  kCompute,
};

◆ ShaderType

enum class 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 class 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 51 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 class impeller::StencilOperation : uint8_t

strong

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

Definition at line 553 of file formats.h.

                            : 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 class impeller::StorageMode

strong

Specified where the allocation resides and how it is used.

Enumerator

kHostVisible

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

kDevicePrivate

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

kDeviceTransient

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

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

Definition at line 33 of file formats.h.

                       {
  //----------------------------------------------------------------------------
  /// 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 class impeller::StoreAction

strong

Enumerator
kDontCare
kStore
kMultisampleResolve
kStoreAndMultisampleResolve

Definition at line 209 of file formats.h.

                       {
  kDontCare,
  kStore,
  kMultisampleResolve,
  kStoreAndMultisampleResolve,
};

◆ TextureCoordinateSystem

enum class impeller::TextureCoordinateSystem

strong

Enumerator
kUploadFromHost
kRenderToTexture

Definition at line 328 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 class impeller::TextureType

strong

Enumerator
kTexture2D
kTexture2DMultisample
kTextureCube
kTextureExternalOES

Definition at line 263 of file formats.h.

                       {
  kTexture2D,
  kTexture2DMultisample,
  kTextureCube,
  kTextureExternalOES,
};

◆ TextureUsage

enum class impeller::TextureUsage

strong

Enumerator
kUnknown
kShaderRead
kShaderWrite
kRenderTarget

Definition at line 301 of file formats.h.

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

◆ VendorVK

enum class impeller::VendorVK

strong

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

Definition at line 13 of file driver_info_vk.h.

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

◆ WindingOrder

enum class impeller::WindingOrder

strong

Enumerator
kClockwise
kCounterClockwise

Definition at line 23 of file formats.h.

                        {
  kClockwise,
  kCounterClockwise,
};

◆ YUVColorSpace

enum class impeller::YUVColorSpace

strong

Enumerator
kBT601LimitedRange
kBT601FullRange

Definition at line 55 of file color.h.

55{ kBT601LimitedRange, kBT601FullRange };

kBT601LimitedRange

@ kBT601LimitedRange

Definition embedder.h:611

kBT601FullRange

@ kBT601FullRange

Definition embedder.h:610

Function Documentation

◆ _FOR_EACH_CAPTURE_PROPERTY() [1/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY ( _CAPTURE_PROPERTY_CAST_DEFINITION )

◆ _FOR_EACH_CAPTURE_PROPERTY() [2/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY ( _CAPTURE_PROPERTY_DECLARATION )

◆ _FOR_EACH_CAPTURE_PROPERTY() [3/3]

impeller::_FOR_EACH_CAPTURE_PROPERTY ( _CAPTURE_PROPERTY_DEFINITION )

◆ Absolute()

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

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

constexpr

Definition at line 21 of file scalar.h.

                                   {
  return val >= T{} ? val : -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 11 of file texture_mipmap.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(context->GetResourceAllocator());
  if (!success) {
    return fml::Status(fml::StatusCode::kUnknown, "");
  }
  return fml::Status();
}

◆ 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 76 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();
    VertexBufferBuilder<typename VS::PerVertexData> vtx_builder;
    vtx_builder.AddVertices({
        {Point(0, 0), dst_uvs[0], src_uvs[0]},
        {Point(size.width, 0), dst_uvs[1], src_uvs[1]},
        {Point(0, size.height), dst_uvs[2], src_uvs[2]},
        {Point(size.width, size.height), dst_uvs[3], src_uvs[3]},
    });
    auto vtx_buffer = vtx_builder.CreateVertexBuffer(host_buffer);
 
    auto options = OptionsFromPass(pass);
    options.primitive_type = PrimitiveType::kTriangleStrip;
    options.blend_mode = BlendMode::kSource;
    std::shared_ptr<Pipeline<PipelineDescriptor>> pipeline =
        std::invoke(pipeline_proc, renderer, options);
 
#ifdef IMPELLER_DEBUG
    pass.SetCommandLabel(
        SPrintF("Advanced Blend Filter (%s)", BlendModeToString(blend_mode)));
#endif  // IMPELLER_DEBUG
    pass.SetVertexBuffer(std::move(vtx_buffer));
    pass.SetPipeline(pipeline);
 
    typename FS::BlendInfo blend_info;
    typename VS::FrameInfo frame_info;
 
    auto dst_sampler_descriptor = dst_snapshot->sampler_descriptor;
    if (renderer.GetDeviceCapabilities().SupportsDecalSamplerAddressMode()) {
      dst_sampler_descriptor.width_address_mode = SamplerAddressMode::kDecal;
      dst_sampler_descriptor.height_address_mode = SamplerAddressMode::kDecal;
    }
    const std::unique_ptr<const Sampler>& dst_sampler =
        renderer.GetContext()->GetSamplerLibrary()->GetSampler(
            dst_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 {
      auto src_sampler_descriptor = src_snapshot->sampler_descriptor;
      if (renderer.GetDeviceCapabilities().SupportsDecalSamplerAddressMode()) {
        src_sampler_descriptor.width_address_mode = SamplerAddressMode::kDecal;
        src_sampler_descriptor.height_address_mode = SamplerAddressMode::kDecal;
      }
      const std::unique_ptr<const Sampler>& src_sampler =
          renderer.GetContext()->GetSamplerLibrary()->GetSampler(
              src_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);
  if (!render_target.ok()) {
    return std::nullopt;
  }
  if (!renderer.GetContext()
           ->GetCommandQueue()
           ->Submit(/*buffers=*/{std::move(command_buffer)})
           .ok()) {
    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());
}

◆ 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]);
}

◆ ApplyBlendedColor()

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

inlinestaticconstexpr

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

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

Definition at line 201 of file color.cc.

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

◆ ApplyFramebufferBlend()

static void impeller::ApplyFramebufferBlend ( Entity & entity )

static

Definition at line 17 of file experimental_canvas.cc.

                                                  {
  auto src_contents = entity.GetContents();
  auto contents = std::make_shared<FramebufferBlendContents>();
  contents->SetChildContents(src_contents);
  contents->SetBlendMode(entity.GetBlendMode());
  entity.SetContents(std::move(contents));
  entity.SetBlendMode(BlendMode::kSource);
}

◆ 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();
}

◆ AttachmentTypeString()

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

static

Definition at line 229 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";
}

◆ BENCHMARK_CAPTURE() [1/10]

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

◆ BENCHMARK_CAPTURE() [2/10]

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

◆ BENCHMARK_CAPTURE() [3/10]

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

◆ BENCHMARK_CAPTURE() [4/10]

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

◆ BENCHMARK_CAPTURE() [5/10]

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

◆ BENCHMARK_CAPTURE() [6/10]

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

◆ BENCHMARK_CAPTURE() [7/10]

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

◆ BENCHMARK_CAPTURE() [8/10]

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

◆ BENCHMARK_CAPTURE() [9/10]

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

◆ BENCHMARK_CAPTURE() [10/10]

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

◆ Bind() [1/2]

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

static

Definition at line 189 of file render_pass_mtl.mm.

                                         {
  if (!view.buffer) {
    return false;
  }
 
  auto device_buffer = view.buffer;
  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.range.offset, buffer);
}

◆ Bind() [2/2]

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

static

Definition at line 211 of file render_pass_mtl.mm.

                                         {
  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());
}

◆ 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)];
}

◆ BM_CanvasRecord()

template<class... Args>

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

static

Definition at line 42 of file canvas_benchmarks.cc.

                                                                   {
  auto args_tuple = std::make_tuple(std::move(args)...);
  auto test_proc = std::get<CanvasCallback>(args_tuple);
 
  size_t op_count = 0u;
  size_t canvas_count = 0u;
  while (state.KeepRunning()) {
    // A new canvas is allocated for each iteration to avoid the benchmark
    // becoming a measurement of only the entity vector re-allocation time.
    Canvas canvas;
    op_count += test_proc(canvas);
    canvas_count++;
  }
  state.counters["TotalOpCount"] = op_count;
  state.counters["TotalCanvasCount"] = canvas_count;
}

◆ BM_Convex()

template<class... Args>

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

static

Definition at line 117 of file geometry_benchmarks.cc.

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

◆ BM_Polyline()

template<class... Args>

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

static

Definition at line 44 of file geometry_benchmarks.cc.

                                                               {
  auto args_tuple = std::make_tuple(std::move(args)...);
  auto path = std::get<Path>(args_tuple);
  bool tessellate = std::get<bool>(args_tuple);
 
  size_t point_count = 0u;
  size_t single_point_count = 0u;
  auto points = std::make_unique<std::vector<Point>>();
  points->reserve(2048);
  while (state.KeepRunning()) {
    if (tessellate) {
      tess.Tessellate(path, 1.0f,
                      [&point_count, &single_point_count](
                          const float* vertices, size_t vertices_count,
                          const uint16_t* indices, size_t indices_count) {
                        if (indices_count > 0) {
                          single_point_count = indices_count;
                          point_count += indices_count;
                        } else {
                          single_point_count = vertices_count;
                          point_count += vertices_count;
                        }
                        return true;
                      });
    } else {
      auto polyline = path.CreatePolyline(
          // Clang-tidy doesn't know that the points get moved back before
          // getting moved again in this loop.
          // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
          1.0f, std::move(points),
          [&points](Path::Polyline::PointBufferPtr reclaimed) {
            points = std::move(reclaimed);
          });
      single_point_count = polyline.points->size();
      point_count += single_point_count;
    }
  }
  state.counters["SinglePointCount"] = single_point_count;
  state.counters["TotalPointCount"] = point_count;
}

◆ BM_StrokePolyline()

template<class... Args>

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

static

Definition at line 86 of file geometry_benchmarks.cc.

                                                                     {
  auto args_tuple = std::make_tuple(std::move(args)...);
  auto path = std::get<Path>(args_tuple);
  auto cap = std::get<Cap>(args_tuple);
  auto join = std::get<Join>(args_tuple);
 
  const Scalar stroke_width = 5.0f;
  const Scalar miter_limit = 10.0f;
  const Scalar scale = 1.0f;
 
  auto points = std::make_unique<std::vector<Point>>();
  points->reserve(2048);
  auto polyline =
      path.CreatePolyline(1.0f, std::move(points),
                          [&points](Path::Polyline::PointBufferPtr reclaimed) {
                            points = std::move(reclaimed);
                          });
 
  size_t point_count = 0u;
  size_t single_point_count = 0u;
  while (state.KeepRunning()) {
    auto vertices = ImpellerBenchmarkAccessor::GenerateSolidStrokeVertices(
        polyline, stroke_width, miter_limit, join, cap, scale);
    single_point_count = vertices.size();
    point_count += single_point_count;
  }
  state.counters["SinglePointCount"] = single_point_count;
  state.counters["TotalPointCount"] = point_count;
}

◆ BytesPerPixelForPixelFormat()

constexpr size_t impeller::BytesPerPixelForPixelFormat ( PixelFormat format )

constexpr

Definition at line 448 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;
}

◆ CanAppendToExistingAtlas() [1/2]

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

static

Definition at line 80 of file typographer_context_skia.cc.

                                                       {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!rect_packer || atlas_size.IsEmpty()) {
    return false;
  }
 
  // We assume that all existing glyphs will fit. After all, they fit before.
  // The glyph_positions only contains the values for the additional glyphs
  // from extra_pairs.
  FML_DCHECK(glyph_positions.size() == 0);
  glyph_positions.reserve(extra_pairs.size());
  for (size_t i = 0; i < extra_pairs.size(); i++) {
    const FontGlyphPair& pair = extra_pairs[i];
 
    const auto glyph_size =
        ISize::Ceil(pair.glyph.bounds.GetSize() * pair.scaled_font.scale);
    IPoint16 location_in_atlas;
    if (!rect_packer->addRect(glyph_size.width + kPadding,   //
                              glyph_size.height + kPadding,  //
                              &location_in_atlas             //
                              )) {
      return false;
    }
    glyph_positions.emplace_back(Rect::MakeXYWH(location_in_atlas.x(),  //
                                                location_in_atlas.y(),  //
                                                glyph_size.width,       //
                                                glyph_size.height       //
                                                ));
  }
 
  return true;
}

◆ CanAppendToExistingAtlas() [2/2]

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

static

Definition at line 98 of file typographer_context_stb.cc.

                                                       {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!rect_packer || atlas_size.IsEmpty()) {
    return false;
  }
 
  // We assume that all existing glyphs will fit. After all, they fit before.
  // The glyph_positions only contains the values for the additional glyphs
  // from extra_pairs.
  FML_DCHECK(glyph_positions.size() == 0);
  glyph_positions.reserve(extra_pairs.size());
  for (size_t i = 0; i < extra_pairs.size(); i++) {
    const FontGlyphPair& pair = extra_pairs[i];
    const Font& font = pair.scaled_font.font;
 
    // We downcast to the correct typeface type to access `stb` specific methods
    std::shared_ptr<TypefaceSTB> typeface_stb =
        std::reinterpret_pointer_cast<TypefaceSTB>(font.GetTypeface());
    // Conversion factor to scale font size in Points to pixels.
    // Note this assumes typical DPI.
    float text_size_pixels =
        font.GetMetrics().point_size * TypefaceSTB::kPointsToPixels;
 
    ISize glyph_size;
    {
      int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
      float scale_y = stbtt_ScaleForMappingEmToPixels(
          typeface_stb->GetFontInfo(), text_size_pixels);
      float scale_x = scale_y;
      stbtt_GetGlyphBitmapBox(typeface_stb->GetFontInfo(), pair.glyph.index,
                              scale_x, scale_y, &x0, &y0, &x1, &y1);
 
      glyph_size = ISize(x1 - x0, y1 - y0);
    }
 
    IPoint16 location_in_atlas;
    if (!rect_packer->addRect(glyph_size.width + kPadding,   //
                              glyph_size.height + kPadding,  //
                              &location_in_atlas             //
                              )) {
      return false;
    }
    glyph_positions.emplace_back(Rect::MakeXYWH(location_in_atlas.x(),  //
                                                location_in_atlas.y(),  //
                                                glyph_size.width,       //
                                                glyph_size.height       //
                                                ));
  }
 
  return true;
}

◆ CanClearAttachment()

constexpr bool impeller::CanClearAttachment ( LoadAction action )

constexpr

Definition at line 240 of file formats.h.

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

◆ CanDiscardAttachmentWhenDone()

constexpr bool impeller::CanDiscardAttachmentWhenDone ( StoreAction action )

constexpr

Definition at line 251 of file formats.h.

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

◆ ChooseAlphaCompositionMode()

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

static

Definition at line 100 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 78 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;
}

◆ ClipColor()

static constexpr Vector3 impeller::ClipColor ( Vector3 color )

inlinestaticconstexpr

Definition at line 144 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;
}

◆ Close()

IMPELLER_API void impeller::Close ( PathBuilder * builder )

Definition at line 38 of file tessellator.cc.

                                 {
  builder->Close();
}

◆ CollectGLHandle()

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

static

Definition at line 108 of file reactor_gles.cc.

                                           {
  switch (type) {
    case HandleType::kUnknown:
      return false;
    case HandleType::kTexture:
      gl.DeleteTextures(1u, &handle);
      return true;
    case HandleType::kBuffer:
      gl.DeleteBuffers(1u, &handle);
      return true;
    case HandleType::kProgram:
      gl.DeleteProgram(handle);
      return true;
    case HandleType::kRenderBuffer:
      gl.DeleteRenderbuffers(1u, &handle);
      return true;
    case HandleType::kFrameBuffer:
      gl.DeleteFramebuffers(1u, &handle);
      return true;
  }
  return false;
}

◆ 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();
}

◆ ColorToString()

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

Definition at line 410 of file color.cc.

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

◆ ComponentChoose()

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

inlinestaticconstexpr

Definition at line 178 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   //
  );
}

◆ CompressionTypeToString()

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

constexpr

Definition at line 23 of file texture_descriptor.h.

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

◆ ComputeCubicSubdivisions() [1/2]

Scalar impeller::ComputeCubicSubdivisions	(	float	scale_factor,
		const CubicPathComponent &	cub
	)

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

                                                               {
  return ComputeCubicSubdivisions(scale_factor, cub.p1, cub.cp1, cub.cp2,
                                  cub.p2);
}

◆ ComputeCubicSubdivisions() [2/2]

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

◆ ComputeQuadradicSubdivisions() [1/2]

Scalar impeller::ComputeQuadradicSubdivisions	(	Scalar	scale_factor,
		const QuadraticPathComponent &	quad
	)

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 42 of file wangs_formula.cc.

                                                                        {
  return ComputeQuadradicSubdivisions(scale_factor, quad.p1, quad.cp, quad.p2);
}

◆ ComputeQuadradicSubdivisions() [2/2]

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

◆ ComputeQuadrantDivisions()

static size_t impeller::ComputeQuadrantDivisions ( Scalar pixel_radius )

static

Definition at line 161 of file tessellator.cc.

                                                            {
  if (pixel_radius <= 0.0) {
    return 1;
  }
  int radius_index = ceil(pixel_radius);
  if (radius_index < kPrecomputedDivisionCount) {
    return kPrecomputedDivisions[radius_index];
  }
 
  // For a circle with N divisions per quadrant, the maximum deviation of
  // the polgyon approximation from the true circle will be at the center
  // of the base of each triangular pie slice. We can compute that distance
  // by finding the midpoint of the line of the first slice and compare
  // its distance from the center of the circle to the radius. We will aim
  // to have the length of that bisector to be within |kCircleTolerance|
  // from the radius in pixels.
  //
  // Each vertex will appear at an angle of:
  //   theta(i) = (kPi / 2) * (i / N)  // for i in [0..N]
  // with each point falling at:
  //   point(i) = r * (cos(theta), sin(theta))
  // If we consider the unit circle to simplify the calculations below then
  // we need to scale the tolerance from its absolute quantity into a unit
  // circle fraction:
  //   k = tolerance / radius
  // Using this scaled tolerance below to avoid multiplying by the radius
  // throughout all of the math, we have:
  //   first point = (1, 0)   // theta(0) == 0
  //   theta = kPi / 2 / N    // theta(1)
  //   second point = (cos(theta), sin(theta)) = (c, s)
  //   midpoint = (first + second) * 0.5 = ((1 + c)/2, s/2)
  //   |midpoint| = sqrt((1 + c)*(1 + c)/4 + s*s/4)
  //     = sqrt((1 + c + c + c*c + s*s) / 4)
  //     = sqrt((1 + 2c + 1) / 4)
  //     = sqrt((2 + 2c) / 4)
  //     = sqrt((1 + c) / 2)
  //     = cos(theta / 2)     // using half-angle cosine formula
  //   error = 1 - |midpoint| = 1 - cos(theta / 2)
  //   cos(theta/2) = 1 - error
  //   theta/2 = acos(1 - error)
  //   kPi / 2 / N / 2 = acos(1 - error)
  //   kPi / 4 / acos(1 - error) = N
  // Since we need error <= k, we want divisions >= N, so we use:
  //   N = ceil(kPi / 4 / acos(1 - k))
  //
  // Math is confirmed in https://math.stackexchange.com/a/4132095
  // (keeping in mind that we are computing quarter circle divisions here)
  // which also points out a performance optimization that is accurate
  // to within an over-estimation of 1 division would be:
  //   N = ceil(kPi / 4 / sqrt(2 * k))
  // Since we have precomputed the divisions for radii up to 1024, we can
  // afford to be more accurate using the acos formula here for larger radii.
  double k = Tessellator::kCircleTolerance / pixel_radius;
  return ceil(kPiOver4 / std::acos(1 - k));
}

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

◆ ConfigureBlending()

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

Definition at line 43 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
    );
  }
}

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

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

◆ ConfigureFBO()

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

static

Definition at line 23 of file blit_command_gles.cc.

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

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

◆ ConfigureStencil() [1/2]

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

Definition at line 94 of file render_pass_gles.cc.

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

◆ ConfigureStencil() [2/2]

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

Definition at line 76 of file render_pass_gles.cc.

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

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

◆ ContainsFormat()

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

static

Definition at line 73 of file khr_swapchain_impl_vk.cc.

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

◆ CreateAtlasBitmap() [1/2]

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

static

Definition at line 217 of file typographer_context_skia.cc.

                                                                            {
  TRACE_EVENT0("impeller", __FUNCTION__);
  auto bitmap = std::make_shared<SkBitmap>();
  SkImageInfo image_info;
 
  switch (atlas.GetType()) {
    case GlyphAtlas::Type::kAlphaBitmap:
      image_info =
          SkImageInfo::MakeA8(SkISize{static_cast<int32_t>(atlas_size.width),
                                      static_cast<int32_t>(atlas_size.height)});
      break;
    case GlyphAtlas::Type::kColorBitmap:
      image_info =
          SkImageInfo::MakeN32Premul(atlas_size.width, atlas_size.height);
      break;
  }
 
  if (!bitmap->tryAllocPixels(image_info)) {
    return nullptr;
  }
 
  auto surface = SkSurfaces::WrapPixels(bitmap->pixmap());
  if (!surface) {
    return nullptr;
  }
  auto canvas = surface->getCanvas();
  if (!canvas) {
    return nullptr;
  }
 
  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
 
  atlas.IterateGlyphs([canvas, has_color](const ScaledFont& scaled_font,
                                          const Glyph& glyph,
                                          const Rect& location) -> bool {
    DrawGlyph(canvas, scaled_font, glyph, location, has_color);
    return true;
  });
 
  return bitmap;
}

◆ CreateAtlasBitmap() [2/2]

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

static

Definition at line 286 of file typographer_context_stb.cc.

                                                                             {
  TRACE_EVENT0("impeller", __FUNCTION__);
 
  size_t bytes_per_pixel = 1;
  if (atlas.GetType() == GlyphAtlas::Type::kColorBitmap &&
      !DISABLE_COLOR_FONT_SUPPORT) {
    bytes_per_pixel = kColorFontBitsPerPixel;
  }
  auto bitmap = std::make_shared<BitmapSTB>(atlas_size.width, atlas_size.height,
                                            bytes_per_pixel);
 
  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
 
  atlas.IterateGlyphs([&bitmap, has_color](const ScaledFont& scaled_font,
                                           const Glyph& glyph,
                                           const Rect& location) -> bool {
    DrawGlyph(bitmap.get(), scaled_font, glyph, location, has_color);
    return true;
  });
 
  return bitmap;
}

◆ CreateBufferPool()

static PoolVMA impeller::CreateBufferPool ( VmaAllocator allocator )

static

Definition at line 55 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;
 
  VmaPool pool = {};
  result = vk::Result{::vmaCreatePool(allocator, &pool_create_info, &pool)};
  if (result != vk::Result::eSuccess) {
    return {};
  }
  return {allocator, pool};
}

◆ 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 126 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 {};
  }
 
  ContextVK::SetDebugName(device, pass.get(),
                          "Compat Render Pass: " + desc.GetLabel());
 
  return pass;
}

◆ CreateDefaultPipeline()

template<typename PipelineT >

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

static

Definition at line 223 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);
}

◆ CreateDepthStencilDescriptor()

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

static

Definition at line 94 of file pipeline_library_mtl.mm.

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

◆ CreateDeviceBuffer()

template<typename T >

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

static

Definition at line 21 of file compute_tessellator.cc.

                                                          {
  DeviceBufferDescriptor desc;
  desc.storage_mode = storage_mode;
  desc.size = sizeof(T);
  auto buffer = context->GetResourceAllocator()->CreateBuffer(desc);
  buffer->SetLabel(label);
  return buffer;
}

◆ CreateGLHandle()

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

static

Definition at line 84 of file reactor_gles.cc.

                                                             {
  GLuint handle = GL_NONE;
  switch (type) {
    case HandleType::kUnknown:
      return std::nullopt;
    case HandleType::kTexture:
      gl.GenTextures(1u, &handle);
      return handle;
    case HandleType::kBuffer:
      gl.GenBuffers(1u, &handle);
      return handle;
    case HandleType::kProgram:
      return gl.CreateProgram();
    case HandleType::kRenderBuffer:
      gl.GenRenderbuffers(1u, &handle);
      return handle;
    case HandleType::kFrameBuffer:
      gl.GenFramebuffers(1u, &handle);
      return handle;
  }
  return std::nullopt;
}

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

◆ CreateGradientColors()

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

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

Parameters

colors
stops

Returns: StopData

Definition at line 45 of file gradient_generator.cc.

                                                                           {
  FML_DCHECK(stops.size() == colors.size());
 
  std::vector<StopData> result(stops.size());
  for (auto i = 0u; i < stops.size(); i++) {
    result[i] = {.color = colors[i], .stop = stops[i]};
  }
  return result;
}

◆ 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};
  auto texture =
      context->GetResourceAllocator()->CreateTexture(texture_descriptor);
  if (!texture) {
    FML_DLOG(ERROR) << "Could not create Impeller texture.";
    return nullptr;
  }
 
  auto mapping = std::make_shared<fml::DataMapping>(gradient_data.color_bytes);
  if (!texture->SetContents(mapping)) {
    FML_DLOG(ERROR) << "Could not copy contents into Impeller texture.";
    return nullptr;
  }
  texture->SetLabel(impeller::SPrintF("Gradient(%p)", texture.get()).c_str());
  return texture;
}

◆ CreateMappingFromAllocation()

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

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(),                                    //
      [allocation](auto, auto) {}                                 //
  );
}

◆ CreateMappingWithCopy()

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

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);
 
  return CreateMappingFromAllocation(allocation);
}

◆ CreateMappingWithString() [1/2]

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

◆ CreateMappingWithString() [2/2]

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

Definition at line 111 of file allocation.cc.

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

◆ CreateMetalCommandQueue()

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

static

Definition at line 212 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;
}

◆ CreateMetalDevice()

static id< MTLDevice > impeller::CreateMetalDevice ( )

static

Definition at line 208 of file context_mtl.mm.

                                         {
  return ::MTLCreateSystemDefaultDevice();
}

◆ 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 35 of file pipeline.cc.

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

◆ CreatePipelineFuture() [2/2]

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

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

◆ CreateRenderTarget() [1/2]

static std::unique_ptr< EntityPassTarget > impeller::CreateRenderTarget	(	ContentContext &	renderer,
		ISize	size,
		int	mip_count,
		const Color &	clear_color
	)

static

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

Definition at line 33 of file experimental_canvas.cc.

                              {
  const std::shared_ptr<Context>& context = renderer.GetContext();
 
  /// All of the load/store actions are managed by `InlinePassContext` when
  /// `RenderPasses` are created, so we just set them to `kDontCare` here.
  /// What's important is the `StorageMode` of the textures, which cannot be
  /// changed for the lifetime of the textures.
 
  if (context->GetBackendType() == Context::BackendType::kOpenGLES) {
    // TODO(https://github.com/flutter/flutter/issues/141732): Implement mip map
    // generation on opengles.
    mip_count = 1;
  }
 
  RenderTarget target;
  if (context->GetCapabilities()->SupportsOffscreenMSAA()) {
    target = renderer.GetRenderTargetCache()->CreateOffscreenMSAA(
        /*context=*/*context,
        /*size=*/size,
        /*mip_count=*/mip_count,
        /*label=*/"EntityPass",
        /*color_attachment_config=*/
        RenderTarget::AttachmentConfigMSAA{
            .storage_mode = StorageMode::kDeviceTransient,
            .resolve_storage_mode = StorageMode::kDevicePrivate,
            .load_action = LoadAction::kDontCare,
            .store_action = StoreAction::kMultisampleResolve,
            .clear_color = clear_color},
        /*stencil_attachment_config=*/
        kDefaultStencilConfig);
  } else {
    target = renderer.GetRenderTargetCache()->CreateOffscreen(
        *context,  // context
        size,      // size
        /*mip_count=*/mip_count,
        "EntityPass",  // label
        RenderTarget::AttachmentConfig{
            .storage_mode = StorageMode::kDevicePrivate,
            .load_action = LoadAction::kDontCare,
            .store_action = StoreAction::kDontCare,
            .clear_color = clear_color,
        },                     // color_attachment_config
        kDefaultStencilConfig  // stencil_attachment_config
    );
  }
 
  return std::make_unique<EntityPassTarget>(
      target, renderer.GetDeviceCapabilities().SupportsReadFromResolve(),
      renderer.GetDeviceCapabilities().SupportsImplicitResolvingMSAA());
}

◆ CreateRenderTarget() [2/2]

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

static

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

Definition at line 298 of file entity_pass.cc.

                                                                     {
  const std::shared_ptr<Context>& context = renderer.GetContext();
 
  /// All of the load/store actions are managed by `InlinePassContext` when
  /// `RenderPasses` are created, so we just set them to `kDontCare` here.
  /// What's important is the `StorageMode` of the textures, which cannot be
  /// changed for the lifetime of the textures.
 
  if (context->GetBackendType() == Context::BackendType::kOpenGLES) {
    // TODO(https://github.com/flutter/flutter/issues/141732): Implement mip map
    // generation on opengles.
    mip_count = 1;
  }
 
  RenderTarget target;
  if (context->GetCapabilities()->SupportsOffscreenMSAA()) {
    target = renderer.GetRenderTargetCache()->CreateOffscreenMSAA(
        /*context=*/*context,
        /*size=*/size,
        /*mip_count=*/mip_count,
        /*label=*/"EntityPass",
        /*color_attachment_config=*/
        RenderTarget::AttachmentConfigMSAA{
            .storage_mode = StorageMode::kDeviceTransient,
            .resolve_storage_mode = StorageMode::kDevicePrivate,
            .load_action = LoadAction::kDontCare,
            .store_action = StoreAction::kMultisampleResolve,
            .clear_color = clear_color},
        /*stencil_attachment_config=*/
        kDefaultStencilConfig);
  } else {
    target = renderer.GetRenderTargetCache()->CreateOffscreen(
        *context,  // context
        size,      // size
        /*mip_count=*/mip_count,
        "EntityPass",  // label
        RenderTarget::AttachmentConfig{
            .storage_mode = StorageMode::kDevicePrivate,
            .load_action = LoadAction::kDontCare,
            .store_action = StoreAction::kDontCare,
            .clear_color = clear_color,
        },                     // color_attachment_config
        kDefaultStencilConfig  // stencil_attachment_config
    );
  }
 
  return EntityPassTarget(
      target, renderer.GetDeviceCapabilities().SupportsReadFromResolve(),
      renderer.GetDeviceCapabilities().SupportsImplicitResolvingMSAA());
}

◆ CreateSampler()

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

static

Definition at line 13 of file sampler_vk.cc.

                                                          {
  const auto mip_map = ToVKSamplerMipmapMode(desc.mip_filter);
 
  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.mipmapMode = mip_map;
  sampler_info.maxLod = VK_LOD_CLAMP_NONE;
 
  if (yuv_conversion && yuv_conversion->IsValid()) {
    sampler_chain.get<vk::SamplerYcbcrConversionInfo>().conversion =
        yuv_conversion->GetConversion();
 
    //
    // TL;DR: When using YUV conversion, our samplers are somewhat hobbled and
    // not all options configurable in Impeller (especially the linear
    // filtering which is by far the most used form of filtering) can be
    // supported. Switch to safe defaults.
    //
    // 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.
    //
    // Thing is, we don't enable separate reconstruction filters. By the time we
    // are here, we also don't have access to the descriptor used to create this
    // conversion. So we don't yet know what the chromaFilter is. But eNearest
    // is a safe bet since the `AndroidHardwareBufferTextureSourceVK` defaults
    // to that safe value. So just use that.
    //
    // See the validation VUID-VkSamplerCreateInfo-minFilter-01645 for more.
    //
    sampler_info.magFilter = vk::Filter::eNearest;
    sampler_info.minFilter = vk::Filter::eNearest;
 
    // 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.c_str());
  }
 
  return std::move(sampler.value);
}

◆ CreateTextureForDecompressedImage()

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

static

Definition at line 398 of file playground.cc.

                            {
  auto texture_descriptor = TextureDescriptor{};
  texture_descriptor.storage_mode = StorageMode::kHostVisible;
  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 uploaded = texture->SetContents(decompressed_image.GetAllocation());
  if (!uploaded) {
    VALIDATION_LOG << "Could not upload texture to device memory for fixture.";
    return nullptr;
  }
  if (enable_mipmapping) {
    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();
    blit_pass->SetLabel("Mipmap Blit Pass");
    blit_pass->GenerateMipmap(texture);
    blit_pass->EncodeCommands(context->GetResourceAllocator());
    if (!context->GetCommandQueue()->Submit({command_buffer}).ok()) {
      FML_DLOG(ERROR) << "Failed to submit blit pass command buffer.";
      return nullptr;
    }
  }
  return texture;
}

◆ CreateTextureFromDrawableFuture()

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

Create a TextureMTL from a deferred drawable.

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

Definition at line 41 of file lazy_drawable_holder.mm.

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

◆ CreateUniformMemberKey() [1/2]

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

static

Definition at line 84 of file buffer_bindings_gles.cc.

                                        {
  return NormalizeUniformKey(non_struct_member);
}

◆ CreateUniformMemberKey() [2/2]

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

static

Definition at line 68 of file buffer_bindings_gles.cc.

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

◆ CreateVKImageView()

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

static

Definition at line 170 of file ahb_texture_source_vk.cc.

                                          {
  const auto& ahb_format =
      ahb_props.get<vk::AndroidHardwareBufferFormatPropertiesANDROID>();
 
  vk::StructureChain<vk::ImageViewCreateInfo,
                     // Core in 1.1
                     vk::SamplerYcbcrConversionInfo>
      view_chain;
 
  auto& view_info = view_chain.get();
 
  view_info.image = image;
  view_info.viewType = vk::ImageViewType::e2D;
  view_info.format = ahb_format.format;
  view_info.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
  view_info.subresourceRange.baseMipLevel = 0u;
  view_info.subresourceRange.baseArrayLayer = 0u;
  view_info.subresourceRange.levelCount =
      (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE)
          ? ISize{ahb_desc.width, ahb_desc.height}.MipCount()
          : 1u;
  view_info.subresourceRange.layerCount = ahb_desc.layers;
 
  // We need a custom YUV conversion only if we don't recognize the format.
  if (view_info.format == vk::Format::eUndefined) {
    view_chain.get<vk::SamplerYcbcrConversionInfo>().conversion =
        yuv_conversion;
  } else {
    view_chain.unlink<vk::SamplerYcbcrConversionInfo>();
  }
 
  auto image_view = device.createImageViewUnique(view_info);
  if (image_view.result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not create external image view: "
                   << vk::to_string(image_view.result);
    return {};
  }
 
  return std::move(image_view.value);
}

◆ CreateVKImageWrapperForAndroidHarwareBuffer()

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

static

Definition at line 20 of file ahb_texture_source_vk.cc.

                                          {
  const auto& ahb_format =
      ahb_props.get<vk::AndroidHardwareBufferFormatPropertiesANDROID>();
 
  vk::StructureChain<vk::ImageCreateInfo,
                     // For VK_KHR_external_memory
                     vk::ExternalMemoryImageCreateInfo,
                     // For VK_ANDROID_external_memory_android_hardware_buffer
                     vk::ExternalFormatANDROID>
      image_chain;
 
  auto& image_info = image_chain.get<vk::ImageCreateInfo>();
 
  vk::ImageUsageFlags image_usage_flags;
  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE) {
    image_usage_flags |= vk::ImageUsageFlagBits::eSampled;
  }
  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER) {
    image_usage_flags |= vk::ImageUsageFlagBits::eColorAttachment;
  }
 
  vk::ImageCreateFlags image_create_flags;
  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT) {
    image_create_flags |= vk::ImageCreateFlagBits::eProtected;
  }
  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP) {
    image_create_flags |= vk::ImageCreateFlagBits::eCubeCompatible;
  }
 
  image_info.imageType = vk::ImageType::e2D;
  image_info.format = ahb_format.format;
  image_info.extent.width = ahb_desc.width;
  image_info.extent.height = ahb_desc.height;
  image_info.extent.depth = 1;
  image_info.mipLevels =
      (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE)
          ? ISize{ahb_desc.width, ahb_desc.height}.MipCount()
          : 1u;
  image_info.arrayLayers = ahb_desc.layers;
  image_info.samples = vk::SampleCountFlagBits::e1;
  image_info.tiling = vk::ImageTiling::eOptimal;
  image_info.usage = image_usage_flags;
  image_info.flags = image_create_flags;
  image_info.sharingMode = vk::SharingMode::eExclusive;
  image_info.initialLayout = vk::ImageLayout::eUndefined;
 
  image_chain.get<vk::ExternalMemoryImageCreateInfo>().handleTypes =
      vk::ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID;
 
  // If the format isn't natively supported by Vulkan (i.e, be a part of the
  // base vkFormat enum), an untyped "external format" must be specified when
  // creating the image and the image views. Usually includes YUV formats.
  if (ahb_format.format == vk::Format::eUndefined) {
    image_chain.get<vk::ExternalFormatANDROID>().externalFormat =
        ahb_format.externalFormat;
  } else {
    image_chain.unlink<vk::ExternalFormatANDROID>();
  }
 
  auto image = device.createImageUnique(image_chain.get());
  if (image.result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not create image for external buffer: "
                   << vk::to_string(image.result);
    return {};
  }
 
  return std::move(image.value);
}

◆ CreateYUVConversion()

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

static

Definition at line 136 of file ahb_texture_source_vk.cc.

                                    {
  YUVConversionDescriptorVK conversion_chain;
 
  const auto& ahb_format =
      ahb_props.get<vk::AndroidHardwareBufferFormatPropertiesANDROID>();
 
  auto& conversion_info = conversion_chain.get();
 
  conversion_info.format = ahb_format.format;
  conversion_info.ycbcrModel = ahb_format.suggestedYcbcrModel;
  conversion_info.ycbcrRange = ahb_format.suggestedYcbcrRange;
  conversion_info.components = ahb_format.samplerYcbcrConversionComponents;
  conversion_info.xChromaOffset = ahb_format.suggestedXChromaOffset;
  conversion_info.yChromaOffset = ahb_format.suggestedYChromaOffset;
  // If the potential format features of the sampler Y′CBCR conversion do not
  // support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
  // chromaFilter must not be VK_FILTER_LINEAR.
  //
  // Since we are not checking, let's just default to a safe value.
  conversion_info.chromaFilter = vk::Filter::eNearest;
  conversion_info.forceExplicitReconstruction = false;
 
  if (conversion_info.format == vk::Format::eUndefined) {
    auto& external_format = conversion_chain.get<vk::ExternalFormatANDROID>();
    external_format.externalFormat = ahb_format.externalFormat;
  } else {
    conversion_chain.unlink<vk::ExternalFormatANDROID>();
  }
 
  return context.GetYUVConversionLibrary()->GetConversion(conversion_chain);
}

◆ CubicPathBoundingPopulateValues()

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

static

Definition at line 200 of file path_component.cc.

                                                       {
  const Scalar a = 3.0 * (-p1 + 3.0 * p2 - 3.0 * p3 + p4);
  const Scalar b = 6.0 * (p1 - 2.0 * p2 + p3);
  const Scalar c = 3.0 * (p2 - p1);
 
  /*
   *  Boundary conditions.
   */
  if (NearZero(a)) {
    if (NearZero(b)) {
      return;
    }
 
    Scalar t = -c / b;
    if (t >= 0.0 && t <= 1.0) {
      values.emplace_back(t);
    }
    return;
  }
 
  Scalar b2Minus4AC = (b * b) - (4.0 * a * c);
 
  if (b2Minus4AC < 0.0) {
    return;
  }
 
  Scalar rootB2Minus4AC = ::sqrt(b2Minus4AC);
 
  /* From Numerical Recipes in C.
   *
   * q = -1/2 (b + sign(b) sqrt[b^2 - 4ac])
   * x1 = q / a
   * x2 = c / q
   */
  Scalar q = (b < 0) ? -(b - rootB2Minus4AC) / 2 : -(b + rootB2Minus4AC) / 2;
 
  {
    Scalar t = q / a;
    if (t >= 0.0 && t <= 1.0) {
      values.emplace_back(t);
    }
  }
 
  {
    Scalar t = c / q;
    if (t >= 0.0 && t <= 1.0) {
      values.emplace_back(t);
    }
  }
}

◆ CubicSolve()

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

inlinestatic

Definition at line 35 of file path_component.cc.

                                           {
  return (1 - t) * (1 - t) * (1 - t) * p0 +  //
         3 * (1 - t) * (1 - t) * t * p1 +    //
         3 * (1 - t) * t * t * p2 +          //
         t * t * t * p3;
}

◆ CubicSolveDerivative()

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

inlinestatic

Definition at line 46 of file path_component.cc.

                                                     {
  return -3 * p0 * (1 - t) * (1 - t) +  //
         p1 * (3 * (1 - t) * (1 - t) - 6 * (1 - t) * t) +
         p2 * (6 * (1 - t) * t - 3 * t * t) +  //
         3 * p3 * t * t;
}

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

◆ DecorateCacheWithMetadata()

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

static

Definition at line 24 of file pipeline_cache_vk.cc.

                                    {
  return data;
}

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

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

◆ DefaultUniformAlignment()

constexpr size_t impeller::DefaultUniformAlignment ( )

constexpr

Definition at line 15 of file platform.h.

                                           {
#if FML_OS_IOS && !TARGET_OS_SIMULATOR
  return 16u;
#else
  return 256u;
#endif
}

◆ DeleteFBO()

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

static

Definition at line 16 of file blit_command_gles.cc.

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

◆ 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();
}

◆ DescribeFramebufferAttachment()

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

static

Definition at line 242 of file proc_table_gles.cc.

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

◆ 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 166 of file tessellator_libtess.cc.

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

◆ DestroyVertices()

IMPELLER_API void impeller::DestroyVertices ( Vertices * vertices )

Definition at line 76 of file tessellator.cc.

                                         {
  delete vertices->points;
  delete vertices;
}

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

◆ DetermineIfES()

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

static

Definition at line 39 of file description_gles.cc.

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

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

◆ DeviceHasUnifiedMemoryArchitecture()

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

static

Definition at line 37 of file allocator_mtl.mm.

                                                                     {
  if (@available(ios 13.0, tvos 13.0, macOS 10.15, *)) {
    return [device hasUnifiedMemory];
  } else {
#if FML_OS_IOS
    // iOS devices where the availability check can fail always have had UMA.
    return true;
#else
    // Mac devices where the availability check can fail have never had UMA.
    return false;
#endif
  }
  FML_UNREACHABLE();
}

◆ DeviceMaxTextureSizeSupported()

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

static

Definition at line 52 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 (@available(macOS 10.15, iOS 13, tvOS 13, *)) {
    if ([device supportsFamily:MTLGPUFamilyApple3] ||
        [device supportsFamily:MTLGPUFamilyMacCatalyst1] ||
        [device supportsFamily:MTLGPUFamilyMac1]) {
      return {16384, 16384};
    }
    return {8192, 8192};
  } else {
#if FML_OS_IOS
    if ([device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily4_v1] ||
        [device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily3_v1]) {
      return {16384, 16384};
    }
#endif
#if FML_OS_MACOSX
    return {16384, 16384};
#endif
    return {8192, 8192};
  }
}

◆ DeviceSupportsComputeSubgroups()

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

static

Definition at line 42 of file context_mtl.mm.

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

◆ DeviceSupportsDeviceTransientTargets()

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

static

Definition at line 16 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
  if (@available(ios 13.0, tvos 13.0, macos 10.15, *)) {
    return [device supportsFamily:MTLGPUFamilyApple2];
  } else {
#if FML_OS_IOS
    // This is perhaps redundant. But, just in case we somehow get into a case
    // where Impeller runs on iOS versions less than 8.0 and/or without A8
    // GPUs, we explicitly check feature set support.
    return [device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily2_v1];
#else
    // MacOS devices with Apple GPUs are only available with macos 10.15 and
    // above. So, if we are here, it is safe to assume that memory-less targets
    // are not supported.
    return false;
#endif
  }
  FML_UNREACHABLE();
}

◆ DeviceSupportsFramebufferFetch()

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

static

Definition at line 22 of file context_mtl.mm.

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

◆ DeviceTypeToString()

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

constexpr

Definition at line 75 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();
}

◆ DoColorBlend()

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

inlinestaticconstexpr

Definition at line 216 of file color.cc.

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

◆ DoColorBlendComponents()

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

inlinestaticconstexpr

Definition at line 224 of file color.cc.

                                                           {
  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();
}

◆ DrawGlyph() [1/2]

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

static

Definition at line 194 of file typographer_context_stb.cc.

                                      {
  const auto& metrics = scaled_font.font.GetMetrics();
 
  const impeller::Font& font = scaled_font.font;
  auto typeface = font.GetTypeface();
  // We downcast to the correct typeface type to access `stb` specific methods
  std::shared_ptr<TypefaceSTB> typeface_stb =
      std::reinterpret_pointer_cast<TypefaceSTB>(typeface);
  // Conversion factor to scale font size in Points to pixels.
  // Note this assumes typical DPI.
  float text_size_pixels = metrics.point_size * TypefaceSTB::kPointsToPixels;
  float scale_y = stbtt_ScaleForMappingEmToPixels(typeface_stb->GetFontInfo(),
                                                  text_size_pixels);
  float scale_x = scale_y;
 
  auto output = bitmap->GetPixelAddress({static_cast<size_t>(location.GetX()),
                                         static_cast<size_t>(location.GetY())});
  // For Alpha and Signed Distance field bitmaps we can use STB to draw the
  // Glyph in place
  if (!has_color || DISABLE_COLOR_FONT_SUPPORT) {
    stbtt_MakeGlyphBitmap(typeface_stb->GetFontInfo(), output,
                          location.GetWidth(), location.GetHeight(),
                          bitmap->GetRowBytes(), scale_x, scale_y, glyph.index);
  } else {
    // But for color bitmaps we need to get the glyph pixels and then carry all
    // channels into the atlas bitmap. This may not be performant but I'm unsure
    // of any other approach currently.
    int glyph_bitmap_width = 0;
    int glyph_bitmap_height = 0;
    int glyph_bitmap_xoff = 0;
    int glyph_bitmap_yoff = 0;
    auto glyph_pixels = stbtt_GetGlyphBitmap(
        typeface_stb->GetFontInfo(), scale_x, scale_y, glyph.index,
        &glyph_bitmap_width, &glyph_bitmap_height, &glyph_bitmap_xoff,
        &glyph_bitmap_yoff);
 
    uint8_t* write_pos = output;
    for (auto y = 0; y < glyph_bitmap_height; ++y) {
      for (auto x = 0; x < glyph_bitmap_width; ++x) {
        // Color bitmaps write as White (i.e. what is 0 in an alpha bitmap is
        // 255 in a color bitmap) But not alpha. Alpha still carries
        // transparency info in the normal way.
        // There's some issue with color fonts, in that if the pixel color is
        // nonzero, the alpha is ignored during rendering. That is, partially
        // (or fully) transparent pixels with nonzero color are rendered as
        // fully opaque.
        uint8_t a = glyph_pixels[x + y * glyph_bitmap_width];
        uint8_t c = 255 - a;
 
        // Red channel
        *write_pos = c;
        write_pos++;
        // Green channel
        *write_pos = c;
        write_pos++;
        // Blue channel
        *write_pos = c;
        write_pos++;
        // Alpha channel
        *write_pos = a;
        write_pos++;
      }
      // next row
      write_pos = output + (y * bitmap->GetRowBytes());
    }
    stbtt_FreeBitmap(glyph_pixels, nullptr);
  }
}

◆ DrawGlyph() [2/2]

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

static

Definition at line 157 of file typographer_context_skia.cc.

                                      {
  const auto& metrics = scaled_font.font.GetMetrics();
  const auto position = SkPoint::Make(location.GetX() / scaled_font.scale,
                                      location.GetY() / scaled_font.scale);
  SkGlyphID glyph_id = 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);
 
  auto glyph_color = has_color ? SK_ColorWHITE : SK_ColorBLACK;
 
  SkPaint glyph_paint;
  glyph_paint.setColor(glyph_color);
  canvas->resetMatrix();
  canvas->scale(scaled_font.scale, scaled_font.scale);
  canvas->drawGlyphs(1u,         // count
                     &glyph_id,  // glyphs
                     &position,  // positions
                     SkPoint::Make(-glyph.bounds.GetLeft(),
                                   -glyph.bounds.GetTop()),  // origin
                     sk_font,                                // font
                     glyph_paint                             // paint
  );
}

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

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

◆ EmptyFeedback()

static vk::PipelineCreationFeedbackEXT impeller::EmptyFeedback ( )

static

Definition at line 21 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 RenderPassData &	pass_data,
		const std::shared_ptr< Allocator > &	transients_allocator,
		const ReactorGLES &	reactor,
		const std::vector< Command > &	commands,
		const std::shared_ptr< GPUTracerGLES > &	tracer
	)

Configure blending.

Setup stencil.

Configure depth.

Setup the viewport.

Setup the scissor rect.

Setup culling.

Setup winding order.

Bind vertex and index buffers.

Bind the pipeline program.

Bind vertex attribs.

Bind uniform data.

Determine the primitive type.

Finally! Invoke the draw call.

Unbind vertex attribs.

Unbind the program pipeline.

Definition at line 144 of file render_pass_gles.cc.

                                                {
  TRACE_EVENT0("impeller", "RenderPassGLES::EncodeCommandsInReactor");
 
  const auto& gl = reactor.GetProcTable();
#ifdef IMPELLER_DEBUG
  tracer->MarkFrameStart(gl);
#endif  // IMPELLER_DEBUG
 
  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();
  }
 
  GLuint fbo = GL_NONE;
  fml::ScopedCleanupClosure delete_fbo([&gl, &fbo]() {
    if (fbo != GL_NONE) {
      gl.BindFramebuffer(GL_FRAMEBUFFER, GL_NONE);
      gl.DeleteFramebuffers(1u, &fbo);
    }
  });
 
  TextureGLES& color_gles = TextureGLES::Cast(*pass_data.color_attachment);
  const bool is_default_fbo = color_gles.IsWrapped();
 
  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.
    gl.GenFramebuffers(1u, &fbo);
    gl.BindFramebuffer(GL_FRAMEBUFFER, fbo);
 
    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 frambuffer: "
                     << 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;
  }
 
  gl.Disable(GL_SCISSOR_TEST);
  gl.Disable(GL_DEPTH_TEST);
  gl.Disable(GL_STENCIL_TEST);
  gl.Disable(GL_CULL_FACE);
  gl.Disable(GL_BLEND);
  gl.ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  gl.DepthMask(GL_TRUE);
  gl.StencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
  gl.StencilMaskSeparate(GL_BACK, 0xFFFFFFFF);
 
  gl.Clear(clear_bits);
 
  for (const auto& command : commands) {
    if (command.instance_count != 1u) {
      VALIDATION_LOG << "GLES backend does not support instanced rendering.";
      return false;
    }
 
    if (!command.pipeline) {
      VALIDATION_LOG << "Command has no pipeline specified.";
      return false;
    }
 
#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);
    }
 
    // 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.
    auto target_size = pass_data.color_attachment->GetSize();
 
    //--------------------------------------------------------------------------
    /// Setup the viewport.
    ///
    const auto& viewport = command.viewport.value_or(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);
      }
    }
 
    //--------------------------------------------------------------------------
    /// 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
      );
    } else {
      gl.Disable(GL_SCISSOR_TEST);
    }
 
    //--------------------------------------------------------------------------
    /// Setup culling.
    ///
    switch (pipeline.GetDescriptor().GetCullMode()) {
      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;
    }
    //--------------------------------------------------------------------------
    /// Setup winding order.
    ///
    switch (pipeline.GetDescriptor().GetWindingOrder()) {
      case WindingOrder::kClockwise:
        gl.FrontFace(GL_CW);
        break;
      case WindingOrder::kCounterClockwise:
        gl.FrontFace(GL_CCW);
        break;
    }
 
    if (command.vertex_buffer.index_type == IndexType::kUnknown) {
      return false;
    }
 
    auto vertex_desc_gles = pipeline.GetBufferBindings();
 
    //--------------------------------------------------------------------------
    /// Bind vertex and index buffers.
    ///
    auto& vertex_buffer_view = command.vertex_buffer.vertex_buffer;
 
    if (!vertex_buffer_view) {
      return false;
    }
 
    auto vertex_buffer = vertex_buffer_view.buffer;
 
    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 pipeline program.
    ///
    if (!pipeline.BindProgram()) {
      return false;
    }
 
    //--------------------------------------------------------------------------
    /// Bind vertex attribs.
    ///
    if (!vertex_desc_gles->BindVertexAttributes(
            gl, vertex_buffer_view.range.offset)) {
      return false;
    }
 
    //--------------------------------------------------------------------------
    /// Bind uniform data.
    ///
    if (!vertex_desc_gles->BindUniformData(gl,                        //
                                           *transients_allocator,     //
                                           command.vertex_bindings,   //
                                           command.fragment_bindings  //
                                           )) {
      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.
    auto mode = pipeline.GetDescriptor().GetPolygonMode() == PolygonMode::kLine
                    ? GL_LINE_STRIP
                    : ToMode(pipeline.GetDescriptor().GetPrimitiveType());
 
    //--------------------------------------------------------------------------
    /// Finally! Invoke the draw call.
    ///
    if (command.vertex_buffer.index_type == IndexType::kNone) {
      gl.DrawArrays(mode, command.base_vertex,
                    command.vertex_buffer.vertex_count);
    } else {
      // Bind the index buffer if necessary.
      auto index_buffer_view = command.vertex_buffer.index_buffer;
      auto index_buffer = index_buffer_view.buffer;
      const auto& index_buffer_gles = DeviceBufferGLES::Cast(*index_buffer);
      if (!index_buffer_gles.BindAndUploadDataIfNecessary(
              DeviceBufferGLES::BindingType::kElementArrayBuffer)) {
        return false;
      }
      gl.DrawElements(mode,                                           // mode
                      command.vertex_buffer.vertex_count,             // count
                      ToIndexType(command.vertex_buffer.index_type),  // type
                      reinterpret_cast<const GLvoid*>(static_cast<GLsizei>(
                          index_buffer_view.range.offset))  // indices
      );
    }
 
    //--------------------------------------------------------------------------
    /// Unbind vertex attribs.
    ///
    if (!vertex_desc_gles->UnbindVertexAttributes(gl)) {
      return false;
    }
 
    //--------------------------------------------------------------------------
    /// Unbind the program pipeline.
    ///
    if (!pipeline.UnbindProgram()) {
      return false;
    }
  }
 
  if (gl.DiscardFramebufferEXT.IsAvailable()) {
    std::vector<GLenum> attachments;
 
    // TODO(jonahwilliams): 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.push_back(is_default_fbo ? GL_COLOR_EXT
                                           : GL_COLOR_ATTACHMENT0);
    }
    if (pass_data.discard_depth_attachment && angle_safe) {
      attachments.push_back(is_default_fbo ? GL_DEPTH_EXT
                                           : GL_DEPTH_ATTACHMENT);
    }
 
    if (pass_data.discard_stencil_attachment && angle_safe) {
      attachments.push_back(is_default_fbo ? GL_STENCIL_EXT
                                           : GL_STENCIL_ATTACHMENT);
    }
    gl.DiscardFramebufferEXT(GL_FRAMEBUFFER,      // target
                             attachments.size(),  // attachments to discard
                             attachments.data()   // size
    );
  }
 
#ifdef IMPELLER_DEBUG
  if (is_default_fbo) {
    tracer->MarkFrameEnd(gl);
  }
#endif  // IMPELLER_DEBUG
 
  return true;
}

◆ EncodeCommandsInReactor() [2/2]

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

Definition at line 34 of file blit_pass_gles.cc.

                            {
  TRACE_EVENT0("impeller", "BlitPassGLES::EncodeCommandsInReactor");
 
  if (commands.empty()) {
    return true;
  }
 
  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();
  }
 
  for (const auto& command : commands) {
    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();
    }
 
    if (!command->Encode(reactor)) {
      return false;
    }
  }
 
  return true;
}

◆ 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.";
  }
}

◆ 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();
}

◆ FramebufferStatusToString()

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

static

Definition at line 208 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";
}

◆ fromFanIndices()

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

static

Definition at line 22 of file vertices_geometry.cc.

                                        {
  std::vector<uint16_t> unrolled_indices;
 
  // Un-fan index buffer if provided.
  if (indices.size() > 0u) {
    if (indices.size() < 3u) {
      return {};
    }
 
    auto center_point = indices[0];
    for (auto i = 1u; i < indices.size() - 1; i++) {
      unrolled_indices.push_back(center_point);
      unrolled_indices.push_back(indices[i]);
      unrolled_indices.push_back(indices[i + 1]);
    }
  } else {
    if (vertices.size() < 3u) {
      return {};
    }
 
    // If indices were not provided, create an index buffer that unfans
    // triangles instead of re-writing points, colors, et cetera.
    for (auto i = 1u; i < vertices.size() - 1; i++) {
      unrolled_indices.push_back(0);
      unrolled_indices.push_back(i);
      unrolled_indices.push_back(i + 1);
    }
  }
  return unrolled_indices;
}

◆ FromMTLLoadAction()

constexpr LoadAction impeller::FromMTLLoadAction ( MTLLoadAction action )

constexpr

Definition at line 289 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;
}

◆ FromMTLPixelFormat()

constexpr PixelFormat impeller::FromMTLPixelFormat ( MTLPixelFormat format )

constexpr

Definition at line 23 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;
}

◆ FromMTLStoreAction()

constexpr StoreAction impeller::FromMTLStoreAction ( MTLStoreAction action )

constexpr

Definition at line 318 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;
}

◆ FromRGB()

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

inlinestaticconstexpr

Definition at line 192 of file color.cc.

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

◆ GenerateBlurInfo()

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

Definition at line 593 of file gaussian_blur_filter_contents.cc.

                               {
  GaussianBlurPipeline::FragmentShader::KernelSamples result;
  result.sample_count =
      ((2 * parameters.blur_radius) / parameters.step_size) + 1;
 
  // Chop off the last samples if the radius >= 3 where they account for < 1.56%
  // of the result.
  int x_offset = 0;
  if (parameters.blur_radius >= 3) {
    result.sample_count -= 2;
    x_offset = 1;
  }
 
  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] = GaussianBlurPipeline::FragmentShader::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;
}

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

◆ GetDrawableDeferred()

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

Create a deferred drawable from a CAMetalLayer.

Definition at line 23 of file lazy_drawable_holder.mm.

                         {
  auto future =
      std::async(std::launch::deferred, [layer]() -> id<CAMetalDrawable> {
        id<CAMetalDrawable> current_drawable = nil;
        {
          TRACE_EVENT0("impeller", "WaitForNextDrawable");
          current_drawable = [layer nextDrawable];
        }
        if (!current_drawable) {
          VALIDATION_LOG << "Could not acquire current drawable.";
          return nullptr;
        }
        return current_drawable;
      });
  return std::shared_future<id<CAMetalDrawable>>(std::move(future));
}

◆ GetExtensionName() [1/3]

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

static

Definition at line 188 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::kLast:
      return "Unknown";
  }
  FML_UNREACHABLE();
}

◆ GetExtensionName() [2/3]

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

static

Definition at line 169 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();
}

◆ GetExtensionName() [3/3]

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

static

Definition at line 159 of file capabilities_vk.cc.

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

◆ GetFencesForWaitSet()

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

static

Definition at line 82 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;
}

◆ GetFragInfo()

template<typename T >

T::FragInfo * impeller::GetFragInfo ( const Command & command )

Retrieve the [FragInfo] struct data from the provided [command].

Definition at line 31 of file contents_test_helpers.h.

                                                        {
  auto resource = std::find_if(command.fragment_bindings.buffers.begin(),
                               command.fragment_bindings.buffers.end(),
                               [](const BufferAndUniformSlot& data) {
                                 return data.slot.ext_res_0 == 0u ||
                                        data.slot.binding == 64;
                               });
  if (resource == command.fragment_bindings.buffers.end()) {
    return nullptr;
  }
 
  auto data = (resource->view.resource.buffer->OnGetContents() +
               resource->view.resource.range.offset);
  return reinterpret_cast<typename T::FragInfo*>(data);
}

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

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

◆ GetMTLComputePipelineDescriptor()

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

static

Definition at line 84 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;
}

◆ GetMTLRenderPipelineDescriptor()

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

static

Definition at line 28 of file pipeline_library_mtl.mm.

                                                                     {
  auto descriptor = [[MTLRenderPipelineDescriptor alloc] init];
  descriptor.label = @(desc.GetLabel().c_str());
  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);
  }
}

◆ GetQueueCreateInfos()

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

static

Definition at line 63 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;
}

◆ GetShaderClipDepth()

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

static

Definition at line 18 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(entity.GetClipDepth() + 1),
                         0.0f);
}

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

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

◆ GetShaderType()

static ShaderType impeller::GetShaderType ( RuntimeUniformType type )

static

Definition at line 46 of file runtime_effect_contents.cc.

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

◆ GetSupportedDeviceExtensions()

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

static

Definition at line 213 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;
}

◆ GetTextureTypeFromDescriptor()

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

static

Definition at line 45 of file texture_gles.cc.

                                   {
  const auto usage = static_cast<TextureUsageMask>(desc.usage);
  const auto render_target = TextureUsage::kRenderTarget;
  const auto is_msaa = desc.sample_count == SampleCount::kCount4;
  if (usage == render_target && IsDepthStencilFormat(desc.format)) {
    return is_msaa ? TextureGLES::Type::kRenderBufferMultisampled
                   : TextureGLES::Type::kRenderBuffer;
  }
  return is_msaa ? TextureGLES::Type::kTextureMultisampled
                 : TextureGLES::Type::kTexture;
}

◆ GetVertInfo()

template<typename T >

T::VertInfo * impeller::GetVertInfo ( const Command & command )

Retrieve the [VertInfo] struct data from the provided [command].

Definition at line 14 of file contents_test_helpers.h.

                                                        {
  auto resource = std::find_if(command.vertex_bindings.buffers.begin(),
                               command.vertex_bindings.buffers.end(),
                               [](const BufferAndUniformSlot& data) {
                                 return data.slot.ext_res_0 == 0u;
                               });
  if (resource == command.vertex_bindings.buffers.end()) {
    return nullptr;
  }
 
  auto data = (resource->view.resource.buffer->OnGetContents() +
               resource->view.resource.range.offset);
  return reinterpret_cast<typename T::VertInfo*>(data);
}

◆ GetVKClearValues()

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

static

Definition at line 53 of file render_pass_vk.cc.

                                {
  std::vector<vk::ClearValue> clears;
 
  for (const auto& [_, color] : target.GetColorAttachments()) {
    clears.emplace_back(VKClearValueFromColor(color.clear_color));
    if (color.resolve_texture) {
      clears.emplace_back(VKClearValueFromColor(color.clear_color));
    }
  }
 
  const auto& depth = target.GetDepthAttachment();
  const auto& stencil = target.GetStencilAttachment();
 
  if (depth.has_value()) {
    clears.emplace_back(VKClearValueFromDepthStencil(
        stencil ? stencil->clear_stencil : 0u, depth->clear_depth));
  } else if (stencil.has_value()) {
    clears.emplace_back(VKClearValueFromDepthStencil(
        stencil->clear_stencil, depth ? depth->clear_depth : 0.0f));
  }
 
  return clears;
}

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

◆ 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.";
}

◆ GLESShaderNameToShaderKeyName()

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

static

Definition at line 30 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();
}

◆ 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";
  }
  FML_UNREACHABLE();
}

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

◆ HasRequiredProperties()

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

static

Definition at line 311 of file capabilities_vk.cc.

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

◆ HasRequiredQueues()

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

static

Definition at line 320 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));
}

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

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

◆ HasSuitableDepthStencilFormat()

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

static

Definition at line 294 of file capabilities_vk.cc.

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

◆ HasValidationLayers()

bool impeller::HasValidationLayers ( )

Definition at line 48 of file context_vk.cc.

                           {
  return gHasValidationLayers;
}

◆ HeapAlloc()

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

static

Definition at line 11 of file tessellator_libtess.cc.

                                                          {
  return malloc(size);
}

◆ HeapFree()

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

static

Definition at line 19 of file tessellator_libtess.cc.

                                                {
  free(ptr);
}

◆ HeapRealloc()

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

static

Definition at line 15 of file tessellator_libtess.cc.

                                                                       {
  return realloc(ptr, size);
}

◆ IdentifyVendor()

constexpr VendorVK impeller::IdentifyVendor ( uint32_t vendor )

constexpr

Definition at line 14 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;
  }
  // 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;
}

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

Definition at line 48 of file validation.cc.

                                                  {
  std::stringstream stream;
#if FLUTTER_RELEASE
  stream << "Impeller validation: " << message;
#else
  stream << "Break on '" << __FUNCTION__
         << "' to inspect point of failure: " << message;
#endif
  if (sValidationLogsAreFatal > 0) {
    FML_LOG(FATAL) << stream.str();
  } else {
    FML_LOG(ERROR) << stream.str();
  }
}

◆ ImpellerValidationErrorsAreFatal()

bool impeller::ImpellerValidationErrorsAreFatal ( )

Definition at line 63 of file validation.cc.

                                        {
  return sValidationLogsAreFatal;
}

◆ ImpellerValidationErrorsSetFatal()

void impeller::ImpellerValidationErrorsSetFatal ( bool fatal )

Definition at line 16 of file validation.cc.

                                                  {
  sValidationLogsAreFatal = fatal;
}

◆ ImportVKDeviceMemoryFromAndroidHarwareBuffer()

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

static

Definition at line 92 of file ahb_texture_source_vk.cc.

                                    {
  vk::PhysicalDeviceMemoryProperties memory_properties;
  physical_device.getMemoryProperties(&memory_properties);
  int memory_type_index = AllocatorVK::FindMemoryTypeIndex(
      ahb_props.get().memoryTypeBits, memory_properties);
  if (memory_type_index < 0) {
    VALIDATION_LOG << "Could not find memory type of external image.";
    return {};
  }
 
  vk::StructureChain<vk::MemoryAllocateInfo,
                     // Core in 1.1
                     vk::MemoryDedicatedAllocateInfo,
                     // For VK_ANDROID_external_memory_android_hardware_buffer
                     vk::ImportAndroidHardwareBufferInfoANDROID>
      memory_chain;
 
  auto& mem_alloc_info = memory_chain.get<vk::MemoryAllocateInfo>();
  mem_alloc_info.allocationSize = ahb_props.get().allocationSize;
  mem_alloc_info.memoryTypeIndex = memory_type_index;
 
  auto& dedicated_alloc_info =
      memory_chain.get<vk::MemoryDedicatedAllocateInfo>();
  dedicated_alloc_info.image = image;
 
  auto& ahb_import_info =
      memory_chain.get<vk::ImportAndroidHardwareBufferInfoANDROID>();
  ahb_import_info.buffer = hardware_buffer;
 
  auto device_memory = device.allocateMemoryUnique(memory_chain.get());
  if (device_memory.result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not allocate device memory for external image : "
                   << vk::to_string(device_memory.result);
    return {};
  }
 
  return std::move(device_memory.value);
}

◆ InferMetalCapabilities()

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

static

Definition at line 53 of file context_mtl.mm.

                              {
  return CapabilitiesBuilder()
      .SetSupportsOffscreenMSAA(true)
      .SetSupportsSSBO(true)
      .SetSupportsBufferToTextureBlits(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)
      .Build();
}

◆ InferShaderTypefromFileExtension()

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

Definition at line 19 of file shader_archive_writer.cc.

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

◆ InitializeGLFWOnce()

static void impeller::InitializeGLFWOnce ( )

static

Definition at line 56 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);
  });
}

◆ InsertBarrierForInputAttachmentRead()

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

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

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

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

Parameters

[in]	buffer	The buffer
[in]	image	The image

Definition at line 158 of file render_pass_builder_vk.cc.

                                                               {
  // 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                       //
  );
}

◆ 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 18 of file blit_command_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 31 of file blend_filter_contents.cc.

                                                                   {
  switch (blend_mode) {
    case BlendMode::kClear:
      return BlendMode::kClear;
    case BlendMode::kSource:
      return BlendMode::kDestination;
    case BlendMode::kDestination:
      return BlendMode::kSource;
    case BlendMode::kSourceOver:
      return BlendMode::kDestinationOver;
    case BlendMode::kDestinationOver:
      return BlendMode::kSourceOver;
    case BlendMode::kSourceIn:
      return BlendMode::kDestinationIn;
    case BlendMode::kDestinationIn:
      return BlendMode::kSourceIn;
    case BlendMode::kSourceOut:
      return BlendMode::kDestinationOut;
    case BlendMode::kDestinationOut:
      return BlendMode::kSourceOut;
    case BlendMode::kSourceATop:
      return BlendMode::kDestinationATop;
    case BlendMode::kDestinationATop:
      return BlendMode::kSourceATop;
    case BlendMode::kXor:
      return BlendMode::kXor;
    case BlendMode::kPlus:
      return BlendMode::kPlus;
    case BlendMode::kModulate:
      return BlendMode::kModulate;
    default:
      return std::nullopt;
  }
}

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

◆ IPLR_GUARDED_BY()

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

static

◆ IsDepthStencilFormat()

static bool impeller::IsDepthStencilFormat ( PixelFormat format )

static

Definition at line 21 of file texture_gles.cc.

                                                     {
  switch (format) {
    case PixelFormat::kS8UInt:
    case PixelFormat::kD24UnormS8Uint:
    case PixelFormat::kD32FloatS8UInt:
      return true;
    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;
  }
  FML_UNREACHABLE();
}

◆ IsDepthWritable()

constexpr bool impeller::IsDepthWritable ( PixelFormat format )

constexpr

Definition at line 120 of file formats.h.

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

◆ IsExtensionInList()

template<class ExtensionEnum >

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

static

Definition at line 335 of file capabilities_vk.cc.

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

◆ IsMappingSPIRV()

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

static

Definition at line 118 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 284 of file formats.h.

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

◆ IsStencilWritable()

constexpr bool impeller::IsStencilWritable ( PixelFormat format )

constexpr

Definition at line 130 of file formats.h.

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

◆ IterateExtensions()

template<class T >

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

static

Definition at line 201 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 VkDebugUtilsLabelEXT *	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 VkDebugUtilsObjectNameInfoEXT *	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(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();
}

◆ LerpHackKernelSamples()

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

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

Definition at line 629 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;
  for (int i = 0; i < result.sample_count; i++) {
    if (i == middle) {
      result.samples[i] = parameters.samples[j++];
    } else {
      GaussianBlurPipeline::FragmentShader::KernelSample left =
          parameters.samples[j];
      GaussianBlurPipeline::FragmentShader::KernelSample right =
          parameters.samples[j + 1];
      result.samples[i] = GaussianBlurPipeline::FragmentShader::KernelSample{
          .uv_offset = (left.uv_offset * left.coefficient +
                        right.uv_offset * right.coefficient) /
                       (left.coefficient + right.coefficient),
          .coefficient = left.coefficient + right.coefficient,
      };
      j += 2;
    }
  }
 
  return result;
}

◆ LinearSolve()

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

inlinestatic

Definition at line 17 of file path_component.cc.

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

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

◆ 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().c_str()));
  gl.SetDebugLabel(
      DebugResourceType::kShader, frag_shader,
      SPrintF("%s Fragment Shader", descriptor.GetLabel().c_str()));
 
  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);
    return false;
  }
  return true;
}

◆ LoadActionToString()

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

constexpr

Definition at line 216 of file formats.h.

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

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

◆ LogShaderCompilationFailure()

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

static

Definition at line 49 of file pipeline_library_gles.cc.

                                                           {
  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();
}

◆ Luminosity()

static constexpr Scalar impeller::Luminosity ( Vector3 color )

inlinestaticconstexpr

Definition at line 140 of file color.cc.

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

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

◆ MAKE_STROKE_BENCHMARK_CAPTURE()

impeller::MAKE_STROKE_BENCHMARK_CAPTURE	(	RRect	,
		Butt	,
		Bevel
	)

◆ MakeShaderMetadata()

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

static

Definition at line 57 of file runtime_effect_contents.cc.

                                              {
  auto metadata = std::make_shared<ShaderMetadata>();
  metadata->name = uniform.name;
  metadata->members.emplace_back(ShaderStructMemberMetadata{
      .type = GetShaderType(uniform.type),
      .size = uniform.GetSize(),
      .byte_length = uniform.bit_width / 8,
  });
 
  return metadata;
}

◆ MakeSharedVK()

template<class T >

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

Definition at line 43 of file shared_object_vk.h.

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

◆ MakeTextFrameFromTextBlobSkia()

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

Definition at line 41 of file text_frame_skia.cc.

                                   {
  bool has_color = false;
  std::vector<TextRun> runs;
  for (SkTextBlobRunIterator run(blob.get()); !run.done(); run.next()) {
    // TODO(jonahwilliams): ask Skia for a public API to look this up.
    // https://github.com/flutter/flutter/issues/112005
    SkStrikeSpec strikeSpec = SkStrikeSpec::MakeWithNoDevice(run.font());
    SkBulkGlyphMetricsAndPaths paths{strikeSpec};
 
    const auto glyph_count = run.glyphCount();
    const auto* glyphs = run.glyphs();
    switch (run.positioning()) {
      case SkTextBlobRunIterator::kFull_Positioning: {
        std::vector<SkRect> glyph_bounds;
        glyph_bounds.resize(glyph_count);
        SkFont font = run.font();
        auto font_size = font.getSize();
        // For some platforms (including Android), `SkFont::getBounds()` snaps
        // the computed bounds to integers. And so we scale up the font size
        // prior to fetching the bounds to ensure that the returned bounds are
        // always precise enough.
        font.setSize(kScaleSize);
        font.getBounds(glyphs, glyph_count, glyph_bounds.data(), nullptr);
 
        std::vector<TextRun::GlyphPosition> positions;
        positions.reserve(glyph_count);
        for (auto i = 0u; i < glyph_count; i++) {
          // kFull_Positioning has two scalars per glyph.
          const SkPoint* glyph_points = run.points();
          const auto* point = glyph_points + i;
          Glyph::Type type = paths.glyph(glyphs[i])->isColor()
                                 ? Glyph::Type::kBitmap
                                 : Glyph::Type::kPath;
          has_color |= type == Glyph::Type::kBitmap;
 
          positions.emplace_back(TextRun::GlyphPosition{
              Glyph{glyphs[i], type,
                    ToRect(glyph_bounds[i]).Scale(font_size / kScaleSize)},
              Point{point->x(), point->y()}});
        }
        TextRun text_run(ToFont(run), positions);
        runs.emplace_back(text_run);
        break;
      }
      default:
        FML_DLOG(ERROR) << "Unimplemented.";
        continue;
    }
  }
  return std::make_shared<TextFrame>(runs, ToRect(blob->bounds()), has_color);
}

◆ MakeTextFrameSTB()

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

Definition at line 11 of file text_frame_stb.cc.

                           {
  TextRun run(Font(typeface_stb, metrics));
 
  // Shape the text run using STB. The glyph positions could also be resolved
  // using a more advanced text shaper such as harfbuzz.
 
  float scale = stbtt_ScaleForMappingEmToPixels(
      typeface_stb->GetFontInfo(),
      metrics.point_size * TypefaceSTB::kPointsToPixels);
 
  int ascent, descent, line_gap;
  stbtt_GetFontVMetrics(typeface_stb->GetFontInfo(), &ascent, &descent,
                        &line_gap);
  ascent = std::round(ascent * scale);
  descent = std::round(descent * scale);
 
  float x = 0;
  for (size_t i = 0; i < text.size(); i++) {
    int glyph_index =
        stbtt_FindGlyphIndex(typeface_stb->GetFontInfo(), text[i]);
 
    int x0, y0, x1, y1;
    stbtt_GetGlyphBitmapBox(typeface_stb->GetFontInfo(), glyph_index, scale,
                            scale, &x0, &y0, &x1, &y1);
    float y = y0;
 
    int advance_width;
    int left_side_bearing;
    stbtt_GetGlyphHMetrics(typeface_stb->GetFontInfo(), glyph_index,
                           &advance_width, &left_side_bearing);
 
    Glyph glyph(glyph_index, Glyph::Type::kPath,
                Rect::MakeXYWH(0, 0, x1 - x0, y1 - y0));
    run.AddGlyph(glyph, {x + (left_side_bearing * scale), y});
 
    if (i + 1 < text.size()) {
      int kerning = stbtt_GetCodepointKernAdvance(typeface_stb->GetFontInfo(),
                                                  text[i], text[i + 1]);
      x += std::round((advance_width + kerning) * scale);
    }
  }
 
  std::optional<Rect> result;
  for (const auto& glyph_position : run.GetGlyphPositions()) {
    Rect glyph_rect = Rect::MakeOriginSize(
        glyph_position.position + glyph_position.glyph.bounds.GetOrigin(),
        glyph_position.glyph.bounds.GetSize());
    result = result.has_value() ? result->Union(glyph_rect) : glyph_rect;
  }
 
  std::vector<TextRun> runs = {run};
  return std::make_shared<TextFrame>(
      runs, result.value_or(Rect::MakeLTRB(0, 0, 0, 0)), false);
}

◆ MakeVertices()

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

Definition at line 31 of file dl_vertices_geometry.cc.

                                       {
  auto bounds = ToRect(vertices->bounds());
  auto mode = ToVertexMode(vertices->mode());
  std::vector<Point> positions(vertices->vertex_count());
  for (auto i = 0; i < vertices->vertex_count(); i++) {
    positions[i] = skia_conversions::ToPoint(vertices->vertices()[i]);
  }
 
  std::vector<uint16_t> indices(vertices->index_count());
  for (auto i = 0; i < vertices->index_count(); i++) {
    indices[i] = vertices->indices()[i];
  }
 
  std::vector<Color> colors;
  if (vertices->colors()) {
    colors.reserve(vertices->vertex_count());
    for (auto i = 0; i < vertices->vertex_count(); i++) {
      colors.push_back(
          skia_conversions::ToColor(vertices->colors()[i]).Premultiply());
    }
  }
  std::vector<Point> texture_coordinates;
  if (vertices->texture_coordinates()) {
    texture_coordinates.reserve(vertices->vertex_count());
    for (auto i = 0; i < vertices->vertex_count(); i++) {
      texture_coordinates.push_back(
          skia_conversions::ToPoint(vertices->texture_coordinates()[i]));
    }
  }
  return std::make_shared<VerticesGeometry>(
      positions, indices, texture_coordinates, colors, bounds, mode);
}

◆ Min()

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

inlinestaticconstexpr

Definition at line 132 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));
}

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

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

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

◆ MTLShaderLibraryFromFilePaths()

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

static

Definition at line 142 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;
}

◆ NearEqual()

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

inlinestatic

Definition at line 192 of file path_component.cc.

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

◆ NearZero()

static bool impeller::NearZero ( Scalar a )

inlinestatic

Definition at line 196 of file path_component.cc.

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

◆ NormalizeUniformKey()

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

static

Definition at line 57 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;
}

◆ OpenCacheFile()

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

static

Definition at line 34 of file pipeline_cache_vk.cc.

                                {
  if (!base_directory.is_valid()) {
    return nullptr;
  }
  std::unique_ptr<fml::Mapping> mapping =
      fml::FileMapping::CreateReadOnly(base_directory, cache_file_name);
  if (!mapping) {
    return nullptr;
  }
  if (!VerifyExistingCache(*mapping, caps)) {
    return nullptr;
  }
  mapping = RemoveMetadataFromCache(std::move(mapping));
  if (!mapping) {
    return nullptr;
  }
  return mapping;
}

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

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

◆ operator*() [2/7]

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

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

constexpr

Definition at line 268 of file point.h.

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

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

◆ operator*() [5/7]

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

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

constexpr

Definition at line 285 of file point.h.

                                                       {
  return p * s;
}

◆ operator*() [6/7]

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

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

constexpr

Definition at line 128 of file size.h.

                                                     {
  return p * s;
}

◆ operator*() [7/7]

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

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

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

◆ operator+() [2/5]

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

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

constexpr

Definition at line 248 of file point.h.

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

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

◆ operator+() [5/5]

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

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

constexpr

Definition at line 214 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 253 of file point.h.

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

◆ operator-() [2/5]

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

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

constexpr

Definition at line 258 of file point.h.

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

◆ operator-() [3/5]

template<class T , class U >

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

constexpr

Definition at line 302 of file point.h.

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

◆ operator-() [4/5]

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

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

inlineconstexpr

Definition at line 895 of file color.h.

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

◆ operator-() [5/5]

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

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

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

◆ operator/() [2/7]

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

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

constexpr

Definition at line 278 of file point.h.

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

◆ operator/() [3/7]

template<class T , class U >

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

constexpr

Definition at line 312 of file point.h.

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

◆ operator/() [4/7]

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

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

inlineconstexpr

Definition at line 906 of file color.h.

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

◆ operator/() [5/7]

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

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

constexpr

Definition at line 290 of file point.h.

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

◆ operator/() [6/7]

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

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

constexpr

Definition at line 133 of file size.h.

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

◆ operator/() [7/7]

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

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

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

◆ OptimumAtlasSizeForFontGlyphPairs() [1/2]

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

static

Definition at line 118 of file typographer_context_skia.cc.

                                   {
  static constexpr auto kMinAtlasSize = 8u;
  static constexpr auto kMinAlphaBitmapSize = 1024u;
 
  TRACE_EVENT0("impeller", __FUNCTION__);
 
  ISize current_size = type == GlyphAtlas::Type::kAlphaBitmap
                           ? ISize(kMinAlphaBitmapSize, kMinAlphaBitmapSize)
                           : ISize(kMinAtlasSize, kMinAtlasSize);
  size_t total_pairs = pairs.size() + 1;
  do {
    auto rect_packer = std::shared_ptr<RectanglePacker>(
        RectanglePacker::Factory(current_size.width, current_size.height));
 
    auto remaining_pairs = PairsFitInAtlasOfSize(pairs, current_size,
                                                 glyph_positions, rect_packer);
    if (remaining_pairs == 0) {
      atlas_context->UpdateRectPacker(rect_packer);
      return current_size;
    } else if (remaining_pairs < std::ceil(total_pairs / 2)) {
      current_size = ISize::MakeWH(
          std::max(current_size.width, current_size.height),
          Allocation::NextPowerOfTwoSize(
              std::min(current_size.width, current_size.height) + 1));
    } else {
      current_size = ISize::MakeWH(
          Allocation::NextPowerOfTwoSize(current_size.width + 1),
          Allocation::NextPowerOfTwoSize(current_size.height + 1));
    }
  } while (current_size.width <= max_texture_size.width &&
           current_size.height <= max_texture_size.height);
  return ISize{0, 0};
}

◆ OptimumAtlasSizeForFontGlyphPairs() [2/2]

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

static

Definition at line 155 of file typographer_context_stb.cc.

                                   {
  static constexpr auto kMinAtlasSize = 8u;
  static constexpr auto kMinAlphaBitmapSize = 1024u;
 
  TRACE_EVENT0("impeller", __FUNCTION__);
 
  ISize current_size = type == GlyphAtlas::Type::kAlphaBitmap
                           ? ISize(kMinAlphaBitmapSize, kMinAlphaBitmapSize)
                           : ISize(kMinAtlasSize, kMinAtlasSize);
  size_t total_pairs = pairs.size() + 1;
  do {
    auto rect_packer = std::shared_ptr<RectanglePacker>(
        RectanglePacker::Factory(current_size.width, current_size.height));
 
    auto remaining_pairs = PairsFitInAtlasOfSize(pairs, current_size,
                                                 glyph_positions, rect_packer);
    if (remaining_pairs == 0) {
      atlas_context->UpdateRectPacker(rect_packer);
      return current_size;
    } else if (remaining_pairs < std::ceil(total_pairs / 2)) {
      current_size = ISize::MakeWH(
          std::max(current_size.width, current_size.height),
          Allocation::NextPowerOfTwoSize(
              std::min(current_size.width, current_size.height) + 1));
    } else {
      current_size = ISize::MakeWH(
          Allocation::NextPowerOfTwoSize(current_size.width + 1),
          Allocation::NextPowerOfTwoSize(current_size.height + 1));
    }
  } while (current_size.width <= max_texture_size.width &&
           current_size.height <= max_texture_size.height);
  return ISize{0, 0};
}

◆ OptionsFromPass()

ContentContextOptions impeller::OptionsFromPass ( const RenderPass & pass )

Definition at line 20 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::kGreater;
  opts.stencil_mode = ContentContextOptions::StencilMode::kIgnore;
  return opts;
}

◆ OptionsFromPassAndEntity()

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

Definition at line 35 of file contents.cc.

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

◆ PairsFitInAtlasOfSize() [1/2]

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

static

Definition at line 45 of file typographer_context_skia.cc.

                                                       {
  if (atlas_size.IsEmpty()) {
    return false;
  }
 
  glyph_positions.clear();
  glyph_positions.reserve(pairs.size());
 
  size_t i = 0;
  for (auto it = pairs.begin(); it != pairs.end(); ++i, ++it) {
    const auto& pair = *it;
 
    const auto glyph_size =
        ISize::Ceil(pair.glyph.bounds.GetSize() * pair.scaled_font.scale);
    IPoint16 location_in_atlas;
    if (!rect_packer->addRect(glyph_size.width + kPadding,   //
                              glyph_size.height + kPadding,  //
                              &location_in_atlas             //
                              )) {
      return pairs.size() - i;
    }
    glyph_positions.emplace_back(Rect::MakeXYWH(location_in_atlas.x(),  //
                                                location_in_atlas.y(),  //
                                                glyph_size.width,       //
                                                glyph_size.height       //
                                                ));
  }
 
  return 0;
}

◆ PairsFitInAtlasOfSize() [2/2]

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

static

Definition at line 44 of file typographer_context_stb.cc.

                                                       {
  if (atlas_size.IsEmpty()) {
    return false;
  }
 
  glyph_positions.clear();
  glyph_positions.reserve(pairs.size());
 
  size_t i = 0;
  for (auto it = pairs.begin(); it != pairs.end(); ++i, ++it) {
    const auto& pair = *it;
    const Font& font = pair.scaled_font.font;
 
    // We downcast to the correct typeface type to access `stb` specific
    // methods.
    std::shared_ptr<TypefaceSTB> typeface_stb =
        std::reinterpret_pointer_cast<TypefaceSTB>(font.GetTypeface());
    // Conversion factor to scale font size in Points to pixels.
    // Note this assumes typical DPI.
    float text_size_pixels =
        font.GetMetrics().point_size * TypefaceSTB::kPointsToPixels;
 
    ISize glyph_size;
    {
      int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
      float scale = stbtt_ScaleForMappingEmToPixels(typeface_stb->GetFontInfo(),
                                                    text_size_pixels);
      stbtt_GetGlyphBitmapBox(typeface_stb->GetFontInfo(), pair.glyph.index,
                              scale, scale, &x0, &y0, &x1, &y1);
 
      glyph_size = ISize(x1 - x0, y1 - y0);
    }
 
    IPoint16 location_in_atlas;
    if (!rect_packer->addRect(glyph_size.width + kPadding,   //
                              glyph_size.height + kPadding,  //
                              &location_in_atlas             //
                              )) {
      return pairs.size() - i;
    }
    glyph_positions.emplace_back(Rect::MakeXYWH(location_in_atlas.x(),  //
                                                location_in_atlas.y(),  //
                                                glyph_size.width,       //
                                                glyph_size.height       //
                                                ));
  }
 
  return 0;
}

◆ PhysicalDeviceSupportsRequiredFormats()

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

static

Definition at line 301 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;
}

◆ PickPhysicalDevice()

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

static

Definition at line 52 of file context_vk.cc.

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

◆ PickQueue()

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

static

Definition at line 86 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;
}

◆ 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 504 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(
        SPrintF("Pipeline Blend Filter (%s)", BlendModeToString(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;
      }
 
      const std::unique_ptr<const Sampler>& sampler =
          renderer.GetContext()->GetSamplerLibrary()->GetSampler(
              input->sampler_descriptor);
      FS::BindTextureSampler(pass, input->texture, sampler);
 
      auto size = input->texture->GetSize();
      VertexBufferBuilder<VS::PerVertexData> vtx_builder;
      vtx_builder.AddVertices({
          {Point(0, 0), Point(0, 0)},
          {Point(size.width, 0), Point(1, 0)},
          {Point(0, size.height), Point(0, 1)},
          {Point(size.width, size.height), Point(1, 1)},
      });
      pass.SetVertexBuffer(vtx_builder.CreateVertexBuffer(host_buffer));
 
      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::kSource;
    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>();
      contents->SetGeometry(
          Geometry::MakeRect(Rect::MakeSize(pass.GetRenderTargetSize())));
      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);
 
  if (!render_target.ok()) {
    return std::nullopt;
  }
 
  if (!renderer.GetContext()
           ->GetCommandQueue()
           ->Submit(/*buffers=*/{std::move(command_buffer)})
           .ok()) {
    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());
}

◆ PixelFormatIsDepthStencil()

constexpr bool impeller::PixelFormatIsDepthStencil ( PixelFormat format )

constexpr

Definition at line 392 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;
}

◆ PixelFormatToString()

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

constexpr

Definition at line 141 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();
}

◆ PlaygroundBackendToRuntimeStageBackend()

constexpr RuntimeStageBackend impeller::PlaygroundBackendToRuntimeStageBackend ( PlaygroundBackend backend )

inlineconstexpr

Definition at line 35 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();
}

◆ PlaygroundBackendToString()

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

Definition at line 44 of file playground.cc.

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

◆ PlaygroundKeyCallback()

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

static

Definition at line 170 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);
  }
}

◆ QuadraticSolve()

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

inlinestatic

Definition at line 21 of file path_component.cc.

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

◆ QuadraticSolveDerivative()

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

inlinestatic

Definition at line 27 of file path_component.cc.

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

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

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

◆ RemoveMetadataFromCache()

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

static

Definition at line 29 of file pipeline_cache_vk.cc.

                                    {
  return data;
}

◆ ReportPipelineCreationFeedback()

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

static

Definition at line 105 of file pipeline_vk.cc.

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

◆ ReportPipelineCreationFeedbackToLog() [1/2]

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

static

Definition at line 57 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();
}

◆ ReportPipelineCreationFeedbackToLog() [2/2]

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

static

Definition at line 40 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();
}

◆ ReportPipelineCreationFeedbackToTrace()

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

static

Definition at line 82 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                  //
  );
}

◆ ResourceIsLive()

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

static

Definition at line 328 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);
  }
  FML_UNREACHABLE();
}

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

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

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

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

◆ Saturation()

static constexpr Scalar impeller::Saturation ( Vector3 color )

inlinestaticconstexpr

Definition at line 166 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);
}

◆ ScalarNearlyEqual()

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

inlineconstexpr

Definition at line 30 of file scalar.h.

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

◆ ScalarNearlyZero()

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

inlineconstexpr

Definition at line 25 of file scalar.h.

                                                                          {
  return Absolute(x) <= tolerance;
}

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

◆ SetClipScissor()

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

static

Definition at line 737 of file entity_pass.cc.

                                                       {
  // Set the scissor to the clip coverage area. We do this prior to rendering
  // the clip itself and all its contents.
  IRect scissor;
  if (clip_coverage.has_value()) {
    clip_coverage = clip_coverage->Shift(-global_pass_position);
    scissor = IRect::RoundOut(clip_coverage.value());
    // The scissor rect must not exceed the size of the render target.
    scissor = scissor.Intersection(IRect::MakeSize(pass.GetRenderTargetSize()))
                  .value_or(IRect());
  }
  pass.SetScissor(scissor);
}

◆ SetLuminosity()

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

inlinestaticconstexpr

Definition at line 160 of file color.cc.

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

◆ SetSaturation()

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

inlinestaticconstexpr

Definition at line 171 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();
}

◆ 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.";
}

◆ 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_imgui_shaders_gles_data, impeller_imgui_shaders_gles_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_scene_shaders_gles_data, impeller_scene_shaders_gles_length),
  };
}

◆ ShaderLibraryMappingsForPlayground() [2/3]

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

static

Definition at line 36 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_imgui_shaders_data,
                                                 impeller_imgui_shaders_length),
          std::make_shared<fml::NonOwnedMapping>(impeller_scene_shaders_data,
                                                 impeller_scene_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_imgui_shaders_vk_data,
                                             impeller_imgui_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(impeller_scene_shaders_vk_data,
                                             impeller_scene_shaders_vk_length),
      std::make_shared<fml::NonOwnedMapping>(
          impeller_compute_shaders_vk_data, impeller_compute_shaders_vk_length),
  };
}

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

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

◆ 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();
}

◆ StorageModeToString()

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

constexpr

Definition at line 61 of file formats.h.

                                                            {
  switch (mode) {
    case StorageMode::kHostVisible:
      return "HostVisible";
    case StorageMode::kDevicePrivate:
      return "DevicePrivate";
    case StorageMode::kDeviceTransient:
      return "DeviceTransient";
  }
  FML_UNREACHABLE();
}

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

◆ StoreActionPerformsResolve()

constexpr bool impeller::StoreActionPerformsResolve ( StoreAction store_action )

constexpr

Definition at line 338 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();
}

◆ StoreActionToString()

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

constexpr

Definition at line 227 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";
  }
}

◆ 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());
}

◆ SupportsLossyTextureCompression()

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

static

Definition at line 80 of file allocator_mtl.mm.

                                                                  {
#ifdef FML_OS_IOS_SIMULATOR
  return false;
#else
  if (@available(macOS 10.15, iOS 13, tvOS 13, *)) {
    return [device supportsFamily:MTLGPUFamilyApple8];
  }
  return false;
#endif
}

◆ Tessellate()

IMPELLER_API struct Vertices * impeller::Tessellate	(	PathBuilder *	builder,
		int	fill_type,
		Scalar	tolerance
	)

Definition at line 42 of file tessellator.cc.

                                              {
  auto path = builder->CopyPath(static_cast<FillType>(fill_type));
  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;
          }) != Tessellator::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;
}

◆ TEST()

impeller::TEST	(	ValidationTest	,
		IsFatal
	)

Definition at line 29 of file main.cc.

                              {
  EXPECT_TRUE(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();
}

◆ TextureTypeToString()

constexpr const char * impeller::TextureTypeToString ( TextureType type )

constexpr

Definition at line 270 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();
}

◆ 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();
}

◆ TextureUsageToString()

constexpr const char * impeller::TextureUsageToString ( TextureUsage usage )

constexpr

Definition at line 311 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();
}

◆ TileModeToAddressMode()

static std::optional< SamplerAddressMode > impeller::TileModeToAddressMode	(	Entity::TileMode	tile_mode,
		const Capabilities &	capabilities
	)

static

Definition at line 15 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;
  }
}

◆ ToAddressMode()

static GLint impeller::ToAddressMode	(	SamplerAddressMode	mode,
		bool	supports_decal_sampler_address_mode
	)

static

Definition at line 50 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();
}

◆ ToArchiveRenderingBackend()

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

constexpr

Definition at line 11 of file multi_arch_shader_archive.cc.

                                {
  switch (backend) {
    case fb::RenderingBackend::kOpenGLES:
      return ArchiveRenderingBackend::kOpenGLES;
    case fb::RenderingBackend::kVulkan:
      return ArchiveRenderingBackend::kVulkan;
    case fb::RenderingBackend::kMetal:
      return ArchiveRenderingBackend::kMetal;
  }
  FML_UNREACHABLE();
}

◆ ToArrayLayerCount()

constexpr uint32_t impeller::ToArrayLayerCount ( TextureType type )

constexpr

Definition at line 517 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();
}

◆ ToAttachmentType()

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

static

Definition at line 497 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;
  }
}

◆ ToBlendFactor()

constexpr GLenum impeller::ToBlendFactor ( BlendFactor factor )

constexpr

Definition at line 91 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();
}

◆ ToBlendMode()

static BlendMode impeller::ToBlendMode ( flutter::DlBlendMode mode )

static

Definition at line 39 of file dl_dispatcher.cc.

                                                      {
  switch (mode) {
    case flutter::DlBlendMode::kClear:
      return BlendMode::kClear;
    case flutter::DlBlendMode::kSrc:
      return BlendMode::kSource;
    case flutter::DlBlendMode::kDst:
      return BlendMode::kDestination;
    case flutter::DlBlendMode::kSrcOver:
      return BlendMode::kSourceOver;
    case flutter::DlBlendMode::kDstOver:
      return BlendMode::kDestinationOver;
    case flutter::DlBlendMode::kSrcIn:
      return BlendMode::kSourceIn;
    case flutter::DlBlendMode::kDstIn:
      return BlendMode::kDestinationIn;
    case flutter::DlBlendMode::kSrcOut:
      return BlendMode::kSourceOut;
    case flutter::DlBlendMode::kDstOut:
      return BlendMode::kDestinationOut;
    case flutter::DlBlendMode::kSrcATop:
      return BlendMode::kSourceATop;
    case flutter::DlBlendMode::kDstATop:
      return BlendMode::kDestinationATop;
    case flutter::DlBlendMode::kXor:
      return BlendMode::kXor;
    case flutter::DlBlendMode::kPlus:
      return BlendMode::kPlus;
    case flutter::DlBlendMode::kModulate:
      return BlendMode::kModulate;
    case flutter::DlBlendMode::kScreen:
      return BlendMode::kScreen;
    case flutter::DlBlendMode::kOverlay:
      return BlendMode::kOverlay;
    case flutter::DlBlendMode::kDarken:
      return BlendMode::kDarken;
    case flutter::DlBlendMode::kLighten:
      return BlendMode::kLighten;
    case flutter::DlBlendMode::kColorDodge:
      return BlendMode::kColorDodge;
    case flutter::DlBlendMode::kColorBurn:
      return BlendMode::kColorBurn;
    case flutter::DlBlendMode::kHardLight:
      return BlendMode::kHardLight;
    case flutter::DlBlendMode::kSoftLight:
      return BlendMode::kSoftLight;
    case flutter::DlBlendMode::kDifference:
      return BlendMode::kDifference;
    case flutter::DlBlendMode::kExclusion:
      return BlendMode::kExclusion;
    case flutter::DlBlendMode::kMultiply:
      return BlendMode::kMultiply;
    case flutter::DlBlendMode::kHue:
      return BlendMode::kHue;
    case flutter::DlBlendMode::kSaturation:
      return BlendMode::kSaturation;
    case flutter::DlBlendMode::kColor:
      return BlendMode::kColor;
    case flutter::DlBlendMode::kLuminosity:
      return BlendMode::kLuminosity;
  }
  FML_UNREACHABLE();
}

◆ ToBlendOperation()

constexpr GLenum impeller::ToBlendOperation ( BlendOperation op )

constexpr

Definition at line 127 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();
}

◆ ToBlurStyle()

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

static

Definition at line 484 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;
  }
}

◆ ToClipOperation()

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

static

Definition at line 708 of file dl_dispatcher.cc.

                                   {
  switch (clip_op) {
    case flutter::DlCanvas::ClipOp::kDifference:
      return Entity::ClipOperation::kDifference;
    case flutter::DlCanvas::ClipOp::kIntersect:
      return Entity::ClipOperation::kIntersect;
  }
}

◆ ToColorFilter()

static std::shared_ptr< ColorFilter > impeller::ToColorFilter ( const flutter::DlColorFilter * filter )

static

Definition at line 437 of file dl_dispatcher.cc.

                                        {
  if (filter == nullptr) {
    return nullptr;
  }
  switch (filter->type()) {
    case flutter::DlColorFilterType::kBlend: {
      auto dl_blend = filter->asBlend();
      auto blend_mode = ToBlendMode(dl_blend->mode());
      auto color = skia_conversions::ToColor(dl_blend->color());
      return ColorFilter::MakeBlend(blend_mode, color);
    }
    case flutter::DlColorFilterType::kMatrix: {
      const flutter::DlMatrixColorFilter* dl_matrix = filter->asMatrix();
      impeller::ColorMatrix color_matrix;
      dl_matrix->get_matrix(color_matrix.array);
      return ColorFilter::MakeMatrix(color_matrix);
    }
    case flutter::DlColorFilterType::kSrgbToLinearGamma:
      return ColorFilter::MakeSrgbToLinear();
    case flutter::DlColorFilterType::kLinearToSrgbGamma:
      return ColorFilter::MakeLinearToSrgb();
  }
  return nullptr;
}

◆ ToColors()

static std::vector< Color > impeller::ToColors	(	const flutter::DlColor	colors[],
		int	count
	)

static

Definition at line 242 of file dl_dispatcher.cc.

                                                                           {
  auto result = std::vector<Color>();
  if (colors == nullptr) {
    return result;
  }
  for (int i = 0; i < count; i++) {
    result.push_back(skia_conversions::ToColor(colors[i]));
  }
  return result;
}

◆ ToColorSourceType()

static std::optional< ColorSource::Type > impeller::ToColorSourceType ( flutter::DlColorSourceType type )

static

Definition at line 253 of file dl_dispatcher.cc.

                                   {
  switch (type) {
    case flutter::DlColorSourceType::kColor:
      return ColorSource::Type::kColor;
    case flutter::DlColorSourceType::kImage:
      return ColorSource::Type::kImage;
    case flutter::DlColorSourceType::kLinearGradient:
      return ColorSource::Type::kLinearGradient;
    case flutter::DlColorSourceType::kRadialGradient:
      return ColorSource::Type::kRadialGradient;
    case flutter::DlColorSourceType::kConicalGradient:
      return ColorSource::Type::kConicalGradient;
    case flutter::DlColorSourceType::kSweepGradient:
      return ColorSource::Type::kSweepGradient;
    case flutter::DlColorSourceType::kRuntimeEffect:
      return ColorSource::Type::kRuntimeEffect;
#ifdef IMPELLER_ENABLE_3D
    case flutter::DlColorSourceType::kScene:
      return ColorSource::Type::kScene;
#endif  // IMPELLER_ENABLE_3D
  }
}

◆ ToCommitResult()

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

static

Definition at line 148 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 69 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();
}

◆ ToDebugIdentifier()

static std::optional< GLenum > impeller::ToDebugIdentifier ( DebugResourceType type )

static

Definition at line 310 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;
  }
  FML_UNREACHABLE();
}

◆ ToDebugResourceType()

static DebugResourceType impeller::ToDebugResourceType ( HandleType type )

static

Definition at line 173 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;
  }
  FML_UNREACHABLE();
}

◆ ToDeviceType()

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

constexpr

Definition at line 91 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;
}

◆ ToFont()

static Font impeller::ToFont ( const SkTextBlobRunIterator & run )

static

Definition at line 19 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};
}

◆ ToHandleType()

HandleType impeller::ToHandleType ( TextureGLES::Type type )

Definition at line 58 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();
}

◆ ToImageAspectFlags()

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

constexpr

Definition at line 564 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();
}

◆ ToImageFilter()

static std::shared_ptr< ImageFilter > impeller::ToImageFilter ( const flutter::DlImageFilter * filter )

static

Definition at line 517 of file dl_dispatcher.cc.

                                        {
  if (filter == nullptr) {
    return nullptr;
  }
 
  switch (filter->type()) {
    case flutter::DlImageFilterType::kBlur: {
      auto blur = filter->asBlur();
      auto sigma_x = Sigma(blur->sigma_x());
      auto sigma_y = Sigma(blur->sigma_y());
      auto tile_mode = ToTileMode(blur->tile_mode());
      return ImageFilter::MakeBlur(
          sigma_x, sigma_y, FilterContents::BlurStyle::kNormal, tile_mode);
    }
    case flutter::DlImageFilterType::kDilate: {
      auto dilate = filter->asDilate();
      FML_DCHECK(dilate);
      if (dilate->radius_x() < 0 || dilate->radius_y() < 0) {
        return nullptr;
      }
      auto radius_x = Radius(dilate->radius_x());
      auto radius_y = Radius(dilate->radius_y());
      return ImageFilter::MakeDilate(radius_x, radius_y);
    }
    case flutter::DlImageFilterType::kErode: {
      auto erode = filter->asErode();
      FML_DCHECK(erode);
      if (erode->radius_x() < 0 || erode->radius_y() < 0) {
        return nullptr;
      }
      auto radius_x = Radius(erode->radius_x());
      auto radius_y = Radius(erode->radius_y());
      return ImageFilter::MakeErode(radius_x, radius_y);
    }
    case flutter::DlImageFilterType::kMatrix: {
      auto matrix_filter = filter->asMatrix();
      FML_DCHECK(matrix_filter);
      auto matrix = ToMatrix(matrix_filter->matrix());
      auto desc = ToSamplerDescriptor(matrix_filter->sampling());
      return ImageFilter::MakeMatrix(matrix, desc);
    }
    case flutter::DlImageFilterType::kCompose: {
      auto compose = filter->asCompose();
      FML_DCHECK(compose);
      auto outer_dl_filter = compose->outer();
      auto inner_dl_filter = compose->inner();
      auto outer_filter = ToImageFilter(outer_dl_filter.get());
      auto inner_filter = ToImageFilter(inner_dl_filter.get());
      if (!outer_filter) {
        return inner_filter;
      }
      if (!inner_filter) {
        return outer_filter;
      }
      FML_DCHECK(outer_filter && inner_filter);
 
      return ImageFilter::MakeCompose(*inner_filter, *outer_filter);
    }
    case flutter::DlImageFilterType::kColorFilter: {
      auto color_filter_image_filter = filter->asColorFilter();
      FML_DCHECK(color_filter_image_filter);
      auto color_filter =
          ToColorFilter(color_filter_image_filter->color_filter().get());
      if (!color_filter) {
        return nullptr;
      }
      // 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 ImageFilter::MakeFromColorFilter(*color_filter);
    }
    case flutter::DlImageFilterType::kLocalMatrix: {
      auto local_matrix_filter = filter->asLocalMatrix();
      FML_DCHECK(local_matrix_filter);
      auto internal_filter = local_matrix_filter->image_filter();
      FML_DCHECK(internal_filter);
 
      auto image_filter = ToImageFilter(internal_filter.get());
      if (!image_filter) {
        return nullptr;
      }
 
      auto matrix = ToMatrix(local_matrix_filter->matrix());
      return ImageFilter::MakeLocalMatrix(matrix, *image_filter);
    }
  }
}

◆ ToIndexType()

constexpr GLenum impeller::ToIndexType ( IndexType type )

constexpr

Definition at line 34 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();
}

◆ ToMatrix()

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

static

Definition at line 158 of file dl_dispatcher.cc.

                                          {
  return Matrix{
      // clang-format off
      m[0], m[3], 0, m[6],
      m[1], m[4], 0, m[7],
      0,    0,    1, 0,
      m[2], m[5], 0, m[8],
      // clang-format on
  };
}

◆ ToMode()

constexpr GLenum impeller::ToMode ( PrimitiveType primitive_type )

constexpr

Definition at line 18 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;
  }
  FML_UNREACHABLE();
}

◆ ToMTLBlendFactor()

constexpr MTLBlendFactor impeller::ToMTLBlendFactor ( BlendFactor type )

constexpr

Definition at line 115 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;
};

◆ ToMTLBlendOperation()

constexpr MTLBlendOperation impeller::ToMTLBlendOperation ( BlendOperation type )

constexpr

Definition at line 198 of file formats_mtl.h.

                                                                     {
  switch (type) {
    case BlendOperation::kAdd:
      return MTLBlendOperationAdd;
    case BlendOperation::kSubtract:
      return MTLBlendOperationSubtract;
    case BlendOperation::kReverseSubtract:
      return MTLBlendOperationReverseSubtract;
  }
  return MTLBlendOperationAdd;
};

◆ ToMTLClearColor()

MTLClearColor impeller::ToMTLClearColor ( const Color & color )

inline

Definition at line 369 of file formats_mtl.h.

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

◆ ToMTLColorWriteMask()

constexpr MTLColorWriteMask impeller::ToMTLColorWriteMask ( ColorWriteMask type )

constexpr

Definition at line 210 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;
};

◆ ToMTLCompareFunction()

constexpr MTLCompareFunction impeller::ToMTLCompareFunction ( CompareFunction func )

constexpr

Definition at line 232 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;
};

◆ ToMTLCullMode()

constexpr MTLCullMode impeller::ToMTLCullMode ( CullMode mode )

constexpr

Definition at line 186 of file formats_mtl.h.

                                                   {
  switch (mode) {
    case CullMode::kNone:
      return MTLCullModeNone;
    case CullMode::kBackFace:
      return MTLCullModeBack;
    case CullMode::kFrontFace:
      return MTLCullModeFront;
  }
  return MTLCullModeNone;
}

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

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

                                                      {
  switch (type) {
    case IndexType::k16bit:
      return MTLIndexTypeUInt16;
    default:
      return MTLIndexTypeUInt32;
  }
}

◆ ToMTLLoadAction()

constexpr MTLLoadAction impeller::ToMTLLoadAction ( LoadAction action )

constexpr

Definition at line 276 of file formats_mtl.h.

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

◆ ToMTLPixelFormat()

constexpr MTLPixelFormat impeller::ToMTLPixelFormat ( PixelFormat format )

constexpr

Definition at line 77 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;
};

◆ ToMTLPrimitiveType()

constexpr MTLPrimitiveType impeller::ToMTLPrimitiveType ( PrimitiveType type )

constexpr

Definition at line 151 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;
  }
  return MTLPrimitiveTypePoint;
}

◆ ToMTLRenderPassDescriptor()

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

static

Definition at line 104 of file render_pass_mtl.mm.

                              {
  auto result = [MTLRenderPassDescriptor renderPassDescriptor];
 
  const auto& colors = desc.GetColorAttachments();
 
  for (const auto& color : colors) {
    if (!ConfigureColorAttachment(color.second,
                                  result.colorAttachments[color.first])) {
      VALIDATION_LOG << "Could not configure color attachment at index "
                     << color.first;
      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;
}

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

◆ ToMTLResourceOptions()

static MTLResourceOptions impeller::ToMTLResourceOptions	(	StorageMode	type,
		bool	supports_memoryless_targets,
		bool	supports_uma
	)

static

Definition at line 110 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();
}

◆ ToMTLSamplerAddressMode()

constexpr MTLSamplerAddressMode impeller::ToMTLSamplerAddressMode ( SamplerAddressMode mode )

constexpr

Definition at line 354 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;
}

◆ ToMTLSamplerMinMagFilter()

constexpr MTLSamplerMinMagFilter impeller::ToMTLSamplerMinMagFilter ( MinMagFilter filter )

constexpr

Definition at line 334 of file formats_mtl.h.

                                                                               {
  switch (filter) {
    case MinMagFilter::kNearest:
      return MTLSamplerMinMagFilterNearest;
    case MinMagFilter::kLinear:
      return MTLSamplerMinMagFilterLinear;
  }
  return MTLSamplerMinMagFilterNearest;
}

◆ ToMTLSamplerMipFilter()

constexpr MTLSamplerMipFilter impeller::ToMTLSamplerMipFilter ( MipFilter filter )

constexpr

Definition at line 344 of file formats_mtl.h.

                                                                      {
  switch (filter) {
    case MipFilter::kNearest:
      return MTLSamplerMipFilterNearest;
    case MipFilter::kLinear:
      return MTLSamplerMipFilterLinear;
  }
  return MTLSamplerMipFilterNotMipmapped;
}

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

◆ ToMTLStencilOperation()

constexpr MTLStencilOperation impeller::ToMTLStencilOperation ( StencilOperation op )

constexpr

Definition at line 254 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;
};

◆ ToMTLStorageMode()

static MTLStorageMode impeller::ToMTLStorageMode	(	StorageMode	mode,
		bool	supports_memoryless_targets,
		bool	supports_uma
	)

static

Definition at line 142 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();
}

◆ ToMTLStoreAction()

constexpr MTLStoreAction impeller::ToMTLStoreAction ( StoreAction action )

constexpr

Definition at line 304 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;
}

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

◆ ToMTLTextureType()

constexpr MTLTextureType impeller::ToMTLTextureType ( TextureType type )

constexpr

Definition at line 373 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;
}

◆ ToMTLTriangleFillMode()

constexpr MTLTriangleFillMode impeller::ToMTLTriangleFillMode ( PolygonMode mode )

constexpr

Definition at line 167 of file formats_mtl.h.

                                                                      {
  switch (mode) {
    case PolygonMode::kFill:
      return MTLTriangleFillModeFill;
    case PolygonMode::kLine:
      return MTLTriangleFillModeLines;
  }
  return MTLTriangleFillModeFill;
}

◆ ToParam()

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

static

Definition at line 19 of file sampler_gles.cc.

                                                                     {
  if (!mip_filter.has_value()) {
    switch (minmag_filter) {
      case MinMagFilter::kNearest:
        return GL_NEAREST;
      case MinMagFilter::kLinear:
        return GL_LINEAR;
    }
    FML_UNREACHABLE();
  }
 
  switch (mip_filter.value()) {
    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();
}

◆ ToPixelFormat() [1/2]

static PixelFormat impeller::ToPixelFormat ( AHardwareBuffer_Format format )

static

Definition at line 216 of file ahb_texture_source_vk.cc.

                                                                {
  switch (format) {
    case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
      return PixelFormat::kR8G8B8A8UNormInt;
    case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
      return PixelFormat::kR16G16B16A16Float;
    case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
      return PixelFormat::kD24UnormS8Uint;
    case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
      return PixelFormat::kD32FloatS8UInt;
    case AHARDWAREBUFFER_FORMAT_S8_UINT:
      return PixelFormat::kS8UInt;
    case AHARDWAREBUFFER_FORMAT_R8_UNORM:
      return PixelFormat::kR8UNormInt;
    case AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM:
    case AHARDWAREBUFFER_FORMAT_R16G16_UINT:
    case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
    case AHARDWAREBUFFER_FORMAT_R16_UINT:
    case AHARDWAREBUFFER_FORMAT_D24_UNORM:
    case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
    case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
    case AHARDWAREBUFFER_FORMAT_BLOB:
    case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
    case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
    case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
    case AHARDWAREBUFFER_FORMAT_D16_UNORM:
    case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
      // Not understood by the rest of Impeller. Use a placeholder but create
      // the native image and image views using the right external format.
      break;
  }
  return PixelFormat::kR8G8B8A8UNormInt;
}

◆ ToPixelFormat() [2/2]

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

constexpr

Definition at line 172 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;
  }
}

◆ ToRect() [1/2]

static Rect impeller::ToRect ( const SkRect & rect )

static

Definition at line 16 of file dl_vertices_geometry.cc.

                                       {
  return Rect::MakeLTRB(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
}

◆ ToRect() [2/2]

static Rect impeller::ToRect ( const SkRect & rect )

static

Definition at line 35 of file text_frame_skia.cc.

                                       {
  return Rect::MakeLTRB(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
}

◆ ToRenderBufferFormat()

static std::optional< GLenum > impeller::ToRenderBufferFormat ( PixelFormat format )

static

Definition at line 317 of file texture_gles.cc.

                                                                    {
  switch (format) {
    case PixelFormat::kB8G8R8A8UNormInt:
    case PixelFormat::kR8G8B8A8UNormInt:
      return GL_RGBA4;
    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();
}

◆ ToRenderingBackend()

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

constexpr

Definition at line 31 of file multi_arch_shader_archive_writer.cc.

                                     {
  switch (backend) {
    case ArchiveRenderingBackend::kMetal:
      return fb::RenderingBackend::kMetal;
    case ArchiveRenderingBackend::kVulkan:
      return fb::RenderingBackend::kVulkan;
    case ArchiveRenderingBackend::kOpenGLES:
      return fb::RenderingBackend::kOpenGLES;
  }
  FML_UNREACHABLE();
}

◆ ToRGB()

static constexpr Vector3 impeller::ToRGB ( Color color )

inlinestaticconstexpr

Definition at line 188 of file color.cc.

                                                   {
  return {color.red, color.green, color.blue};
}

◆ ToSamplerDescriptor() [1/2]

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

static

Definition at line 140 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;
}

◆ ToSamplerDescriptor() [2/2]

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

static

Definition at line 116 of file dl_dispatcher.cc.

                                          {
  impeller::SamplerDescriptor desc;
  switch (options) {
    case flutter::DlImageSampling::kNearestNeighbor:
      desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kNearest;
      desc.label = "Nearest Sampler";
      break;
    case flutter::DlImageSampling::kLinear:
    // Impeller doesn't support cubic sampling, but linear is closer to correct
    // than nearest for this case.
    case flutter::DlImageSampling::kCubic:
      desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
      desc.label = "Linear Sampler";
      break;
    case flutter::DlImageSampling::kMipmapLinear:
      desc.min_filter = desc.mag_filter = impeller::MinMagFilter::kLinear;
      desc.mip_filter = impeller::MipFilter::kLinear;
      desc.label = "Mipmap Linear Sampler";
      break;
  }
  return desc;
}

◆ ToShaderStage() [1/4]

static ShaderStage impeller::ToShaderStage ( ArchiveShaderType type )

static

Definition at line 18 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();
}

◆ ToShaderStage() [2/4]

static ShaderStage impeller::ToShaderStage ( ArchiveShaderType type )

static

Definition at line 18 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();
}

◆ 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();
}

◆ 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();
}

◆ 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();
}

◆ ToStage()

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

constexpr

Definition at line 86 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();
}

◆ ToStencilOp()

constexpr GLenum impeller::ToStencilOp ( StencilOperation op )

constexpr

Definition at line 47 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();
}

◆ ToStyle()

static Paint::Style impeller::ToStyle ( flutter::DlDrawStyle style )

static

Definition at line 174 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;
}

◆ ToTarget()

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

static

Definition at line 64 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;
  }
  FML_UNREACHABLE();
}

◆ ToTessWindingRule()

static int impeller::ToTessWindingRule ( FillType fill_type )

static

Definition at line 46 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;
}

◆ ToTextureDescriptor()

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

static

Definition at line 263 of file ahb_texture_source_vk.cc.

                                          {
  const auto ahb_size = ISize{ahb_desc.width, ahb_desc.height};
  TextureDescriptor desc;
  // We are not going to touch hardware buffers on the CPU or use them as
  // transient attachments. Just treat them as device private.
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.format =
      ToPixelFormat(static_cast<AHardwareBuffer_Format>(ahb_desc.format));
  desc.size = ahb_size;
  desc.type = ToTextureType(ahb_desc);
  desc.sample_count = SampleCount::kCount1;
  desc.compression_type = CompressionType::kLossless;
  desc.mip_count = (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE)
                       ? ahb_size.MipCount()
                       : 1u;
  return desc;
}

◆ ToTextureTarget()

constexpr std::optional< GLenum > impeller::ToTextureTarget ( TextureType type )

constexpr

Definition at line 184 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();
}

◆ ToTextureType() [1/2]

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

static

Definition at line 250 of file ahb_texture_source_vk.cc.

                                                                       {
  if (ahb_desc.layers == 1u) {
    return TextureType::kTexture2D;
  }
  if (ahb_desc.layers % 6u == 0 &&
      (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP)) {
    return TextureType::kTextureCube;
  }
  // Our texture types seem to understand external OES textures. Should these be
  // wired up instead?
  return TextureType::kTexture2D;
}

◆ ToTextureType() [2/2]

constexpr GLenum impeller::ToTextureType ( TextureType type )

constexpr

Definition at line 170 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();
}

◆ ToTileMode()

static Entity::TileMode impeller::ToTileMode ( flutter::DlTileMode tile_mode )

static

Definition at line 103 of file dl_dispatcher.cc.

                                                              {
  switch (tile_mode) {
    case flutter::DlTileMode::kClamp:
      return Entity::TileMode::kClamp;
    case flutter::DlTileMode::kRepeat:
      return Entity::TileMode::kRepeat;
    case flutter::DlTileMode::kMirror:
      return Entity::TileMode::kMirror;
    case flutter::DlTileMode::kDecal:
      return Entity::TileMode::kDecal;
  }
}

◆ 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();
}

◆ ToVector()

constexpr Vector4 impeller::ToVector ( Color color )

inlineconstexpr

Definition at line 185 of file shader_types.h.

                                               {
  return {color.red, color.green, color.blue, color.alpha};
}

◆ ToVertexAttribType()

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

constexpr

Definition at line 139 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();
}

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

◆ ToVertexMode()

static VerticesGeometry::VertexMode impeller::ToVertexMode ( flutter::DlVertexMode mode )

static

Definition at line 20 of file dl_vertices_geometry.cc.

                                                                         {
  switch (mode) {
    case flutter::DlVertexMode::kTriangles:
      return VerticesGeometry::VertexMode::kTriangles;
    case flutter::DlVertexMode::kTriangleStrip:
      return VerticesGeometry::VertexMode::kTriangleStrip;
    case flutter::DlVertexMode::kTriangleFan:
      return VerticesGeometry::VertexMode::kTriangleFan;
  };
}

◆ ToVKAttachmentLoadOp()

constexpr vk::AttachmentLoadOp impeller::ToVKAttachmentLoadOp ( LoadAction load_action )

constexpr

Definition at line 301 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();
}

◆ ToVKAttachmentStoreOp()

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

constexpr

Definition at line 314 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();
}

◆ ToVKBlendFactor()

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

constexpr

Definition at line 31 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();
}

◆ ToVKBlendOp()

constexpr vk::BlendOp impeller::ToVKBlendOp ( BlendOperation op )

constexpr

Definition at line 67 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();
}

◆ ToVKBufferMemoryPropertyFlags()

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

staticconstexpr

Definition at line 20 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();
}

◆ ToVKColorComponentFlags()

constexpr vk::ColorComponentFlags impeller::ToVKColorComponentFlags ( ColorWriteMask type )

constexpr

Definition at line 79 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;
}

◆ ToVKCompareOp()

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

constexpr

Definition at line 431 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();
}

◆ ToVKCullModeFlags()

constexpr vk::CullModeFlags impeller::ToVKCullModeFlags ( CullMode mode )

constexpr

Definition at line 419 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();
}

◆ ToVKDescriptorSetLayoutBinding()

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

constexpr

Definition at line 291 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;
}

◆ ToVKDescriptorType()

constexpr vk::DescriptorType impeller::ToVKDescriptorType ( DescriptorType type )

constexpr

Definition at line 267 of file formats_vk.h.

                                                                   {
  switch (type) {
    case DescriptorType::kSampledImage:
      return vk::DescriptorType::eCombinedImageSampler;
      break;
    case DescriptorType::kUniformBuffer:
      return vk::DescriptorType::eUniformBuffer;
      break;
    case DescriptorType::kStorageBuffer:
      return vk::DescriptorType::eStorageBuffer;
      break;
    case DescriptorType::kImage:
      return vk::DescriptorType::eSampledImage;
      break;
    case DescriptorType::kSampler:
      return vk::DescriptorType::eSampler;
      break;
    case DescriptorType::kInputAttachment:
      return vk::DescriptorType::eInputAttachment;
  }
 
  FML_UNREACHABLE();
}

◆ ToVKFrontFace()

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

constexpr

Definition at line 30 of file pipeline_vk.cc.

                                                        {
  switch (order) {
    case WindingOrder::kClockwise:
      return vk::FrontFace::eClockwise;
    case WindingOrder::kCounterClockwise:
      return vk::FrontFace::eCounterClockwise;
  }
  FML_UNREACHABLE();
}

◆ ToVKImageAspectFlags()

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

constexpr

Definition at line 491 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();
}

◆ ToVKImageCreateFlags()

constexpr vk::ImageCreateFlags impeller::ToVKImageCreateFlags ( TextureType type )

constexpr

Definition at line 545 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();
}

◆ ToVKImageFormat()

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

constexpr

Definition at line 135 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();
}

◆ ToVKImageViewType()

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

constexpr

Definition at line 531 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();
}

◆ ToVKIndexType()

constexpr vk::IndexType impeller::ToVKIndexType ( IndexType index_type )

constexpr

Definition at line 350 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();
}

◆ ToVKPipelineColorBlendAttachmentState()

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

constexpr

Definition at line 102 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;
}

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

◆ ToVKPolygonMode()

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

constexpr

Definition at line 365 of file formats_vk.h.

                                                          {
  switch (mode) {
    case PolygonMode::kFill:
      return vk::PolygonMode::eFill;
    case PolygonMode::kLine:
      return vk::PolygonMode::eLine;
  }
  FML_UNREACHABLE();
}

◆ ToVKPrimitiveTopology()

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

constexpr

Definition at line 375 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;
  }
 
  FML_UNREACHABLE();
}

◆ ToVKSampleCount()

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

constexpr

Definition at line 203 of file formats_vk.h.

                                                                          {
  switch (sample_count) {
    case SampleCount::kCount1:
      return vk::SampleCountFlagBits::e1;
    case SampleCount::kCount4:
      return vk::SampleCountFlagBits::e4;
  }
 
  FML_UNREACHABLE();
}

◆ ToVKSampleCountFlagBits()

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

constexpr

Definition at line 21 of file formats_vk.h.

                                                                           {
  switch (count) {
    case SampleCount::kCount1:
      return vk::SampleCountFlagBits::e1;
    case SampleCount::kCount4:
      return vk::SampleCountFlagBits::e4;
  }
  FML_UNREACHABLE();
}

◆ ToVKSamplerAddressMode()

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

constexpr

Definition at line 236 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();
}

◆ ToVKSamplerMinMagFilter()

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

constexpr

Definition at line 214 of file formats_vk.h.

                                                                {
  switch (filter) {
    case MinMagFilter::kNearest:
      return vk::Filter::eNearest;
    case MinMagFilter::kLinear:
      return vk::Filter::eLinear;
  }
 
  FML_UNREACHABLE();
}

◆ ToVKSamplerMipmapMode()

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

constexpr

Definition at line 225 of file formats_vk.h.

                                                                      {
  switch (filter) {
    case MipFilter::kNearest:
      return vk::SamplerMipmapMode::eNearest;
    case MipFilter::kLinear:
      return vk::SamplerMipmapMode::eLinear;
  }
 
  FML_UNREACHABLE();
}

◆ ToVkShaderStage()

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

constexpr

Definition at line 252 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();
}

◆ ToVKShaderStageFlagBits()

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

constexpr

Definition at line 120 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();
}

◆ ToVKStencilOp()

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

constexpr

Definition at line 453 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();
}

◆ ToVKStencilOpState()

constexpr vk::StencilOpState impeller::ToVKStencilOpState ( const StencilAttachmentDescriptor & desc )

constexpr

Definition at line 476 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;
}

◆ ToVKTextureMemoryPropertyFlags()

static constexpr vk::Flags< vk::MemoryPropertyFlagBits > impeller::ToVKTextureMemoryPropertyFlags	(	StorageMode	mode,
		bool	supports_memoryless_textures
	)

staticconstexpr

Definition at line 249 of file allocator_vk.cc.

                                                                  {
  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();
}

◆ ToVmaAllocationBufferCreateFlags()

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

static

Definition at line 32 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();
}

◆ ToVmaAllocationCreateFlags()

static VmaAllocationCreateFlags impeller::ToVmaAllocationCreateFlags ( StorageMode mode )

static

Definition at line 267 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();
}

◆ ToVMAMemoryUsage()

static constexpr VmaMemoryUsage impeller::ToVMAMemoryUsage ( )

staticconstexpr

Definition at line 244 of file allocator_vk.cc.

                                                   {
  return VMA_MEMORY_USAGE_AUTO;
}

◆ UpdateAtlasBitmap() [1/2]

static bool impeller::UpdateAtlasBitmap	(	const GlyphAtlas &	atlas,
		const std::shared_ptr< BitmapSTB > &	bitmap,
		const std::vector< FontGlyphPair > &	new_pairs
	)

static

Definition at line 267 of file typographer_context_stb.cc.

                                                                         {
  TRACE_EVENT0("impeller", __FUNCTION__);
  FML_DCHECK(bitmap != nullptr);
 
  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
 
  for (const FontGlyphPair& pair : new_pairs) {
    auto pos = atlas.FindFontGlyphBounds(pair);
    if (!pos.has_value()) {
      continue;
    }
    DrawGlyph(bitmap.get(), pair.scaled_font, pair.glyph, pos.value(),
              has_color);
  }
  return true;
}

◆ UpdateAtlasBitmap() [2/2]

static bool impeller::UpdateAtlasBitmap	(	const GlyphAtlas &	atlas,
		const std::shared_ptr< SkBitmap > &	bitmap,
		const std::vector< FontGlyphPair > &	new_pairs
	)

static

Definition at line 190 of file typographer_context_skia.cc.

                                                                         {
  TRACE_EVENT0("impeller", __FUNCTION__);
  FML_DCHECK(bitmap != nullptr);
 
  auto surface = SkSurfaces::WrapPixels(bitmap->pixmap());
  if (!surface) {
    return false;
  }
  auto canvas = surface->getCanvas();
  if (!canvas) {
    return false;
  }
 
  bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
 
  for (const FontGlyphPair& pair : new_pairs) {
    auto pos = atlas.FindFontGlyphBounds(pair);
    if (!pos.has_value()) {
      continue;
    }
    DrawGlyph(canvas, pair.scaled_font, pair.glyph, pos.value(), has_color);
  }
  return true;
}

◆ UpdateGlyphTextureAtlas() [1/2]

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

static

Definition at line 311 of file typographer_context_stb.cc.

                                                                           {
  TRACE_EVENT0("impeller", __FUNCTION__);
 
  FML_DCHECK(bitmap != nullptr);
 
  auto texture_descriptor = texture->GetTextureDescriptor();
 
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(bitmap->GetPixels()),  // data
      texture_descriptor.GetByteSizeOfBaseMipLevel()          // size
      // As the bitmap is static in this module I believe we don't need to
      // specify a release proc.
  );
 
  return texture->SetContents(mapping);
}

◆ UpdateGlyphTextureAtlas() [2/2]

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

static

Definition at line 260 of file typographer_context_skia.cc.

                                                                           {
  TRACE_EVENT0("impeller", __FUNCTION__);
 
  FML_DCHECK(bitmap != nullptr);
  auto texture_descriptor = texture->GetTextureDescriptor();
 
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(bitmap->getAddr(0, 0)),  // data
      texture_descriptor.GetByteSizeOfBaseMipLevel(),           // size
      [bitmap](auto, auto) mutable { bitmap.reset(); }          // proc
  );
 
  return texture->SetContents(mapping);
}

◆ UploadGlyphTextureAtlas() [1/2]

static std::shared_ptr< Texture > impeller::UploadGlyphTextureAtlas	(	const std::shared_ptr< Allocator > &	allocator,
		std::shared_ptr< BitmapSTB > &	bitmap,
		const ISize &	atlas_size,
		PixelFormat	format
	)

static

Definition at line 329 of file typographer_context_stb.cc.

                        {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!allocator) {
    return nullptr;
  }
 
  FML_DCHECK(bitmap != nullptr);
 
  TextureDescriptor texture_descriptor;
  texture_descriptor.storage_mode = StorageMode::kHostVisible;
  texture_descriptor.format = format;
  texture_descriptor.size = atlas_size;
 
  if (bitmap->GetRowBytes() * bitmap->GetHeight() !=
      texture_descriptor.GetByteSizeOfBaseMipLevel()) {
    return nullptr;
  }
 
  auto texture = allocator->CreateTexture(texture_descriptor);
  if (!texture || !texture->IsValid()) {
    return nullptr;
  }
  texture->SetLabel("GlyphAtlas");
 
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(bitmap->GetPixels()),  // data
      texture_descriptor.GetByteSizeOfBaseMipLevel()          // size
      // As the bitmap is static in this module I believe we don't need to
      // specify a release proc.
  );
 
  if (!texture->SetContents(mapping)) {
    return nullptr;
  }
  return texture;
}

◆ UploadGlyphTextureAtlas() [2/2]

static std::shared_ptr< Texture > impeller::UploadGlyphTextureAtlas	(	const std::shared_ptr< Allocator > &	allocator,
		std::shared_ptr< SkBitmap >	bitmap,
		const ISize &	atlas_size,
		PixelFormat	format
	)

static

Definition at line 276 of file typographer_context_skia.cc.

                        {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!allocator) {
    return nullptr;
  }
 
  FML_DCHECK(bitmap != nullptr);
  const auto& pixmap = bitmap->pixmap();
 
  TextureDescriptor texture_descriptor;
  texture_descriptor.storage_mode = StorageMode::kHostVisible;
  texture_descriptor.format = format;
  texture_descriptor.size = atlas_size;
 
  if (pixmap.rowBytes() * pixmap.height() !=
      texture_descriptor.GetByteSizeOfBaseMipLevel()) {
    return nullptr;
  }
 
  auto texture = allocator->CreateTexture(texture_descriptor);
  if (!texture || !texture->IsValid()) {
    return nullptr;
  }
  texture->SetLabel("GlyphAtlas");
 
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(bitmap->getAddr(0, 0)),  // data
      texture_descriptor.GetByteSizeOfBaseMipLevel(),           // size
      [bitmap](auto, auto) mutable { bitmap.reset(); }          // proc
  );
 
  if (!texture->SetContents(mapping)) {
    return nullptr;
  }
  return texture;
}

◆ UseColorSourceContents()

static bool impeller::UseColorSourceContents	(	const std::shared_ptr< VerticesGeometry > &	vertices,
		const Paint &	paint
	)

static

Definition at line 901 of file canvas.cc.

                        {
  // If there are no vertex color or texture coordinates. Or if there
  // are vertex coordinates but its just a color.
  if (vertices->HasVertexColors()) {
    return false;
  }
  if (vertices->HasTextureCoordinates() &&
      (paint.color_source.GetType() == ColorSource::Type::kColor)) {
    return true;
  }
  return !vertices->HasTextureCoordinates();
}

◆ 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::kLast)) {
    return false;
  }
  return true;
}

◆ VendorToString()

constexpr const char * impeller::VendorToString ( VendorVK vendor )

constexpr

Definition at line 49 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";
  }
  FML_UNREACHABLE();
}

◆ VerifyExistingCache()

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

static

Definition at line 19 of file pipeline_cache_vk.cc.

                                                            {
  return true;
}

◆ VKClearValueFromColor()

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

static

Definition at line 38 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;
}

◆ VKClearValueFromDepthStencil()

static vk::ClearDepthStencilValue impeller::VKClearValueFromDepthStencil	(	uint32_t	stencil,
		Scalar	depth
	)

static

Definition at line 45 of file render_pass_vk.cc.

                                                                             {
  vk::ClearDepthStencilValue value;
  value.depth = depth;
  value.stencil = stencil;
  return value;
}

◆ VKShaderNameToShaderKeyName()

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

static

Definition at line 30 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();
}

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

◆ WrapperMTL()

std::shared_ptr< Texture > impeller::WrapperMTL	(	TextureDescriptor	desc,
		const void *	mtl_texture,
		std::function< void()>	deletion_proc
	)

Definition at line 13 of file texture_mtl.mm.

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

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

◆ WrapTextureWithRenderTarget()

static std::optional< RenderTarget > impeller::WrapTextureWithRenderTarget	(	Allocator &	allocator,
		id< MTLTexture >	texture,
		bool	requires_blit,
		std::optional< IRect >	clip_rect
	)

static

Definition at line 47 of file surface_mtl.mm.

                                  {
  // compositor_context.cc will offset the rendering by the clip origin. Here we
  // shrink to the size of the clip. This has the same effect as clipping the
  // rendering but also creates smaller intermediate passes.
  ISize root_size;
  if (requires_blit) {
    if (!clip_rect.has_value()) {
      VALIDATION_LOG << "Missing clip rectangle.";
      return std::nullopt;
    }
    root_size = ISize(clip_rect->GetWidth(), clip_rect->GetHeight());
  } else {
    root_size = {static_cast<ISize::Type>(texture.width),
                 static_cast<ISize::Type>(texture.height)};
  }
 
  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;
 
  if (resolve_tex_desc.format == PixelFormat::kUnknown) {
    VALIDATION_LOG << "Unknown drawable color format.";
    return std::nullopt;
  }
 
  // Create color resolve texture.
  std::shared_ptr<Texture> resolve_tex;
  if (requires_blit) {
    resolve_tex_desc.compression_type = CompressionType::kLossy;
    resolve_tex = allocator.CreateTexture(resolve_tex_desc);
  } else {
    resolve_tex = TextureMTL::Create(resolve_tex_desc, texture);
  }
 
  if (!resolve_tex) {
    VALIDATION_LOG << "Could not wrap resolve texture.";
    return std::nullopt;
  }
  resolve_tex->SetLabel("ImpellerOnscreenResolve");
 
  TextureDescriptor msaa_tex_desc;
  msaa_tex_desc.storage_mode = StorageMode::kDeviceTransient;
  msaa_tex_desc.type = TextureType::kTexture2DMultisample;
  msaa_tex_desc.sample_count = SampleCount::kCount4;
  msaa_tex_desc.format = resolve_tex->GetTextureDescriptor().format;
  msaa_tex_desc.size = resolve_tex->GetSize();
  msaa_tex_desc.usage = TextureUsage::kRenderTarget;
 
  auto msaa_tex = allocator.CreateTexture(msaa_tex_desc);
  if (!msaa_tex) {
    VALIDATION_LOG << "Could not allocate MSAA color texture.";
    return std::nullopt;
  }
  msaa_tex->SetLabel("ImpellerOnscreenColorMSAA");
 
  ColorAttachment color0;
  color0.texture = msaa_tex;
  color0.clear_color = Color::DarkSlateGray();
  color0.load_action = LoadAction::kClear;
  color0.store_action = StoreAction::kMultisampleResolve;
  color0.resolve_texture = std::move(resolve_tex);
 
  auto render_target_desc = std::make_optional<RenderTarget>();
  render_target_desc->SetColorAttachment(color0, 0u);
 
  return render_target_desc;
}

Variable Documentation

◆ g_all_pools_map_mutex

Mutex impeller::g_all_pools_map_mutex

static

Definition at line 174 of file command_pool_vk.cc.

◆ gHasValidationLayers

bool impeller::gHasValidationLayers = false

static

Definition at line 46 of file context_vk.cc.

◆ gShouldOpenNewPlaygrounds

std::atomic_bool impeller::gShouldOpenNewPlaygrounds = true

static

Definition at line 164 of file playground.cc.

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

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

◆ kAlloc

const TESSalloc impeller::kAlloc

static

Initial value:

= {
    HeapAlloc, HeapRealloc, HeapFree, 0, 
    16,                                  
    16,                                  
    16,                                  
    16,                                  
    16,                                  
    0                                    
}

Definition at line 24 of file tessellator_libtess.cc.

                                {
    HeapAlloc, HeapRealloc, HeapFree, 0, /* =userData */
    16,                                  /* =meshEdgeBucketSize */
    16,                                  /* =meshVertexBucketSize */
    16,                                  /* =meshFaceBucketSize */
    16,                                  /* =dictNodeBucketSize */
    16,                                  /* =regionBucketSize */
    0                                    /* =extraVertices */
};

◆ kAllocatorBlockSize

constexpr size_t impeller::kAllocatorBlockSize = 1024000

constexpr

Definition at line 18 of file host_buffer.cc.

◆ kAngleInputAttachmentPrefix

constexpr std::string_view impeller::kAngleInputAttachmentPrefix

staticconstexpr

Initial value:

=

"ANGLEInputAttachment"

Definition at line 21 of file buffer_bindings_gles.cc.

◆ kBlendModeNames

constexpr const char* impeller::kBlendModeNames[]

staticconstexpr

Initial value:

= {

IMPELLER_FOR_EACH_BLEND_MODE(_IMPELLER_BLEND_MODE_NAME_LIST)}

_IMPELLER_BLEND_MODE_NAME_LIST

#define _IMPELLER_BLEND_MODE_NAME_LIST(blend_mode)

Definition color.cc:42

Definition at line 44 of file color.cc.

44 {

45 IMPELLER_FOR_EACH_BLEND_MODE(_IMPELLER_BLEND_MODE_NAME_LIST)};

◆ kColorInversion

constexpr ColorMatrix impeller::kColorInversion

constexpr

Initial value:

= {
  .array = {
    -1.0,    0,    0, 1.0, 0, 
       0, -1.0,    0, 1.0, 0, 
       0,    0, -1.0, 1.0, 0, 
     1.0,  1.0,  1.0, 1.0, 0  
  }
}

A color matrix which inverts colors.

Definition at line 20 of file paint.cc.

                                        {
  .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  //
  }
};

◆ kDefaultBindingSize

const constexpr DescriptorPoolSize impeller::kDefaultBindingSize

staticconstexpr

Initial value:

=
    DescriptorPoolSize{
        .buffer_bindings = 512u,   
        .texture_bindings = 256u,  
        .storage_bindings = 32,
        .subpass_bindings = 4u  
    }

Descriptor pools are always allocated with the following sizes.

Definition at line 24 of file descriptor_pool_vk.cc.

                      {
        .buffer_bindings = 512u,   // Buffer Bindings
        .texture_bindings = 256u,  // Texture Bindings
        .storage_bindings = 32,
        .subpass_bindings = 4u  // Subpass Bindings
    };

◆ kDefaultStencilConfig [1/2]

const constexpr RenderTarget::AttachmentConfig impeller::kDefaultStencilConfig

staticconstexpr

Initial value:

=
    RenderTarget::AttachmentConfig{
        .storage_mode = StorageMode::kDeviceTransient,
        .load_action = LoadAction::kDontCare,
        .store_action = StoreAction::kDontCare,
    }

Definition at line 26 of file experimental_canvas.cc.

                                {
        .storage_mode = StorageMode::kDeviceTransient,
        .load_action = LoadAction::kDontCare,
        .store_action = StoreAction::kDontCare,
    };

◆ kDefaultStencilConfig [2/2]

const constexpr RenderTarget::AttachmentConfig impeller::kDefaultStencilConfig

staticconstexpr

Initial value:

=
    RenderTarget::AttachmentConfig{
        .storage_mode = StorageMode::kDeviceTransient,
        .load_action = LoadAction::kDontCare,
        .store_action = StoreAction::kDontCare,
    }

Definition at line 291 of file entity_pass.cc.

                                {
        .storage_mode = StorageMode::kDeviceTransient,
        .load_action = LoadAction::kDontCare,
        .store_action = StoreAction::kDontCare,
    };

◆ kE

constexpr float impeller::kE = 2.7182818284590452354f

constexpr

Definition at line 11 of file constants.h.

◆ kEhCloseEnough

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

constexpr

Definition at line 56 of file constants.h.

◆ kElementsWindowName

const char* impeller::kElementsWindowName = "Elements"

static

Definition at line 17 of file aiks_playground_inspector.cc.

◆ kEmptyResult

const GeometryResult impeller::kEmptyResult

static

Initial value:

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

Definition at line 41 of file geometry.h.

                                           {
    .vertex_buffer =
        {
            .index_type = IndexType::kNone,
        },
};

◆ kFramebufferFetchExt

const constexpr char* impeller::kFramebufferFetchExt

staticconstexpr

Initial value:

=

"GL_EXT_shader_framebuffer_fetch"

Definition at line 13 of file capabilities_gles.cc.

◆ kHostBufferArenaSize

const constexpr size_t impeller::kHostBufferArenaSize = 3u

staticconstexpr

Approximately the same size as the max frames in flight.

Definition at line 22 of file host_buffer.h.

◆ kImageSizeThresholdForDedicatedMemoryAllocation

constexpr size_t impeller::kImageSizeThresholdForDedicatedMemoryAllocation

constexpr

Initial value:

=

4 * 1024 * 1024

Definition at line 12 of file limits_vk.h.

◆ kInstanceLayer

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

staticconstexpr

Definition at line 15 of file capabilities_vk.cc.

◆ kKernelRadiusPerSigma

constexpr float impeller::kKernelRadiusPerSigma = 1.73205080757

staticconstexpr

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

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

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

Definition at line 24 of file sigma.h.

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

◆ kMatrixBT601FullRange

constexpr Matrix impeller::kMatrixBT601FullRange

constexpr

Initial value:

= {
      1.0,    1.0,   1.0, 0.0,
      0.0, -0.344, 1.772, 0.0,
    1.402, -0.714,   0.0, 0.0,
      0.0,    0.0,   0.0, 1.0
}

Definition at line 24 of file yuv_to_rgb_filter_contents.cc.

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

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

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

◆ kMaxBindings

constexpr size_t impeller::kMaxBindings = 32

staticconstexpr

Definition at line 26 of file pipeline_vk.h.

◆ kMaxFramesInFlight

constexpr size_t impeller::kMaxFramesInFlight = 3u

staticconstexpr

Definition at line 21 of file khr_swapchain_impl_vk.cc.

◆ kMultisampledRenderToTextureExt

const constexpr char* impeller::kMultisampledRenderToTextureExt

staticconstexpr

Initial value:

=

"GL_EXT_multisampled_render_to_texture"

Definition at line 22 of file capabilities_gles.cc.

◆ kNullGlyphAtlas

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

static

Definition at line 17 of file lazy_glyph_atlas.cc.

◆ kNullSampler [1/3]

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

static

Definition at line 14 of file sampler_library_gles.cc.

◆ kNullSampler [2/3]

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

static

Definition at line 16 of file sampler_library_mtl.mm.

◆ kNullSampler [3/3]

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

static

Definition at line 19 of file sampler_library_vk.cc.

◆ kNvidiaTextureBorderClampExt

const constexpr char* impeller::kNvidiaTextureBorderClampExt

staticconstexpr

Initial value:

=

"GL_NV_texture_border_clamp"

Definition at line 18 of file capabilities_gles.cc.

◆ kPadding

constexpr size_t impeller::kPadding = 2

constexpr

Definition at line 30 of file typographer_context_skia.cc.

◆ kPhi

constexpr float impeller::kPhi = 1.61803398874989484820f

constexpr

Definition at line 53 of file constants.h.

◆ kPi

constexpr float impeller::kPi = 3.14159265358979323846f

constexpr

Definition at line 26 of file constants.h.

◆ kPiOver2

constexpr float impeller::kPiOver2 = 1.57079632679489661923f

constexpr

Definition at line 32 of file constants.h.

◆ kPiOver4

constexpr float impeller::kPiOver4 = 0.78539816339744830962f

constexpr

Definition at line 35 of file constants.h.

◆ kPipelineCacheFileName

constexpr const char* impeller::kPipelineCacheFileName

staticconstexpr

Initial value:

=

"flutter.impeller.vkcache"

Definition at line 16 of file pipeline_cache_vk.cc.

◆ kPollFramesForOrientation

constexpr size_t impeller::kPollFramesForOrientation = 1u

staticconstexpr

Definition at line 26 of file khr_swapchain_impl_vk.cc.

◆ kPoolSize

constexpr uint32_t impeller::kPoolSize = 128u

staticconstexpr

Definition at line 23 of file gpu_tracer_vk.cc.

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

                                                                      {{
    {0, 0, 0, 0, 0},    // Clear
    {1, 0, 0, 0, 0},    // Source
    {0, 0, 1, 0, 0},    // Destination
    {1, 0, 1, -1, 0},   // SourceOver
    {1, -1, 1, 0, 0},   // DestinationOver
    {0, 1, 0, 0, 0},    // SourceIn
    {0, 0, 0, 1, 0},    // DestinationIn
    {1, -1, 0, 0, 0},   // SourceOut
    {0, 0, 1, -1, 0},   // DestinationOut
    {0, 1, 1, -1, 0},   // SourceATop
    {1, -1, 0, 1, 0},   // DestinationATop
    {1, -1, 1, -1, 0},  // Xor
    {1, 0, 1, 0, 0},    // Plus
    {0, 0, 0, 0, 1},    // Modulate
    {0, 0, 1, 0, -1},   // Screen
}};

◆ kPrecomputedDivisionCount

constexpr int impeller::kPrecomputedDivisionCount = 1024

staticconstexpr

Definition at line 91 of file tessellator.cc.

◆ kPrecomputedDivisions

int impeller::kPrecomputedDivisions[kPrecomputedDivisionCount]

static

Definition at line 92 of file tessellator.cc.

                                                              {
    // clang-format off
     1,  2,  3,  4,  4,  4,  5,  5,  5,  6,  6,  6,  7,  7,  7,  7,
     8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10,
    10, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 13,
    13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18,
    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19,
    19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
    20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23,
    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24,
    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25,
    25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26,
    26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27,
    27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28,
    28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29,
    29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
    29, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
    30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
    31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32,
    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33,
    33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
    33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
    34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35,
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36,
    36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
    36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
    37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38,
    38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
    38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
    39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40,
    40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
    40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41,
    41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
    41, 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 43, 43,
    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
    43, 43, 43, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 44, 44, 44,
    44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
    44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
    45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
    45, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
    46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 47,
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48,
    48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
    48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 49, 49, 49,
    49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
    49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 50, 50, 50, 50, 50,
    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 51, 51, 51, 51, 51,
    51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
    51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 52, 52, 52, 52,
    52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
    52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 53, 53, 53,
    53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
    53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 54,
    54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
    54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
    54, 54, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
    55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
    55, 55, 55, 55, 55, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
    56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
    56, 56, 56, 56, 56, 56, 56, 56, 56, 57, 57, 57, 57, 57, 57, 57,
    // clang-format on
};

◆ kPropertiesProcTable

const auto impeller::kPropertiesProcTable

static

Definition at line 70 of file aiks_playground_inspector.cc.

                                                         {
    .boolean =
        [](CaptureBooleanProperty& p) {
          ImGui::Checkbox(p.label.c_str(), &p.value);
        },
    .integer =
        [](CaptureIntegerProperty& p) {
          if (p.options.range.has_value()) {
            ImGui::SliderInt(p.label.c_str(), &p.value,
                             static_cast<int>(p.options.range->min),
                             static_cast<int>(p.options.range->max));
            return;
          }
          ImGui::InputInt(p.label.c_str(), &p.value);
        },
    .scalar =
        [](CaptureScalarProperty& p) {
          if (p.options.range.has_value()) {
            ImGui::SliderFloat(p.label.c_str(), &p.value, p.options.range->min,
                               p.options.range->max);
            return;
          }
          ImGui::DragFloat(p.label.c_str(), &p.value, 0.01);
        },
    .point =
        [](CapturePointProperty& p) {
          if (p.options.range.has_value()) {
            ImGui::SliderFloat2(p.label.c_str(),
                                reinterpret_cast<float*>(&p.value),
                                p.options.range->min, p.options.range->max);
            return;
          }
          ImGui::DragFloat2(p.label.c_str(), reinterpret_cast<float*>(&p.value),
                            0.01);
        },
    .vector3 =
        [](CaptureVector3Property& p) {
          if (p.options.range.has_value()) {
            ImGui::SliderFloat3(p.label.c_str(),
                                reinterpret_cast<float*>(&p.value),
                                p.options.range->min, p.options.range->max);
            return;
          }
          ImGui::DragFloat3(p.label.c_str(), reinterpret_cast<float*>(&p.value),
                            0.01);
        },
    .rect =
        [](CaptureRectProperty& p) {
          ImGui::DragFloat4(p.label.c_str(), reinterpret_cast<float*>(&p.value),
                            0.01);
        },
    .color =
        [](CaptureColorProperty& p) {
          ImGui::ColorEdit4(p.label.c_str(),
                            reinterpret_cast<float*>(&p.value));
        },
    .matrix =
        [](CaptureMatrixProperty& p) {
          float* pointer = reinterpret_cast<float*>(&p.value);
          ImGui::DragFloat4((p.label + " X basis").c_str(), pointer, 0.001);
          ImGui::DragFloat4((p.label + " Y basis").c_str(), pointer + 4, 0.001);
          ImGui::DragFloat4((p.label + " Z basis").c_str(), pointer + 8, 0.001);
          ImGui::DragFloat4((p.label + " Translation").c_str(), pointer + 12,
                            0.001);
        },
    .string =
        [](CaptureStringProperty& p) {
          ImGui::InputTextEx(p.label.c_str(), "",
                             // Fine as long as it's read-only.
                             const_cast<char*>(p.value.c_str()), p.value.size(),
                             ImVec2(0, 0), ImGuiInputTextFlags_ReadOnly);
        },
};

◆ kPropertiesWindowName

const char* impeller::kPropertiesWindowName = "Properties"

static

Definition at line 18 of file aiks_playground_inspector.cc.

◆ kScaleSize

constexpr Scalar impeller::kScaleSize = 100000.0f

staticconstexpr

Definition at line 39 of file text_frame_skia.cc.

◆ kSelfDependencyDstAccessMask

constexpr auto impeller::kSelfDependencyDstAccessMask

constexpr

Initial value:

=

vk::AccessFlagBits::eInputAttachmentRead

Definition at line 20 of file render_pass_builder_vk.cc.

◆ kSelfDependencyDstStageMask

constexpr auto impeller::kSelfDependencyDstStageMask

constexpr

Initial value:

=

vk::PipelineStageFlagBits::eFragmentShader

Definition at line 18 of file render_pass_builder_vk.cc.

◆ kSelfDependencyFlags

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

constexpr

Definition at line 23 of file render_pass_builder_vk.cc.

◆ kSelfDependencySrcAccessMask

constexpr auto impeller::kSelfDependencySrcAccessMask

constexpr

Initial value:

=

vk::AccessFlagBits::eColorAttachmentWrite

Definition at line 15 of file render_pass_builder_vk.cc.

◆ kSelfDependencySrcStageMask

constexpr auto impeller::kSelfDependencySrcStageMask

constexpr

Initial value:

=

vk::PipelineStageFlagBits::eColorAttachmentOutput

Definition at line 13 of file render_pass_builder_vk.cc.

◆ kSkipTests

const std::vector<std::string> impeller::kSkipTests

static

Initial value:

= {
    
    IMP_AIKSTEST(TextRotated),
    
    "impeller_Play_AiksTest_CanRenderClippedRuntimeEffects_Vulkan",
}

Definition at line 64 of file golden_playground_test_mac.cc.

                                               {
    // TextRotated is flakey and we can't seem to get it to stabilize on Skia
    // Gold.
    IMP_AIKSTEST(TextRotated),
    // Runtime stage based tests get confused with a Metal context.
    "impeller_Play_AiksTest_CanRenderClippedRuntimeEffects_Vulkan",
};

◆ kSqrt2

constexpr float impeller::kSqrt2 = 1.41421356237309504880f

constexpr

Definition at line 47 of file constants.h.

◆ kSupportedDocuments

const std::initializer_list<std::string> impeller::kSupportedDocuments

static

Initial value:

= {

EntityPass::kCaptureDocumentName}

Definition at line 20 of file aiks_playground_inspector.cc.

20 {

21 EntityPass::kCaptureDocumentName};

◆ kTextureBorderClampExt

const constexpr char* impeller::kTextureBorderClampExt

staticconstexpr

Initial value:

=

"GL_EXT_texture_border_clamp"

Definition at line 16 of file capabilities_gles.cc.

◆ kUnusedAttachmentReference

constexpr vk::AttachmentReference impeller::kUnusedAttachmentReference

staticconstexpr

Initial value:

= {

VK_ATTACHMENT_UNUSED, vk::ImageLayout::eUndefined}

VK_ATTACHMENT_UNUSED

#define VK_ATTACHMENT_UNUSED

Definition vulkan_core.h:124

Definition at line 416 of file formats_vk.h.

416 {

417 VK_ATTACHMENT_UNUSED, vk::ImageLayout::eUndefined};

◆ sLastID

std::atomic_size_t impeller::sLastID

static

Definition at line 11 of file comparable.cc.

◆ sValidationLogsAreFatal

std::atomic_int32_t impeller::sValidationLogsAreFatal = 0

static

Definition at line 14 of file validation.cc.

◆ sValidationLogsDisabledCount

std::atomic_int32_t impeller::sValidationLogsDisabledCount = 0

static

Definition at line 13 of file validation.cc.

◆ tess

TessellatorLibtess impeller::tess

static

Definition at line 41 of file geometry_benchmarks.cc.

◆ tls_command_pool_map

thread_local std::unique_ptr<CommandPoolMap> impeller::tls_command_pool_map

static

Definition at line 170 of file command_pool_vk.cc.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AHBProperties

◆ BlendColorBurnPipeline

◆ BlendColorDodgePipeline

◆ BlendColorPipeline

◆ BlendDarkenPipeline

◆ BlendDifferencePipeline

◆ BlendExclusionPipeline

◆ BlendHardLightPipeline

◆ BlendHuePipeline

◆ BlendLightenPipeline

◆ BlendLuminosityPipeline

◆ BlendMultiplyPipeline

◆ BlendOverlayPipeline

◆ BlendSaturationPipeline

◆ BlendScreenPipeline

◆ BlendSoftLightPipeline

◆ BorderMaskBlurPipeline

◆ BufferResource

◆ Callback

◆ CanvasType

◆ ClipPipeline

◆ Clock

◆ ColorMatrixColorFilterPipeline

◆ ColorSourceData

◆ ColorWriteMask

◆ CommandPoolMap

◆ ComputePipelineMap

◆ ConicalGradientFillPipeline

◆ ConicalGradientSSBOFillPipeline

◆ CTessellator

◆ EllipticalVertexGenerator

◆ FontGlyphMap

◆ FramebufferBlendColorBurnPipeline

◆ FramebufferBlendColorDodgePipeline

◆ FramebufferBlendColorPipeline

◆ FramebufferBlendDarkenPipeline

◆ FramebufferBlendDifferencePipeline

◆ FramebufferBlendExclusionPipeline

◆ FramebufferBlendHardLightPipeline

◆ FramebufferBlendHuePipeline

◆ FramebufferBlendLightenPipeline

◆ FramebufferBlendLuminosityPipeline

◆ FramebufferBlendMultiplyPipeline

◆ FramebufferBlendOverlayPipeline

◆ FramebufferBlendSaturationPipeline

◆ FramebufferBlendScreenPipeline

◆ FramebufferBlendSoftLightPipeline

◆ GaussianBlurFragmentShader

◆ GaussianBlurPipeline

◆ GaussianBlurVertexShader

◆ GlyphAtlasPipeline

◆ IPoint

◆ IPoint32

◆ IRect

◆ ISize

◆ LinearGradientFillPipeline

◆ LinearGradientSSBOFillPipeline

◆ LinearToSrgbFilterPipeline

◆ MillisecondsF

◆ MixedOp

◆ MorphologyFilterPipeline

◆ MyMask

◆ PathComponentVariant

◆ PipelineMap

◆ PipelineProc

◆ Point

◆ PorterDuffBlendPipeline

◆ Quad

◆ RadialGradientFillPipeline

◆ RadialGradientSSBOFillPipeline

◆ Rect

◆ RRectBlurPipeline

◆ SamplerMap