| 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 |
| SkBBHFactory.h |
Insert N bounding boxes into the hierarchy.
|
1636 |
| 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.
|
54252 |
| SkBlender.h |
SkBlender represents a custom blend function in the Skia pipeline. When an SkBlender is
present in a paint, the SkBlendMode is ignored. A blender combines a source color (the
result of our paint) and destination color (from the canvas) into a final color.
|
856 |
| 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 SkBaseDevice.
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 SkBaseDevice describing the
destination.
SkCanvas can be constructed to draw to SkBitmap without first creating raster surface.
This approach may be deprecated in the future.
|
119089 |
| SkCanvasVirtualEnforcer.h |
|
2846 |
| SkCapabilities.h |
|
900 |
| SkClipOp.h |
|
344 |
| SkColor.h |
\file SkColor.h
Types, consts, functions, and macros for colors.
|
16382 |
| 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.
|
5021 |
| SkColorPriv.h |
Turn 0..255 into 0..256 by adding 1 at the half-way point. Used to turn a
byte into a scale value, so that we can say scale * value >> 8 instead of
alpha * value / 255.
In debugging, asserts that alpha is 0..255
|
5612 |
| SkColorSpace.h |
Describes a color gamut with primaries and a white point.
|
8128 |
| 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.
|
3341 |
| SkContourMeasure.h |
Return the length of the contour.
|
4391 |
| 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 |
| SkDeferredDisplayList.h |
This class contains pre-processed gpu operations that can be replayed into
an SkSurface via SkSurface::draw(SkDeferredDisplayList*).
|
3863 |
| SkDeferredDisplayListRecorder.h |
This class is intended to be used as:
Get an SkSurfaceCharacterization representing the intended gpu-backed destination SkSurface
Create one of these (an SkDeferredDisplayListRecorder) on the stack
Get the canvas and render into it
Snap off and hold on to an SkDeferredDisplayList
Once your app actually needs the pixels, call SkSurface::draw(SkDeferredDisplayList*)
This class never accesses the GPU but performs all the cpu work it can. It
is thread-safe (i.e., one can break a scene into tiles and perform their cpu-side
work in parallel ahead of time).
|
4047 |
| SkDocument.h |
SK_ScalarDefaultDPI is 72 dots per inch. |
2595 |
| 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.
|
7431 |
| SkDrawLooper.h |
\class SkDrawLooper
DEPRECATED: No longer supported in Skia.
|
4533 |
| SkEncodedImageFormat.h |
|
300 |
| 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.
|
3576 |
| SkFont.h |
\class SkFont
SkFont controls options applied when drawing and measuring text.
|
21512 |
| SkFontArguments.h |
Represents a set of actual arguments for a font. |
2768 |
| SkFontMetrics.h |
\class SkFontMetrics
The metrics of an SkFont.
The metric values are consistent with the Skia y-down coordinate system.
|
6184 |
| 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.
|
6333 |
| SkFontParameters.h |
|
1534 |
| SkFontStyle.h |
|
2488 |
| SkFontTypes.h |
|
782 |
| 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.
|
6356 |
| SkICC.h |
|
286 |
| SkImage.h |
\class SkImage
SkImage describes a two dimensional array of pixels to draw. The pixels may be
decoded in a raster bitmap, encoded in a SkPicture or compressed data stream,
or located in GPU memory as a GPU texture.
SkImage cannot be modified after it is created. SkImage may allocate additional
storage as needed; for instance, an encoded SkImage may decode when drawn.
SkImage width and height are greater than zero. Creating an SkImage with zero width
or height returns SkImage equal to nullptr.
SkImage may be created from SkBitmap, SkPixmap, SkSurface, SkPicture, encoded streams,
GPU texture, YUV_ColorSpace data, or hardware buffer. Encoded streams supported
include BMP, GIF, HEIF, ICO, JPEG, PNG, WBMP, WebP. Supported encoding details
vary with platform.
|
81886 |
| SkImageEncoder.h |
Encode SkPixmap in the given binary image format.
@param dst results are written to this stream.
@param src source pixels.
@param format image format, not all formats are supported.
@param quality range from 0-100, this is supported by jpeg and webp.
higher values correspond to improved visual quality, but less compression.
@return false iff input is bad or format is unsupported.
Will always return false if Skia is compiled without image
encoders.
For SkEncodedImageFormat::kWEBP, if quality is 100, it will use lossless compression. Otherwise
it will use lossy.
For examples of encoding an image to a file or to a block of memory,
see tools/ToolUtils.h.
|
2360 |
| 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.
|
4692 |
| SkImageGenerator.h |
The PixelRef which takes ownership of this SkImageGenerator
will call the image generator's destructor.
|
9777 |
| 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
|
24235 |
| SkM44.h |
|
14761 |
| 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.
|
1442 |
| 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.
|
1639 |
| 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.
|
73495 |
| 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.
|
18134 |
| 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.
|
3260 |
| 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.
|
25920 |
| 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.
|
78796 |
| 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.
|
3831 |
| 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).
|
3212 |
| 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.
|
11708 |
| 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.
|
4304 |
| 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.
|
4452 |
| 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.
|
32878 |
| SkPoint.h |
SkIVector provides an alternative name for SkIPoint. SkIVector and SkIPoint
can be used interchangeably for all purposes.
|
17160 |
| SkPoint3.h |
Returns the Euclidian distance from (0,0,0) to (x,y,z)
|
4246 |
| SkPromiseImageTexture.h |
This type is used to fulfill textures for PromiseImages. Once an instance is returned from a
PromiseImageTextureFulfillProc the GrBackendTexture it wraps must remain valid until the
corresponding PromiseImageTextureReleaseProc is called.
|
1576 |
| 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.
|
51091 |
| 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.
|
13424 |
| 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.
|
23472 |
| 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.
|
20410 |
| SkRSXform.h |
A compressed form of a rotation+scale matrix.
[ fSCos -fSSin fTx ]
[ fSSin fSCos fTy ]
[ 0 0 1 ]
|
1919 |
| 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/
|
3362 |
| SkScalar.h |
Returns true if x is not NaN and not infinite
|
6177 |
| 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.
|
2683 |
| SkShader.h |
\class SkShader
Shaders specify the 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 use 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.
|
3081 |
| SkSize.h |
Returns true iff fWidth == 0 && fHeight == 0
|
2818 |
| SkSpan.h |
|
489 |
| SkStream.h |
SkStream -- abstraction for a source of bytes. Subclasses can be backed by
memory, or a file, or something else.
NOTE:
Classic "streams" APIs are sort of async, in that on a request for N
bytes, they may return fewer than N bytes on a given call, in which case
the caller can "try again" to get more bytes, eventually (modulo an error)
receiving their total N bytes.
Skia streams behave differently. They are effectively synchronous, and will
always return all N bytes of the request if possible. If they return fewer
(the read() call returns the number of bytes read) then that means there is
no more data (at EOF or hit an error). The caller should *not* call again
in hopes of fulfilling more of the request.
|
18001 |
| SkString.h |
Some helper functions for C strings |
11501 |
| 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
|
4779 |
| SkSurface.h |
\class SkSurface
SkSurface is responsible for managing the pixels that a canvas draws into. The pixels can be
allocated either in CPU memory (a raster surface) or on the GPU (a GrRenderTarget surface).
SkSurface takes care of allocating a SkCanvas that will draw into the surface. Call
surface->getCanvas() to use that canvas (but don't delete it, it is owned by the surface).
SkSurface always has non-zero dimensions. If there is a request for a new surface, and either
of the requested dimensions are zero, then nullptr will be returned.
|
61615 |
| SkSurfaceCharacterization.h |
\class SkSurfaceCharacterization
A surface characterization contains all the information Ganesh requires to makes its internal
rendering decisions. When passed into a SkDeferredDisplayListRecorder it will copy the
data and pass it on to the SkDeferredDisplayList if/when it is created. Note that both of
those objects (the Recorder and the DisplayList) will take a ref on the
GrContextThreadSafeProxy and SkColorSpace objects.
|
11006 |
| 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.
|
2999 |
| SkSwizzle.h |
Swizzles byte order of |count| 32-bit pixels, swapping R and B.
(RGBA <-> BGRA)
|
402 |
| 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.
|
22119 |
| 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 |
| SkTileMode.h |
Replicate the edge color if the shader draws outside of its
original bounds.
|
886 |
| SkTime.h |
\class SkTime
Platform-implemented utilities to return time of day, and millisecond counter.
|
1753 |
| 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.
|
3836 |
| SkTypeface.h |
Machine endian. |
20560 |
| SkTypes.h |
SK_PMCOLOR_BYTE_ORDER can be used to query the byte order of SkPMColor at compile time.
|
5263 |
| 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
}
|
1146 |
| SkVertices.h |
An immutable set of vertex data that can be used with SkCanvas::drawVertices.
|
4417 |
| 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.
|
11986 |
| 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.
|
13759 |