10#if defined(SK_GRAPHITE)
68bool gNeedSKPPaintOption =
false;
78 create_random_image_filter(
SkRandom*);
82#define SK_ALL_TEST_SHADERS(M) \
100#define M(type) k##type,
101 SK_ALL_TEST_SHADERS(
M)
104 kLast = kWorkingColorSpace
107static constexpr int kShaderTypeCount =
static_cast<int>(ShaderType::kLast) + 1;
109const char* to_str(ShaderType
s) {
111#define M(type) case ShaderType::k##type : return "ShaderType::k" #type;
112 SK_ALL_TEST_SHADERS(
M)
121#define SK_ALL_TEST_BLENDERS(M) \
129enum class BlenderType {
130#define M(type) k##type,
131 SK_ALL_TEST_BLENDERS(
M)
137static constexpr int kBlenderTypeCount =
static_cast<int>(BlenderType::kLast) + 1;
139const char* to_str(BlenderType
b) {
141#define M(type) case BlenderType::k##type : return "BlenderType::k" #type;
142 SK_ALL_TEST_BLENDERS(
M)
151#define SK_ALL_TEST_COLORFILTERS(M) \
168enum class ColorFilterType {
169#define M(type) k##type,
170 SK_ALL_TEST_COLORFILTERS(
M)
173 kLast = kWorkingFormat
176static constexpr int kColorFilterTypeCount =
static_cast<int>(ColorFilterType::kLast) + 1;
178const char* to_str(ColorFilterType cf) {
180#define M(type) case ColorFilterType::k##type : return "ColorFilterType::k" #type;
181 SK_ALL_TEST_COLORFILTERS(
M)
190#define SK_ALL_TEST_CLIPS(M) \
196#define M(type) k##type,
201const char* to_str(ClipType c) {
203#define M(type) case ClipType::k##type : return "ClipType::k" #type;
213#define SK_ALL_TEST_IMAGE_FILTERS(M) \
217enum class ImageFilterType {
218#define M(type) k##type,
219 SK_ALL_TEST_IMAGE_FILTERS(
M)
224static constexpr int kImageFilterTypeCount =
static_cast<int>(ImageFilterType::kLast) + 1;
226const char* to_str(ImageFilterType c) {
228#define M(type) case ImageFilterType::k##type : return "ImageFilterType::k" #type;
229 SK_ALL_TEST_IMAGE_FILTERS(
M)
246static constexpr int kTransferFunctionCount = std::size(gTransferFunctions);
249 return gTransferFunctions[rand->
nextULessThan(kTransferFunctionCount)];
260static constexpr int kGamutCount = std::size(
gGamuts);
266enum class ColorSpaceType {
275static constexpr int kColorSpaceTypeCount =
static_cast<int>(ColorSpaceType::kLast) + 1;
277ColorSpaceType random_colorspacetype(
SkRandom* rand) {
278 return static_cast<ColorSpaceType
>(rand->
nextULessThan(kColorSpaceTypeCount));
282 ColorSpaceType cs = random_colorspacetype(rand);
285 case ColorSpaceType::kNone:
287 case ColorSpaceType::kSRGB:
289 case ColorSpaceType::kSRGBLinear:
291 case ColorSpaceType::kRGB:
298enum class ColorConstraint {
307 switch (constraint) {
308 case ColorConstraint::kNone:
return color;
309 case ColorConstraint::kOpaque:
return 0xff000000 |
color;
310 case ColorConstraint::kTransparent:
return 0x80000000 |
color;
322 switch (constraint) {
323 case ColorConstraint::kNone:
return result;
324 case ColorConstraint::kOpaque:
result.fA = 1.0f;
return result;
325 case ColorConstraint::kTransparent:
result.fA = 0.5f;
return result;
353BlenderType random_blendertype(
SkRandom* rand) {
354 return static_cast<BlenderType
>(rand->
nextULessThan(kBlenderTypeCount));
357ColorFilterType random_colorfiltertype(
SkRandom* rand) {
358 return static_cast<ColorFilterType
>(rand->
nextULessThan(kColorFilterTypeCount));
361ImageFilterType random_imagefiltertype(
SkRandom* rand) {
362 return static_cast<ImageFilterType
>(rand->
nextULessThan(kImageFilterTypeCount));
367 case 0:
return nullptr;
369 case 2: [[fallthrough]];
370 default: storage->
setTranslate(2.0f, 2.0f);
return storage;
412 auto [
s, o] = create_random_shader(rand, recorder);
416 return {
nullptr,
nullptr };
419 constexpr SkRect kSubset{0, 0, 256, 256};
442 o = PrecompileShaders::MakeFractalNoise();
448 o = PrecompileShaders::MakeTurbulence();
457 gNeedSKPPaintOption =
true;
460 SkMatrix* lmPtr = random_local_matrix(rand, &lmStorage);
475 ColorConstraint constraint = ColorConstraint::kNone) {
480 s = SkShaders::Color(random_color(rand, constraint));
481 o = PrecompileShaders::Color();
484 s = SkShaders::Color(random_color4f(rand, constraint), cs);
485 o = PrecompileShaders::Color(std::move(cs));
494 ColorConstraint constraint = ColorConstraint::kOpaque) {
496 SkPoint pts[2] = {{-100, -100},
498 SkColor colors[2] = {random_color(rand, constraint), random_color(rand, constraint)};
502 SkMatrix* lmPtr = random_local_matrix(rand, &lmStorage);
512 case SkShaderBase::GradientType::kLinear:
514 o = PrecompileShadersPriv::LinearGradient(
SkToBool(lmPtr));
516 case SkShaderBase::GradientType::kRadial:
518 o = PrecompileShadersPriv::RadialGradient(
SkToBool(lmPtr));
520 case SkShaderBase::GradientType::kSweep:
524 o = PrecompileShadersPriv::SweepGradient(
SkToBool(lmPtr));
526 case SkShaderBase::GradientType::kConical:
531 o = PrecompileShadersPriv::TwoPointConicalGradient(
SkToBool(lmPtr));
534 SkDEBUGFAIL(
"Gradient shader says its type is none");
543 auto [
s, o] = create_random_shader(rand, recorder);
547 return {
nullptr,
nullptr };
551 random_local_matrix(rand, &lmStorage);
553 return {
s->makeWithLocalMatrix(lmStorage), o->makeWithLocalMatrix() };
558 auto [
s, o] = create_random_shader(rand, recorder);
562 return {
nullptr,
nullptr };
565 auto [cf, cfO] = create_random_colorfilter(rand);
567 return {
s->makeWithColorFilter(std::move(cf)), o->makeWithColorFilter(std::move(cfO)) };
576 SkMatrix* lmPtr = random_local_matrix(rand, &lmStorage);
588 o = PrecompileShaders::Image();
590 s = SkShaders::RawImage(
make_image(rand, recorder),
594 o = PrecompileShaders::RawImage();
604 auto [blender, blenderO] = create_random_blender(rand);
606 auto [dstS, dstO] = create_random_shader(rand, recorder);
609 return {
nullptr,
nullptr };
612 auto [srcS, srcO] = create_random_shader(rand, recorder);
615 return {
nullptr,
nullptr };
618 auto s = SkShaders::Blend(std::move(blender), std::move(dstS), std::move(srcS));
627 auto [wrappedS, wrappedO] = create_random_shader(rand, recorder);
630 return {
nullptr,
nullptr };
642 ShaderType shaderType) {
644 switch (shaderType) {
645 case ShaderType::kNone:
646 return {
nullptr,
nullptr };
647 case ShaderType::kBlend:
648 return create_blend_shader(rand, recorder);
649 case ShaderType::kColorFilter:
650 return create_colorfilter_shader(rand, recorder);
651 case ShaderType::kCoordClamp:
652 return create_coord_clamp_shader(rand, recorder);
653 case ShaderType::kConicalGradient:
654 return create_gradient_shader(rand, SkShaderBase::GradientType::kConical);
655 case ShaderType::kEmpty:
656 return create_empty_shader(rand);
657 case ShaderType::kImage:
658 return create_image_shader(rand, recorder);
659 case ShaderType::kLinearGradient:
660 return create_gradient_shader(rand, SkShaderBase::GradientType::kLinear);
661 case ShaderType::kLocalMatrix:
662 return create_localmatrix_shader(rand, recorder);
663 case ShaderType::kPerlinNoise:
664 return create_perlin_noise_shader(rand);
665 case ShaderType::kPicture:
666 return create_picture_shader(rand);
667 case ShaderType::kRadialGradient:
668 return create_gradient_shader(rand, SkShaderBase::GradientType::kRadial);
669 case ShaderType::kSolidColor:
670 return create_solid_shader(rand);
671 case ShaderType::kSweepGradient:
672 return create_gradient_shader(rand, SkShaderBase::GradientType::kSweep);
673 case ShaderType::kWorkingColorSpace:
674 return create_workingCS_shader(rand, recorder);
682 return create_shader(rand, recorder, random_shadertype(rand));
691 case 0:
return create_gradient_shader(rand, SkShaderBase::GradientType::kConical,
692 ColorConstraint::kTransparent);
693 case 1:
return create_gradient_shader(rand, SkShaderBase::GradientType::kLinear,
694 ColorConstraint::kTransparent);
695 case 2:
return create_gradient_shader(rand, SkShaderBase::GradientType::kRadial,
696 ColorConstraint::kTransparent);
697 case 3:
return create_solid_shader(rand, ColorConstraint::kTransparent);
698 case 4:
return create_gradient_shader(rand, SkShaderBase::GradientType::kSweep,
699 ColorConstraint::kTransparent);
709 "half4 main(half4 src, half4 dst) {"
722 "half4 main(half4 src, half4 dst) {"
736 "uniform float blendFrac;"
739 "half4 main(half4 src, half4 dst) {"
740 "return (blendFrac * a.eval(src, dst)) + ((1 - blendFrac) * b.eval(src, dst));"
744 auto [
src, srcO] = src_blender();
745 auto [
dst, dstO] = dest_blender();
750 const float kUniforms[] = { 1.0f };
771 return { std::move(
b), std::move(o) };
778 case 0:
return src_blender();
779 case 1:
return dest_blender();
780 case 2:
return combo_blender();
783 return {
nullptr,
nullptr };
789 case BlenderType::kNone:
790 return {
nullptr,
nullptr };
791 case BlenderType::kPorterDuff:
792 return create_bm_blender(rand, random_porter_duff_bm(rand));
793 case BlenderType::kShaderBased:
794 return create_bm_blender(rand, random_complex_bm(rand));
795 case BlenderType::kArithmetic:
796 return create_arithmetic_blender();
797 case BlenderType::kRuntime:
798 return create_rt_blender(rand);
805 return create_blender(rand, random_blendertype(rand));
813 "half4 main(half4 c) {"
825 "half4 main(half4 c) {"
837 "uniform float blendFrac;"
838 "uniform colorFilter a;"
839 "uniform colorFilter b;"
840 "half4 main(half4 c) {"
841 "return (blendFrac * a.eval(c)) + ((1 - blendFrac) * b.eval(c));"
845 auto [
src, srcO] = double_colorfilter();
846 auto [
dst, dstO] = half_colorfilter();
851 const float kUniforms[] = { 0.5f };
857 return { std::move(cf) , std::move(o) };
865 case 0:
return double_colorfilter();
866 case 1:
return half_colorfilter();
867 case 2:
return combo_colorfilter();
870 return {
nullptr,
nullptr };
876 auto [
dst, dstO] = create_random_colorfilter(rand);
877 auto [
src, srcO] = create_random_colorfilter(rand);
881 std::tie(src, srcO) = create_random_colorfilter(rand);
898 PrecompileColorFilters::Lighting() };
910 random_colorspace(rand),
911 random_blend_mode(rand));
916 return { std::move(cf), std::move(o) };
924 return { std::move(cf), std::move(o) };
930 random_colorspace(rand)),
931 PrecompileColorFiltersPriv::ColorSpaceXform() };
948 auto [outerCF, outerO] = create_random_colorfilter(rand);
949 auto [innerCF, innerO] = create_random_colorfilter(rand);
954 PrecompileColorFilters::Compose({ std::move(outerO) }, { std::move(innerO) }) };
962 static constexpr uint8_t
kTable[256] = { 0 };
969 auto [childCF, childO] = create_random_colorfilter(rand);
972 return {
nullptr,
nullptr };
979 &random_xfer_function(rand),
984 { std::move(childO) });
986 return { std::move(cf), std::move(o) };
994 return { std::move(cf), std::move(o) };
999 ColorFilterType
type) {
1002 case ColorFilterType::kNone:
1003 return {
nullptr,
nullptr };
1004 case ColorFilterType::kBlendMode:
1005 return create_blendmode_colorfilter(rand);
1006 case ColorFilterType::kColorSpaceXform:
1007 return create_color_space_colorfilter(rand);
1008 case ColorFilterType::kCompose:
1009 return create_compose_colorfilter(rand);
1010 case ColorFilterType::kGaussian:
1011 return create_gaussian_colorfilter();
1012 case ColorFilterType::kHSLAMatrix:
1013 return create_hsla_matrix_colorfilter();
1014 case ColorFilterType::kLerp:
1015 return create_lerp_colorfilter(rand);
1016 case ColorFilterType::kLighting:
1017 return create_lighting_colorfilter();
1018 case ColorFilterType::kLinearToSRGB:
1019 return create_linear_to_srgb_colorfilter();
1020 case ColorFilterType::kLuma:
1021 return create_luma_colorfilter();
1022 case ColorFilterType::kMatrix:
1023 return create_matrix_colorfilter();
1024 case ColorFilterType::kRuntime:
1025 return create_rt_colorfilter(rand);
1026 case ColorFilterType::kSRGBToLinear:
1027 return create_srgb_to_linear_colorfilter();
1028 case ColorFilterType::kTable:
1029 return create_table_colorfilter();
1030 case ColorFilterType::kWorkingFormat:
1031 return create_workingformat_colorfilter(rand);
1039 return create_colorfilter(rand, random_colorfiltertype(rand));
1051 case 0: sigma = 1.0f;
break;
1052 case 1: sigma = 2.0f;
break;
1053 case 2: [[fallthrough]];
1054 default: sigma = 5.0f;
break;
1058 *imageFilterMask |= PrecompileImageFilters::kBlur;
1065 ImageFilterType
type) {
1071 case ImageFilterType::kNone:
1073 case ImageFilterType::kBlur:
1074 imgFilter = blur_imagefilter(rand, &imageFilterMask);
1077 return { std::move(imgFilter), imageFilterMask };
1081 create_random_image_filter(
SkRandom* rand) {
1082 return create_image_filter(rand, random_imagefiltertype(rand));
1086std::pair<SkPaint, PaintOptions> create_paint(
SkRandom* rand,
1088 ShaderType shaderType,
1089 BlenderType blenderType,
1090 ColorFilterType colorFilterType,
1091 ImageFilterType imageFilterType) {
1093 paint.setColor(random_color(rand, ColorConstraint::kOpaque));
1098 auto [
s, o] = create_shader(rand, recorder, shaderType);
1102 paint.setShader(std::move(
s));
1108 auto [cf, o] = create_colorfilter(rand, colorFilterType);
1112 paint.setColorFilter(std::move(cf));
1118 auto [
b, o] = create_blender(rand, blenderType);
1122 paint.setBlender(std::move(
b));
1128 auto [filter, filterO] = create_image_filter(rand, imageFilterType);
1132 paint.setImageFilter(std::move(filter));
1138 paint.setDither(
true);
1142 return {
paint, paintOptions };
1147 dict->
lookup(
id).dump(dict);
1157 path.lineTo(16, 16);
1162 return path.detach();
1178 if (!
paint.getShader() &&
1179 !
paint.getColorFilter() &&
1180 !
paint.getImageFilter() &&
1181 paint.asBlendMode().has_value()) {
1188 paint.asBlendMode().value());
1204 const DrawData& drawData) {
1206 int before = context->priv().globalCache()->numGraphicsPipelines();
1209 std::vector<skgpu::UniqueKey> beforeKeys;
1221 SkCanvas* canvas = surf->getCanvas();
1224 case ClipType::kNone:
1226 case ClipType::kShader:
1230 case ClipType::kShader_Diff:
1237 case DrawTypeFlags::kSimpleShape:
1238 simple_draws(canvas,
paint);
1240 case DrawTypeFlags::kNonSimpleShape:
1241 non_simple_draws(canvas,
paint, drawData);
1243 case DrawTypeFlags::kShape:
1244 simple_draws(canvas,
paint);
1245 non_simple_draws(canvas,
paint, drawData);
1247 case DrawTypeFlags::kText:
1250 case DrawTypeFlags::kDrawVertices:
1259 std::unique_ptr<skgpu::graphite::Recording> recording = recorder->
snap();
1260 context->insertRecording({ recording.get() });
1264 int after = context->priv().globalCache()->numGraphicsPipelines();
1270 if (before != after) {
1271 const RendererProvider* rendererProvider = context->priv().rendererProvider();
1274 std::vector<skgpu::UniqueKey> afterKeys;
1279 if (std::find(beforeKeys.begin(), beforeKeys.end(), afterKey) == beforeKeys.end()) {
1283 &originalPipelineDesc,
1284 &originalRenderPassDesc);
1286 SkDebugf(
"------- New key from draw:\n");
1287 afterKey.dump(
"original key:");
1288 UniqueKeyUtils::DumpDescs(rendererProvider, dict,
1289 originalPipelineDesc,
1290 originalRenderPassDesc);
1328 std::unique_ptr<RuntimeEffectDictionary> rtDict = std::make_unique<RuntimeEffectDictionary>();
1330 auto dstTexInfo = context->priv().caps()->getDefaultSampledTextureInfo(
1332 skgpu::Mipmapped::kNo,
1333 skgpu::Protected::kNo,
1334 skgpu::Renderable::kNo);
1338 context->priv().resourceProvider(),
1344 KeyContext precompileKeyContext(context->priv().caps(),
1352 const char text[] =
"hambur";
1354 constexpr int kNumVerts = 4;
1355 constexpr SkPoint kPositions[kNumVerts] { {0,0}, {0,16}, {16,16}, {16,0} };
1359 DrawData drawData = {
1363 kPositions, kPositions, kColors),
1365 kPositions, kPositions,
nullptr),
1371 ShaderType::kRadialGradient,
1372 ShaderType::kSolidColor,
1375 ShaderType::kColorFilter,
1376 ShaderType::kCoordClamp,
1377 ShaderType::kConicalGradient,
1379 ShaderType::kLinearGradient,
1380 ShaderType::kLocalMatrix,
1381 ShaderType::kPerlinNoise,
1382 ShaderType::kPicture,
1383 ShaderType::kSweepGradient,
1384 ShaderType::kWorkingColorSpace,
1388 BlenderType blenders[] = {
1389 BlenderType::kPorterDuff,
1390 BlenderType::kShaderBased,
1391 BlenderType::kRuntime,
1394 BlenderType::kArithmetic,
1398 ColorFilterType colorFilters[] = {
1399 ColorFilterType::kNone,
1400 ColorFilterType::kBlendMode,
1401 ColorFilterType::kMatrix,
1403 ColorFilterType::kColorSpaceXform,
1404 ColorFilterType::kCompose,
1405 ColorFilterType::kGaussian,
1406 ColorFilterType::kHSLAMatrix,
1407 ColorFilterType::kLerp,
1408 ColorFilterType::kLighting,
1409 ColorFilterType::kLinearToSRGB,
1410 ColorFilterType::kLuma,
1411 ColorFilterType::kRuntime,
1412 ColorFilterType::kSRGBToLinear,
1413 ColorFilterType::kTable,
1414 ColorFilterType::kWorkingFormat,
1418 ClipType clips[] = {
1422 ClipType::kShader_Diff,
1426 ImageFilterType imageFilters[] = {
1427 ImageFilterType::kNone,
1429 ImageFilterType::kBlur,
1434 size_t kExpected = std::size(shaders) * std::size(blenders) * std::size(colorFilters) *
1435 std::size(clips) * std::size(imageFilters);
1439 for (
auto shader : shaders) {
1440 for (
auto blender : blenders) {
1441 for (
auto cf : colorFilters) {
1442 for (
auto clip : clips) {
1443 for (
auto imageFilter : imageFilters) {
1445 SkDebugf(
"%d/%zu\n", current, kExpected);
1449 shader, blender, cf,
clip, imageFilter);
1457 SkASSERT(current == (
int) kExpected);
1465 const DrawData& drawData,
1470 ImageFilterType imageFilter) {
1473 std::unique_ptr<Recorder> recorder = context->makeRecorder();
1480 if (
clip == ClipType::kShader ||
clip == ClipType::kShader_Diff) {
1481 std::tie(clipShader, clipShaderOption) = create_clip_shader(&rand, recorder.get());
1482 SkASSERT(!clipShader == !clipShaderOption);
1489 gNeedSKPPaintOption =
false;
1490 auto [
paint, paintOptions] = create_paint(&rand, recorder.get(),
s, bm, cf, imageFilter);
1493 DrawTypeFlags::kNonSimpleShape,
1494 DrawTypeFlags::kShape,
1495 DrawTypeFlags::kText,
1496 DrawTypeFlags::kDrawVertices }) {
1502 for (
bool withPrimitiveBlender : {
false,
true }) {
1505 if (withPrimitiveBlender) {
1506 if (dt != DrawTypeFlags::kDrawVertices) {
1514 constexpr Coverage coverageOptions[3] = {
1515 Coverage::kNone, Coverage::kSingleChannel, Coverage::kLCD};
1525 bool needsDstSample = dstReadReq == DstReadRequirement::kTextureCopy ||
1526 dstReadReq == DstReadRequirement::kTextureSample;
1535 if (
clip == ClipType::kShader_Diff && modifiedClipShader) {
1537 modifiedClipShader = modifiedClipShader->makeWithColorFilter(
1542 recorder.get(), ¶msGatherer, &builder, Layout::kMetal, {},
1545 std::move(modifiedClipShader),
1554 std::vector<UniquePaintParamsID> precompileIDs;
1556 &precompileGatherer,
1557 DrawTypeFlags::kNone,
1558 withPrimitiveBlender,
1564 precompileIDs.push_back(
id);
1576 auto result = std::find(precompileIDs.begin(), precompileIDs.end(), paintID);
1578 if (
result == precompileIDs.end()) {
1579 SkDebugf(
"Failure on case: %s %s %s %s %s\n",
1580 to_str(
s), to_str(bm), to_str(cf), to_str(
clip), to_str(imageFilter));
1584 if (
result == precompileIDs.end()) {
1586 dump(dict, paintID);
1588 SkDebugf(
"From combination builder [%d]:",
static_cast<int>(precompileIDs.size()));
1589 for (
auto iter : precompileIDs) {
1598 context->priv().globalCache()->resetGraphicsPipelines();
1600 int before = context->priv().globalCache()->numGraphicsPipelines();
1602 if (gNeedSKPPaintOption) {
1605 Precompile(context, skpPaintOptions, DrawTypeFlags::kSimpleShape);
1607 int after = context->priv().globalCache()->numGraphicsPipelines();
static void info(const char *fmt,...) SK_PRINTF_LIKE(1
@ kPremul_SkAlphaType
pixel components are premultiplied by alpha
#define SkDEBUGFAIL(message)
static constexpr int kSkBlendModeCount
@ kLastCoeffMode
last porter duff blend mode
@ kSrcOver
r = s + (1-sa)*d
@ kLastMode
last valid value
SkBlenderBase * as_BB(SkBlender *blend)
@ kAlpha_8_SkColorType
pixel with alpha in 8-bit byte
@ kRGBA_8888_SkColorType
pixel with 8 bits for red, green, blue, alpha; in 32-bit word
constexpr SkColor SK_ColorYELLOW
constexpr SkColor SK_ColorCYAN
constexpr SkColor SK_ColorBLUE
constexpr SkColor SK_ColorRED
constexpr SkColor SK_ColorBLACK
constexpr SkColor SK_ColorGREEN
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1
@ kJPEG_Full_SkYUVColorSpace
describes full range
static SkPath clip(const SkPath &path, const SkHalfPlane &plane)
sk_sp< T > sk_ref_sp(T *obj)
SkRuntimeEffect * SkMakeRuntimeEffect(SkRuntimeEffect::Result(*make)(SkString, const SkRuntimeEffect::Options &), const char *sksl, SkRuntimeEffect::Options options=SkRuntimeEffect::Options{})
SkShaderBase * as_SB(SkShader *shader)
static constexpr int kSkTileModeCount
static constexpr bool SkToBool(const T &x)
static void dump(const float m[20], SkYUVColorSpace cs, bool rgb2yuv)
#define DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS(name, reporter, graphite_ctx, test_ctx, cond, ctsEnforcement)
#define REPORTER_ASSERT(r, cond,...)
virtual std::optional< SkBlendMode > asBlendMode() const
static sk_sp< SkBlender > Mode(SkBlendMode mode)
static sk_sp< SkBlender > Arithmetic(float k1, float k2, float k3, float k4, bool enforcePremul)
void drawRect(const SkRect &rect, const SkPaint &paint)
void experimental_DrawEdgeAAQuad(const SkRect &rect, const SkPoint clip[4], QuadAAFlags aaFlags, const SkColor4f &color, SkBlendMode mode)
void drawRRect(const SkRRect &rrect, const SkPaint &paint)
void drawPath(const SkPath &path, const SkPaint &paint)
void clipShader(sk_sp< SkShader >, SkClipOp=SkClipOp::kIntersect)
void drawVertices(const SkVertices *vertices, SkBlendMode mode, const SkPaint &paint)
void drawTextBlob(const SkTextBlob *blob, SkScalar x, SkScalar y, const SkPaint &paint)
static sk_sp< SkColorFilter > WithWorkingFormat(sk_sp< SkColorFilter > child, const skcms_TransferFunction *tf, const skcms_Matrix3x3 *gamut, const SkAlphaType *at)
static sk_sp< SkColorFilter > MakeColorSpaceXform(sk_sp< SkColorSpace > src, sk_sp< SkColorSpace > dst)
static sk_sp< SkColorFilter > MakeGaussian()
static sk_sp< SkColorFilter > Compose(const sk_sp< SkColorFilter > &outer, sk_sp< SkColorFilter > inner)
static sk_sp< SkColorFilter > Blend(const SkColor4f &c, sk_sp< SkColorSpace >, SkBlendMode mode)
static sk_sp< SkColorFilter > Table(const uint8_t table[256])
static sk_sp< SkColorFilter > Matrix(const SkColorMatrix &)
static sk_sp< SkColorFilter > HSLAMatrix(const SkColorMatrix &)
static sk_sp< SkColorFilter > Lighting(SkColor mul, SkColor add)
static sk_sp< SkColorFilter > SRGBToLinearGamma()
static sk_sp< SkColorFilter > Lerp(float t, sk_sp< SkColorFilter > dst, sk_sp< SkColorFilter > src)
static sk_sp< SkColorFilter > LinearToSRGBGamma()
static SkColorMatrix RGBtoYUV(SkYUVColorSpace)
static sk_sp< SkColorSpace > MakeSRGB()
static sk_sp< SkColorSpace > MakeRGB(const skcms_TransferFunction &transferFn, const skcms_Matrix3x3 &toXYZ)
static sk_sp< SkColorSpace > MakeSRGBLinear()
static sk_sp< SkData > MakeWithCopy(const void *data, size_t length)
static sk_sp< SkShader > MakeTwoPointConical(const SkPoint &start, SkScalar startRadius, const SkPoint &end, SkScalar endRadius, const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)
static sk_sp< SkShader > MakeSweep(SkScalar cx, SkScalar cy, const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, SkScalar startAngle, SkScalar endAngle, uint32_t flags, const SkMatrix *localMatrix)
static sk_sp< SkShader > MakeRadial(const SkPoint ¢er, SkScalar radius, const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)
static sk_sp< SkShader > MakeLinear(const SkPoint pts[2], const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)
@ kInterpolateColorsInPremul_Flag
static sk_sp< SkImageFilter > Blur(SkScalar sigmaX, SkScalar sigmaY, SkTileMode tileMode, sk_sp< SkImageFilter > input, const CropRect &cropRect={})
SkMatrix & setTranslate(SkScalar dx, SkScalar dy)
static const SkMatrix & I()
SkCanvas * beginRecording(const SkRect &bounds, sk_sp< SkBBoxHierarchy > bbh)
sk_sp< SkPicture > finishRecordingAsPicture()
sk_sp< SkShader > makeShader(SkTileMode tmx, SkTileMode tmy, SkFilterMode mode, const SkMatrix *localMatrix, const SkRect *tileRect) const
static SkRRect MakeOval(const SkRect &oval)
static SkRRect MakeRectXY(const SkRect &rect, SkScalar xRad, SkScalar yRad)
uint32_t nextULessThan(uint32_t count)
float nextRangeF(float min, float max)
uint32_t nextRangeU(uint32_t min, uint32_t max)
static Result MakeForColorFilter(SkString sksl, const Options &)
sk_sp< SkBlender > makeBlender(sk_sp< const SkData > uniforms, SkSpan< const ChildPtr > children={}) const
static Result MakeForBlender(SkString sksl, const Options &)
sk_sp< SkColorFilter > makeColorFilter(sk_sp< const SkData > uniforms) const
sk_sp< SkShader > makeWithCTM(const SkMatrix &) const
static sk_sp< SkTextBlob > MakeFromText(const void *text, size_t byteLength, const SkFont &font, SkTextEncoding encoding=SkTextEncoding::kUTF8)
static sk_sp< SkVertices > MakeCopy(VertexMode mode, int vertexCount, const SkPoint positions[], const SkPoint texs[], const SkColor colors[], int indexCount, const uint16_t indices[])
@ kTriangleFan_VertexMode
SkIPoint dstOffset() const
sk_sp< TextureProxy > dstTexture() const
const SkColorInfo & dstColorInfo() const
void buildCombinations(const KeyContext &keyContext, PipelineDataGatherer *gatherer, DrawTypeFlags drawTypes, bool withPrimitiveBlender, Coverage coverage, const PaintOptions::ProcessCombination &processCombination) const
void setColorFilters(SkSpan< const sk_sp< PrecompileColorFilter > > colorFilters)
void setImageFilters(SkEnumBitMask< PrecompileImageFilters > options)
void setDither(bool dither)
void setShaders(SkSpan< const sk_sp< PrecompileShader > > shaders)
void setClipShaders(SkSpan< const sk_sp< PrecompileShader > > clipShaders)
void setBlenders(SkSpan< const sk_sp< PrecompileBlender > > blenders)
std::unique_ptr< Recording > snap()
PaintParamsKey lookup(UniquePaintParamsID) const SK_EXCLUDES(fSpinLock)
void syncedSubmit(skgpu::graphite::Context *)
static const skcms_Matrix3x3 gGamuts[]
FlutterSemanticsFlag flags
static sk_sp< SkImage > make_image()
constexpr SkColor4f kTransparent
SK_API sk_sp< SkImage > TextureFromImage(GrDirectContext *, const SkImage *, skgpu::Mipmapped=skgpu::Mipmapped::kNo, skgpu::Budgeted=skgpu::Budgeted::kYes)
static constexpr skcms_Matrix3x3 kSRGB
static constexpr skcms_Matrix3x3 kAdobeRGB
static constexpr skcms_Matrix3x3 kXYZ
static constexpr skcms_Matrix3x3 kRec2020
static constexpr skcms_Matrix3x3 kDisplayP3
static constexpr skcms_TransferFunction kRec2020
static constexpr skcms_TransferFunction k2Dot2
static constexpr skcms_TransferFunction kSRGB
static constexpr skcms_TransferFunction kHLG
static constexpr skcms_TransferFunction kPQ
static constexpr skcms_TransferFunction kLinear
sk_sp< const SkPicture > picture
PODArray< SkColor > colors
SK_API sk_sp< SkShader > MakeTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY, int numOctaves, SkScalar seed, const SkISize *tileSize=nullptr)
SK_API sk_sp< SkShader > MakeFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY, int numOctaves, SkScalar seed, const SkISize *tileSize=nullptr)
SK_API sk_sp< SkSurface > RenderTarget(GrRecordingContext *context, skgpu::Budgeted budgeted, const SkImageInfo &imageInfo, int sampleCount, GrSurfaceOrigin surfaceOrigin, const SkSurfaceProps *surfaceProps, bool shouldCreateWithMips=false, bool isProtected=false)
void FetchUniqueKeys(GlobalCache *globalCache, std::vector< UniqueKey > *keys)
bool ExtractKeyDescs(Context *context, const UniqueKey &origKey, GraphicsPipelineDesc *pipelineDesc, RenderPassDesc *renderPassDesc)
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir path
font
Font Metadata and Metrics.
sk_sp< PrecompileBlender > MakePrecompileBlender(sk_sp< SkRuntimeEffect > effect, SkSpan< const PrecompileChildOptions > childOptions)
DstReadRequirement GetDstReadRequirement(const Caps *caps, std::optional< SkBlendMode > blendMode, Coverage coverage)
bool Precompile(Context *context, RuntimeEffectDictionary *rteDict, const GraphicsPipelineDesc &pipelineDesc, const RenderPassDesc &renderPassDesc)
std::tuple< UniquePaintParamsID, const UniformDataBlock *, const TextureDataBlock * > ExtractPaintData(Recorder *recorder, PipelineDataGatherer *gatherer, PaintParamsKeyBuilder *builder, const Layout layout, const SkM44 &local2Dev, const PaintParams &p, sk_sp< TextureProxy > dstTexture, SkIPoint dstOffset, const SkColorInfo &targetColorInfo)
sk_sp< PrecompileColorFilter > MakePrecompileColorFilter(sk_sp< SkRuntimeEffect > effect, SkSpan< const PrecompileChildOptions > childOptions)
void run_test(skiatest::Reporter *reporter, Context *context, SkISize surfaceSize, SkISize recordingSize, SkISize replayOffset, DrawCallback draw, const std::vector< Expectation > &expectations)
static SkPath make_path()
static constexpr SkIPoint Make(int32_t x, int32_t y)
static constexpr SkISize Make(int32_t w, int32_t h)
static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at)
static sk_sp< SkColorFilter > Make()
static constexpr SkRect MakeWH(float w, float h)
static sk_sp< SkPicture > make_picture()