| SkAlphaType.h |
\enum SkAlphaType
Describes how to interpret the alpha component of a pixel. A pixel may
be opaque, or alpha, describing multiple levels of transparency.
In simple blending, alpha weights the draw color and the destination
color to create a new color. If alpha describes a weight from zero to one:
new color = draw color * alpha + destination color * (1 - alpha)
In practice alpha is encoded in two or more bits, where 1.0 equals all bits set.
RGB may have alpha included in each component value; the stored
value is the original RGB multiplied by alpha. Premultiplied color
components improve performance.
|
1756 |
| SkAnnotation.h |
Annotate the canvas by associating the specified URL with the
specified rectangle (in local coordinates, just like drawRect).
The URL is expected to be escaped and be valid 7-bit ASCII.
If the backend of this canvas does not support annotations, this call is
safely ignored.
The caller is responsible for managing its ownership of the SkData.
|
1446 |
| SkArc.h |
|
2354 |
| SkBBHFactory.h |
Insert N bounding boxes into the hierarchy.
|
1751 |
| SkBitmap.h |
\class SkBitmap
SkBitmap describes a two-dimensional raster pixel array. SkBitmap is built on
SkImageInfo, containing integer width and height, SkColorType and SkAlphaType
describing the pixel format, and SkColorSpace describing the range of colors.
SkBitmap points to SkPixelRef, which describes the physical array of pixels.
SkImageInfo bounds may be located anywhere fully inside SkPixelRef bounds.
SkBitmap can be drawn using SkCanvas. SkBitmap can be a drawing destination for SkCanvas
draw member functions. SkBitmap flexibility as a pixel container limits some
optimizations available to the target platform.
If pixel array is primarily read-only, use SkImage for better performance.
If pixel array is primarily written to, use SkSurface for better performance.
Declaring SkBitmap const prevents altering SkImageInfo: the SkBitmap height, width,
and so on cannot change. It does not affect SkPixelRef: a caller may write its
pixels. Declaring SkBitmap const affects SkBitmap configuration, not its contents.
SkBitmap is not thread safe. Each thread must have its own copy of SkBitmap fields,
although threads may share the underlying pixel array.
|
54321 |
| SkBlender.h |
SkBlender represents a custom blend function in the Skia pipeline. A blender combines a source
color (the result of our paint) and destination color (from the canvas) into a final color.
|
747 |
| SkBlendMode.h |
Blends are operators that take in two colors (source, destination) and return a new color.
Many of these operate the same on all 4 components: red, green, blue, alpha. For these,
we just document what happens to one component, rather than naming each one separately.
Different SkColorTypes have different representations for color components:
8-bit: 0..255
6-bit: 0..63
5-bit: 0..31
4-bit: 0..15
floats: 0...1
The documentation is expressed as if the component values are always 0..1 (floats).
For brevity, the documentation uses the following abbreviations
s : source
d : destination
sa : source alpha
da : destination alpha
Results are abbreviated
r : if all 4 components are computed in the same manner
ra : result alpha component
rc : result "color": red, green, blue components
|
4247 |
| SkBlurTypes.h |
|
524 |
| SkCanvas.h |
\class SkCanvas
SkCanvas provides an interface for drawing, and how the drawing is clipped and transformed.
SkCanvas contains a stack of SkMatrix and clip values.
SkCanvas and SkPaint together provide the state to draw into SkSurface or SkDevice.
Each SkCanvas draw call transforms the geometry of the object by the concatenation of all
SkMatrix values in the stack. The transformed geometry is clipped by the intersection
of all of clip values in the stack. The SkCanvas draw calls use SkPaint to supply drawing
state such as color, SkTypeface, text size, stroke width, SkShader and so on.
To draw to a pixel-based destination, create raster surface or GPU surface.
Request SkCanvas from SkSurface to obtain the interface to draw.
SkCanvas generated by raster surface draws to memory visible to the CPU.
SkCanvas generated by GPU surface uses Vulkan or OpenGL to draw to the GPU.
To draw to a document, obtain SkCanvas from SVG canvas, document PDF, or SkPictureRecorder.
SkDocument based SkCanvas and other SkCanvas subclasses reference SkDevice describing the
destination.
SkCanvas can be constructed to draw to SkBitmap without first creating raster surface.
This approach may be deprecated in the future.
|
126835 |
| SkCanvasVirtualEnforcer.h |
|
2846 |
| SkCapabilities.h |
|
783 |
| SkClipOp.h |
|
344 |
| SkColor.h |
\file SkColor.h
Types, consts, functions, and macros for colors.
|
16652 |
| SkColorFilter.h |
ColorFilters are optional objects in the drawing pipeline. When present in
a paint, they are called with the "src" colors, and return new colors, which
are then passed onto the next stage (either ImageFilter or Xfermode).
All subclasses are required to be reentrant-safe : it must be legal to share
the same instance between several threads.
|
5864 |
| SkColorSpace.h |
Describes a color gamut with primaries and a white point.
|
15646 |
| SkColorTable.h |
SkColorTable holds the lookup tables for each channel (ARGB) used to define the filter behavior
of `SkColorFilters::Table`, and provides a way to share the table data between client code and
the returned SkColorFilter. Once created, an SkColorTable is immutable.
|
2272 |
| SkColorType.h |
\enum SkColorType
Describes how pixel bits encode color. A pixel may be an alpha mask, a grayscale, RGB, or ARGB.
kN32_SkColorType selects the native 32-bit ARGB format for the current configuration. This can
lead to inconsistent results across platforms, so use with caution.
By default, Skia operates with the assumption of a little-Endian system. The names of each
SkColorType implicitly define the channel ordering and size in memory. Due to historical reasons
the names do not follow 100% identical convention, but are typically labeled from least
significant to most significant. To help clarify when the actual data layout differs from the
default convention, every SkColorType's comment includes a bit-labeled description of a pixel
in that color type on a LE system.
Unless specified otherwise, a channel's value is treated as an unsigned integer with a range of
of [0, 2^N-1] and this is mapped uniformly to a floating point value of [0.0, 1.0]. Some color
types instead store data directly in 32-bit floating point (assumed to be IEEE), or in 16-bit
"half" floating point values. A half float, or F16/float16, is interpreted as FP 1-5-10 or
Bits: [sign:15 exp:14..10 man:9..0]
|
7940 |
| SkContourMeasure.h |
Return the length of the contour.
|
6935 |
| SkCoverageMode.h |
Describes geometric operations (ala SkRegion::Op) that can be applied to coverage bytes.
These can be thought of as variants of porter-duff (SkBlendMode) modes, but only applied
to the alpha channel.
See SkMaskFilter for ways to use these when combining two different masks.
|
792 |
| SkCubicMap.h |
Fast evaluation of a cubic ease-in / ease-out curve. This is defined as a parametric cubic
curve inside the unit square.
pt[0] is implicitly { 0, 0 }
pt[3] is implicitly { 1, 1 }
pts[1,2].X are inside the unit [0..1]
|
1071 |
| SkData.h |
SkData holds an immutable data buffer. Not only is the data immutable,
but the actual ptr that is returned (by data() or bytes()) is guaranteed
to always be the same for the life of this instance.
|
6325 |
| SkDataTable.h |
Like SkData, SkDataTable holds an immutable data buffer. The data buffer is
organized into a table of entries, each with a length, so the entries are
not required to all be the same size.
|
3825 |
| SkDocument.h |
SK_ScalarDefaultDPI is 72 dots per inch. |
2705 |
| SkDrawable.h |
Base-class for objects that draw into SkCanvas.
The object has a generation ID, which is guaranteed to be unique across all drawables. To
allow for clients of the drawable that may want to cache the results, the drawable must
change its generation ID whenever its internal state changes such that it will draw differently.
|
7527 |
| SkExecutor.h |
|
1354 |
| SkFlattenable.h |
\class SkFlattenable
SkFlattenable is the base class for objects that need to be flattened
into a data stream for either transport or as part of the key to the
font cache.
|
3570 |
| SkFont.h |
\class SkFont
SkFont controls options applied when drawing and measuring text.
|
21233 |
| SkFontArguments.h |
Represents a set of actual arguments for a font. |
2798 |
| SkFontMetrics.h |
\class SkFontMetrics
The metrics of an SkFont.
The metric values are consistent with the Skia y-down coordinate system.
|
6190 |
| SkFontMgr.h |
The caller must call unref() on the returned object.
Never returns NULL; will return an empty set if the name is not found.
Passing nullptr as the parameter will return the default system family.
Note that most systems don't have a default system family, so passing nullptr will often
result in the empty set.
It is possible that this will return a style set not accessible from
createStyleSet(int) due to hidden or auto-activated fonts.
|
5946 |
| SkFontParameters.h |
|
1525 |
| SkFontScanner.h |
instanceIndex 0 is the default instance, 1 to numInstances are the named instances. |
1783 |
| SkFontStyle.h |
|
2498 |
| SkFontTypes.h |
|
782 |
| SkFourByteTag.h |
|
448 |
| SkGraphics.h |
Call this at process initialization time if your environment does not
permit static global initializers that execute code.
Init() is thread-safe and idempotent.
|
6420 |
| SkImage.h |
Caller data passed to RasterReleaseProc; may be nullptr. |
45551 |
| SkImageFilter.h |
Base class for image filters. If one is installed in the paint, then all drawing occurs as
usual, but it is as if the drawing happened into an offscreen (before the xfermode is applied).
This offscreen bitmap will then be handed to the imagefilter, who in turn creates a new bitmap
which is what will finally be drawn to the device (using the original xfermode).
The local space of image filters matches the local space of the drawn geometry. For instance if
there is rotation on the canvas, the blur will be computed along those rotated axes and not in
the device space. In order to achieve this result, the actual drawing of the geometry may happen
in an unrotated coordinate system so that the filtered image can be computed more easily, and
then it will be post transformed to match what would have been produced if the geometry were
drawn with the total canvas matrix to begin with.
|
4792 |
| SkImageGenerator.h |
The PixelRef which takes ownership of this SkImageGenerator
will call the image generator's destructor.
|
5084 |
| SkImageInfo.h |
Returns the number of bytes required to store a pixel, including unused padding.
Returns zero if ct is kUnknown_SkColorType or invalid.
@return bytes per pixel
|
25114 |
| SkM44.h |
|
14774 |
| SkMallocPixelRef.h |
We explicitly use the same allocator for our pixels that SkMask does,
so that we can freely assign memory allocated by one class to the other.
|
1444 |
| SkMaskFilter.h |
\class SkMaskFilter
SkMaskFilter is the base class for object that perform transformations on
the mask before drawing it. An example subclass is Blur.
|
1351 |
| SkMatrix.h |
When we transform points through a matrix containing perspective (the bottom row is something
other than 0,0,1), the bruteforce math can produce confusing results (since we might divide
by 0, or a negative w value). By default, methods that map rects and paths will apply
perspective clipping, but this can be changed by specifying kYes to those methods.
|
73401 |
| SkMesh.h |
A specification for custom meshes. Specifies the vertex buffer attributes and stride, the
vertex program that produces a user-defined set of varyings, and a fragment program that ingests
the interpolated varyings and produces local coordinates for shading and optionally a color.
The varyings must include a float2 named "position". If the passed varyings does not
contain such a varying then one is implicitly added to the final specification and the SkSL
Varyings struct described below. It is an error to have a varying named "position" that has a
type other than float2.
The provided attributes and varyings are used to create Attributes and Varyings structs in SkSL
that are used by the shaders. Each attribute from the Attribute span becomes a member of the
SkSL Attributes struct and likewise for the varyings.
The signature of the vertex program must be:
Varyings main(const Attributes).
The signature of the fragment program must be either:
float2 main(const Varyings)
or
float2 main(const Varyings, out (half4|float4) color)
where the return value is the local coordinates that will be used to access SkShader. If the
color variant is used, the returned color will be blended with SkPaint's SkShader (or SkPaint
color in absence of a SkShader) using the SkBlender passed to SkCanvas drawMesh(). To use
interpolated local space positions as the shader coordinates, equivalent to how SkPaths are
shaded, return the position field from the Varying struct as the coordinates.
The vertex and fragment programs may both contain uniforms. Uniforms with the same name are
assumed to be shared between stages. It is an error to specify uniforms in the vertex and
fragment program with the same name but different types, dimensionality, or layouts.
|
18002 |
| SkMilestone.h |
|
197 |
| SkOpenTypeSVGDecoder.h |
Each instance probably owns an SVG DOM.
The instance may be cached so needs to report how much memory it retains.
|
809 |
| SkOverdrawCanvas.h |
Captures all drawing commands. Rather than draw the actual content, this device
increments the alpha channel of each pixel every time it would have been touched
by a draw call. This is useful for detecting overdraw.
|
3802 |
| SkPaint.h |
\class SkPaint
SkPaint controls options applied when drawing. SkPaint collects all
options outside of the SkCanvas clip and SkCanvas matrix.
Various options apply to strokes and fills, and images.
SkPaint collects effects and filters that describe single-pass and multiple-pass
algorithms that alter the drawing geometry, color, and transparency. For instance,
SkPaint does not directly implement dashing or blur, but contains the objects that do so.
|
26178 |
| SkPath.h |
\class SkPath
SkPath contain geometry. SkPath may be empty, or contain one or more verbs that
outline a figure. SkPath always starts with a move verb to a Cartesian coordinate,
and may be followed by additional verbs that add lines or curves.
Adding a close verb makes the geometry into a continuous loop, a closed contour.
SkPath may contain any number of contours, each beginning with a move verb.
SkPath contours may contain only a move verb, or may also contain lines,
quadratic beziers, conics, and cubic beziers. SkPath contours may be open or
closed.
When used to draw a filled area, SkPath describes whether the fill is inside or
outside the geometry. SkPath also describes the winding rule used to fill
overlapping contours.
Internally, SkPath lazily computes metrics likes bounds and convexity. Call
SkPath::updateBoundsCache to make SkPath thread safe.
|
80509 |
| SkPathBuilder.h |
Appends arc to the builder. Arc added is part of ellipse
bounded by oval, from startAngle through sweepAngle. Both startAngle and
sweepAngle are measured in degrees, where zero degrees is aligned with the
positive x-axis, and positive sweeps extends arc clockwise.
arcTo() adds line connecting the builder's last point to initial arc point if forceMoveTo
is false and the builder is not empty. Otherwise, added contour begins with first point
of arc. Angles greater than -360 and less than 360 are treated modulo 360.
@param oval bounds of ellipse containing arc
@param startAngleDeg starting angle of arc in degrees
@param sweepAngleDeg sweep, in degrees. Positive is clockwise; treated modulo 360
@param forceMoveTo true to start a new contour with arc
@return reference to the builder
|
11420 |
| SkPathEffect.h |
\class SkPathEffect
SkPathEffect is the base class for objects in the SkPaint that affect
the geometry of a drawing primitive before it is transformed by the
canvas' matrix and drawn.
Dashing is implemented as a subclass of SkPathEffect.
|
3061 |
| SkPathMeasure.h |
Initialize the pathmeasure with the specified path. The parts of the path that are needed
are copied, so the client is free to modify/delete the path after this call.
resScale controls the precision of the measure. values > 1 increase the
precision (and possibly slow down the computation).
|
3365 |
| SkPathTypes.h |
Specifies that "inside" is computed by a non-zero sum of signed edge crossings |
1725 |
| SkPathUtils.h |
Returns the filled equivalent of the stroked path.
@param src SkPath read to create a filled version
@param paint SkPaint, from which attributes such as stroke cap, width, miter, and join,
as well as pathEffect will be used.
@param dst resulting SkPath; may be the same as src, but may not be nullptr
@param cullRect optional limit passed to SkPathEffect
@param resScale if > 1, increase precision, else if (0 < resScale < 1) reduce precision
to favor speed and size
@return true if the dst path was updated, false if it was not (e.g. if the path
represents hairline and cannot be filled).
|
1488 |
| SkPicture.h |
\class SkPicture
SkPicture records drawing commands made to SkCanvas. The command stream may be
played in whole or in part at a later time.
SkPicture is an abstract class. SkPicture may be generated by SkPictureRecorder
or SkDrawable, or from SkPicture previously saved to SkData or SkStream.
SkPicture may contain any SkCanvas drawing command, as well as one or more
SkCanvas matrix or SkCanvas clip. SkPicture has a cull SkRect, which is used as
a bounding box hint. To limit SkPicture bounds, use SkCanvas clip when
recording or drawing SkPicture.
|
12366 |
| SkPictureRecorder.h |
Returns the canvas that records the drawing commands.
@param bounds the cull rect used when recording this picture. Any drawing the falls outside
of this rect is undefined, and may be drawn or it may not.
@param bbh optional acceleration structure
@param recordFlags optional flags that control recording.
@return the canvas.
|
4344 |
| SkPixelRef.h |
\class SkPixelRef
This class is the smart container for pixel memory, and is used with SkBitmap.
This class can be shared/accessed between multiple threads.
|
4341 |
| SkPixmap.h |
\class SkPixmap
SkPixmap provides a utility to pair SkImageInfo with pixels and row bytes.
SkPixmap is a low level class which provides convenience functions to access
raster destinations. SkCanvas can not draw SkPixmap, nor does SkPixmap provide
a direct drawing destination.
Use SkBitmap to draw pixels referenced by SkPixmap; use SkSurface to draw into
pixels referenced by SkPixmap.
SkPixmap does not try to manage the lifetime of the pixel memory. Use SkPixelRef
to manage pixel memory; SkPixelRef is safe across threads.
|
32036 |
| SkPoint.h |
|
395 |
| SkPoint3.h |
Returns the Euclidian distance from (0,0,0) to (x,y,z)
|
4017 |
| SkRasterHandleAllocator.h |
If a client wants to control the allocation of raster layers in a canvas, it should subclass
SkRasterHandleAllocator. This allocator performs two tasks:
1. controls how the memory for the pixels is allocated
2. associates a "handle" to a private object that can track the matrix/clip of the SkCanvas
This example allocates a canvas, and defers to the allocator to create the base layer.
std::unique_ptr<SkCanvas> canvas = SkRasterHandleAllocator::MakeCanvas(
SkImageInfo::Make(...),
std::make_unique<MySubclassRasterHandleAllocator>(...),
nullptr);
If you have already allocated the base layer (and its handle, release-proc etc.) then you
can pass those in using the last parameter to MakeCanvas().
Regardless of how the base layer is allocated, each time canvas->saveLayer() is called,
your allocator's allocHandle() will be called.
|
3915 |
| SkRect.h |
\struct SkIRect
SkIRect holds four 32-bit integer coordinates describing the upper and
lower bounds of a rectangle. SkIRect may be created from outer bounds or
from position, width, and height. SkIRect describes an area; if its right
is less than or equal to its left, or if its bottom is less than or equal to
its top, it is considered empty.
|
49832 |
| SkRefCnt.h |
\class SkRefCntBase
SkRefCntBase is the base class for objects that may be shared by multiple
objects. When an existing owner wants to share a reference, it calls ref().
When an owner wants to release its reference, it calls unref(). When the
shared object's reference count goes to zero as the result of an unref()
call, its (virtual) destructor is called. It is an error for the
destructor to be called explicitly (or via the object going out of scope on
the stack or calling delete) if getRefCnt() > 1.
|
13462 |
| SkRegion.h |
\class SkRegion
SkRegion describes the set of pixels used to clip SkCanvas. SkRegion is compact,
efficiently storing a single integer rectangle, or a run length encoded array
of rectangles. SkRegion may reduce the current SkCanvas clip, or may be drawn as
one or more integer rectangles. SkRegion iterator returns the scan lines or
rectangles contained by it, optionally intersecting a bounding rectangle.
|
23639 |
| SkRRect.h |
\class SkRRect
SkRRect describes a rounded rectangle with a bounds and a pair of radii for each corner.
The bounds and radii can be set so that SkRRect describes: a rectangle with sharp corners;
a circle; an oval; or a rectangle with one or more rounded corners.
SkRRect allows implementing CSS properties that describe rounded corners.
SkRRect may have up to eight different radii, one for each axis on each of its four
corners.
SkRRect may modify the provided parameters when initializing bounds and radii.
If either axis radii is zero or less: radii are stored as zero; corner is square.
If corner curves overlap, radii are proportionally reduced to fit within bounds.
|
20601 |
| SkRSXform.h |
A compressed form of a rotation+scale matrix.
[ fSCos -fSSin fTx ]
[ fSSin fSCos fTy ]
[ 0 0 1 ]
|
1994 |
| SkSamplingOptions.h |
Specify B and C (each between 0...1) to create a shader that applies the corresponding
cubic reconstruction filter to the image.
Example values:
B = 1/3, C = 1/3 "Mitchell" filter
B = 0, C = 1/2 "Catmull-Rom" filter
See "Reconstruction Filters in Computer Graphics"
Don P. Mitchell
Arun N. Netravali
1988
https://www.cs.utexas.edu/~fussell/courses/cs384g-fall2013/lectures/mitchell/Mitchell.pdf
Desmos worksheet https://www.desmos.com/calculator/aghdpicrvr
Nice overview https://entropymine.com/imageworsener/bicubic/
|
3491 |
| SkScalar.h |
Returns the fractional part of the scalar. |
5663 |
| SkSerialProcs.h |
A serial-proc is asked to serialize the specified object (e.g. picture or image).
If a data object is returned, it will be used (even if it is zero-length).
If null is returned, then Skia will take its default action.
The default action for pictures is to use Skia's internal format.
The default action for images is to encode either in its native format or PNG.
The default action for typefaces is to use Skia's internal format.
|
4569 |
| SkShader.h |
\class SkShader
Shaders specify the premultiplied source color(s) for what is being drawn.
If a paint has no shader, then the paint's color is used. If the paint has a
shader, then the shader's color(s) are used instead, but they are
modulated by the paint's alpha. This makes it easy to create a shader
once (e.g. bitmap tiling or gradient) and then change its transparency
w/o having to modify the original shader... only the paint's alpha needs
to be modified.
|
4179 |
| SkSize.h |
Returns true iff fWidth == 0 && fHeight == 0
|
2905 |
| SkSpan.h |
|
489 |
| SkStream.h |
SkStream -- abstraction for a source of bytes. Subclasses can be backed by
memory, or a file, or something else.
|
17675 |
| SkString.h |
Some helper functions for C strings |
11725 |
| SkStrokeRec.h |
Specify the strokewidth, and optionally if you want stroke + fill.
Note, if width==0, then this request is taken to mean:
strokeAndFill==true -> new style will be Fill
strokeAndFill==false -> new style will be Hairline
|
4882 |
| SkSurface.h |
Returns SkSurface without backing pixels. Drawing to SkCanvas returned from SkSurface
has no effect. Calling makeImageSnapshot() on returned SkSurface returns nullptr.
@param width one or greater
@param height one or greater
@return SkSurface if width and height are positive; otherwise, nullptr
example: https://fiddle.skia.org/c/@Surface_MakeNull
|
32375 |
| SkSurfaceProps.h |
Description of how the LCD strips are arranged for each pixel. If this is unknown, or the
pixels are meant to be "portable" and/or transformed before showing (e.g. rotated, scaled)
then use kUnknown_SkPixelGeometry.
|
4084 |
| SkSwizzle.h |
Swizzles byte order of |count| 32-bit pixels, swapping R and B.
(RGBA <-> BGRA)
|
428 |
| SkTextBlob.h |
\class SkTextBlob
SkTextBlob combines multiple text runs into an immutable container. Each text
run consists of glyphs, SkPaint, and position. Only parts of SkPaint related to
fonts and text rendering are used by run.
|
22482 |
| SkTextureCompressionType.h |
Skia | GL_COMPRESSED_* | MTLPixelFormat* | VK_FORMAT_*_BLOCK
--------------------------------------------------------------------------------------
kETC2_RGB8_UNORM | ETC1_RGB8 | ETC2_RGB8 (iOS-only) | ETC2_R8G8B8_UNORM
| RGB8_ETC2 | |
--------------------------------------------------------------------------------------
kBC1_RGB8_UNORM | RGB_S3TC_DXT1_EXT | N/A | BC1_RGB_UNORM
--------------------------------------------------------------------------------------
kBC1_RGBA8_UNORM | RGBA_S3TC_DXT1_EXT | BC1_RGBA (macOS-only)| BC1_RGBA_UNORM
|
1122 |
| SkTiledImageUtils.h |
\namespace SkTiledImageUtils
SkTiledImageUtils' DrawImage/DrawImageRect methods are intended to be direct replacements
for their SkCanvas equivalents. The SkTiledImageUtils calls will break SkBitmap-backed
SkImages into smaller tiles and draw them if the original image is too large to be
uploaded to the GPU. If the original image doesn't need tiling or is already gpu-backed
the DrawImage/DrawImageRect calls will fall through to the matching SkCanvas call.
|
5191 |
| SkTileMode.h |
Replicate the edge color if the shader draws outside of its
original bounds.
|
886 |
| SkTraceMemoryDump.h |
Interface for memory tracing.
This interface is meant to be passed as argument to the memory dump methods of Skia objects.
The implementation of this interface is provided by the embedder.
|
4619 |
| SkTypeface.h |
Machine endian. |
19685 |
| SkTypes.h |
SK_PMCOLOR_BYTE_ORDER can be used to query the byte order of SkPMColor at compile time.
|
5449 |
| SkUnPreMultiply.h |
Usage:
const Scale* table = SkUnPreMultiply::GetScaleTable();
for (...) {
unsigned a = ...
SkUnPreMultiply::Scale scale = table[a];
red = SkUnPreMultiply::ApplyScale(scale, red);
...
// now red is unpremultiplied
}
|
1240 |
| SkVertices.h |
An immutable set of vertex data that can be used with SkCanvas::drawVertices.
|
4506 |
| SkYUVAInfo.h |
Specifies the structure of planes for a YUV image with optional alpha. The actual planar data
is not part of this structure and depending on usage is in external textures or pixmaps.
|
12093 |
| SkYUVAPixmaps.h |
SkYUVAInfo combined with per-plane SkColorTypes and row bytes. Fully specifies the SkPixmaps
for a YUVA image without the actual pixel memory and data.
|
13789 |