| Sk1DPathEffect.h |
Dash by replicating the specified path.
@param path The path to replicate (dash)
@param advance The space between instances of path
@param phase distance (mod advance) along path for its initial position
@param style how to transform path at each point (based on the current
position and tangent)
|
1204 |
| Sk2DPathEffect.h |
|
723 |
| SkBlenders.h |
Create a blender that implements the following:
k1 * src * dst + k2 * src + k3 * dst + k4
@param k1, k2, k3, k4 The four coefficients.
@param enforcePMColor If true, the RGB channels will be clamped to the calculated alpha.
|
693 |
| SkBlurDrawLooper.h |
DEPRECATED: No longer supported in Skia.
|
697 |
| SkBlurMaskFilter.h |
Create an emboss maskfilter
@param blurSigma standard deviation of the Gaussian blur to apply
before applying lighting (e.g. 3)
@param direction array of 3 scalars [x, y, z] specifying the direction of the light source
@param ambient 0...1 amount of ambient light
@param specular coefficient for specular highlights (e.g. 8)
@return the emboss maskfilter
|
1198 |
| SkColorMatrix.h |
|
1909 |
| SkColorMatrixFilter.h |
|
603 |
| SkCornerPathEffect.h |
\class SkCornerPathEffect
SkCornerPathEffect is a subclass of SkPathEffect that can turn sharp corners
into various treatments (e.g. rounded corners)
|
806 |
| SkDashPathEffect.h |
intervals: array containing an even number of entries (>=2), with
the even indices specifying the length of "on" intervals, and the odd
indices specifying the length of "off" intervals. This array will be
copied in Make, and can be disposed of freely after.
count: number of elements in the intervals array
phase: offset into the intervals array (mod the sum of all of the
intervals).
For example: if intervals[] = {10, 20}, count = 2, and phase = 25,
this will set up a dashed path like so:
5 pixels off
10 pixels on
20 pixels off
10 pixels on
20 pixels off
...
A phase of -5, 25, 55, 85, etc. would all result in the same path,
because the sum of all the intervals is 30.
Note: only affects stroked paths.
|
1374 |
| SkDiscretePathEffect.h |
\class SkDiscretePathEffect
This path effect chops a path into discrete segments, and randomly displaces them.
|
1404 |
| SkGradientShader.h |
\class SkGradientShader
SkGradientShader hosts factories for creating subclasses of SkShader that
render linear and radial gradients. In general, degenerate cases should not
produce surprising results, but there are several types of degeneracies:
A linear gradient made from the same two points.
A radial gradient with a radius of zero.
A sweep gradient where the start and end angle are the same.
A two point conical gradient where the two centers and the two radii are
the same.
For any degenerate gradient with a decal tile mode, it will draw empty since the interpolating
region is zero area and the outer region is discarded by the decal mode.
For any degenerate gradient with a repeat or mirror tile mode, it will draw a solid color that
is the average gradient color, since infinitely many repetitions of the gradients will fill the
shape.
For a clamped gradient, every type is well-defined at the limit except for linear gradients. The
radial gradient with zero radius becomes the last color. The sweep gradient draws the sector
from 0 to the provided angle with the first color, with a hardstop switching to the last color.
When the provided angle is 0, this is just the solid last color again. Similarly, the two point
conical gradient becomes a circle filled with the first color, sized to the provided radius,
with a hardstop switching to the last color. When the two radii are both zero, this is just the
solid last color.
As a linear gradient approaches the degenerate case, its shader will approach the appearance of
two half planes, each filled by the first and last colors of the gradient. The planes will be
oriented perpendicular to the vector between the two defining points of the gradient. However,
once they become the same point, Skia cannot reconstruct what that expected orientation is. To
provide a stable and predictable color in this case, Skia just uses the last color as a solid
fill to be similar to many of the other degenerate gradients' behaviors in clamp mode.
|
21076 |
| SkHighContrastFilter.h |
Configuration struct for SkHighContrastFilter.
Provides transformations to improve contrast for users with low vision.
|
2386 |
| SkImageFilters.h |
Create a filter that updates the alpha of the image based on 'region'. Pixels inside the
region are made more opaque and pixels outside are made more transparent.
Specifically, if a pixel is inside the region, its alpha will be set to
max(innerMin, pixel's alpha). If a pixel is outside the region, its alpha will be updated to
min(outerMax, pixel's alpha).
@param region The geometric region controlling the inner and outer alpha thresholds.
@param innerMin The minimum alpha value for pixels inside 'region'.
@param outerMax The maximum alpha value for pixels outside of 'region'.
@param input The input filter, or uses the source bitmap if this is null.
@param cropRect Optional rectangle that crops the input and output.
|
32450 |
| SkLayerDrawLooper.h |
DEPRECATED: No longer supported by Skia.
|
4788 |
| SkLumaColorFilter.h |
SkLumaColorFilter multiplies the luma of its input into the alpha channel,
and sets the red, green, and blue channels to zero.
SkLumaColorFilter(r,g,b,a) = {0,0,0, a * luma(r,g,b)}
This is similar to a luminanceToAlpha feColorMatrix,
but note how this filter folds in the previous alpha,
something an feColorMatrix cannot do.
feColorMatrix(luminanceToAlpha; r,g,b,a) = {0,0,0, luma(r,g,b)}
(Despite its name, an feColorMatrix using luminanceToAlpha does
actually compute luma, a dot-product of gamma-encoded color channels,
not luminance, a dot-product of linear color channels. So at least
SkLumaColorFilter and feColorMatrix+luminanceToAlpha agree there.)
|
1118 |
| SkOpPathEffect.h |
Defers to two other patheffects, and then combines their outputs using the specified op.
e.g.
result = output_one op output_two
If either one or two is nullptr, then the original path is passed through to the op.
|
1195 |
| SkOverdrawColorFilter.h |
Uses the value in the src alpha channel to set the dst pixel.
0 -> colors[0]
1 -> colors[1]
...
5 (or larger) -> colors[5]
|
734 |
| SkPerlinNoiseShader.h |
\class SkPerlinNoiseShader
SkPerlinNoiseShader creates an image using the Perlin turbulence function.
It can produce tileable noise if asked to stitch tiles and provided a tile size.
In order to fill a large area with repeating noise, set the stitchTiles flag to
true, and render exactly a single tile of noise. Without this flag, the result
will contain visible seams between tiles.
The algorithm used is described here :
http://www.w3.org/TR/SVG/filters.html#feTurbulenceElement
|
2260 |
| SkRuntimeEffect.h |
SkRuntimeEffect supports creating custom SkShader and SkColorFilter objects using Skia's SkSL
shading language.
NOTE: This API is experimental and subject to change.
|
20962 |
| SkShaderMaskFilter.h |
|
519 |
| SkStrokeAndFillPathEffect.h |
If the paint is set to stroke, this will add the stroke and fill geometries
together (hoping that the winding-direction works out).
If the paint is set to fill, this effect is ignored.
Note that if the paint is set to stroke and the stroke-width is 0, then
this will turn the geometry into just a fill.
|
807 |
| SkTableColorFilter.h |
|
902 |
| SkTableMaskFilter.h |
\class SkTableMaskFilter
Applies a table lookup on each of the alpha values in the mask.
Helper methods create some common tables (e.g. gamma, clipping)
|
1128 |
| SkTrimPathEffect.h |
Take start and stop "t" values (values between 0...1), and return a path that is that
subset of the original path.
e.g.
Make(0.5, 1.0) --> return the 2nd half of the path
Make(0.33333, 0.66667) --> return the middle third of the path
The trim values apply to the entire path, so if it contains several contours, all of them
are including in the calculation.
startT and stopT must be 0..1 inclusive. If they are outside of that interval, they will
be pinned to the nearest legal value. If either is NaN, null will be returned.
Note: for Mode::kNormal, this will return one (logical) segment (even if it is spread
across multiple contours). For Mode::kInverted, this will return 2 logical
segments: stopT..1 and 0...startT, in this order.
|
1544 |