| /* | |
| * Copyright 2021 Google LLC | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "tests/Test.h" | |
| #if defined(SK_GRAPHITE) | |
| #include "include/core/SkBitmap.h" | |
| #include "include/core/SkCanvas.h" | |
| #include "include/core/SkM44.h" | |
| #include "include/core/SkPaint.h" | |
| #include "include/core/SkPathBuilder.h" | |
| #include "include/core/SkShader.h" | |
| #include "include/core/SkTextBlob.h" | |
| #include "include/core/SkVertices.h" | |
| #include "include/effects/SkColorMatrix.h" | |
| #include "include/effects/SkGradientShader.h" | |
| #include "include/effects/SkRuntimeEffect.h" | |
| #include "include/gpu/graphite/Recorder.h" | |
| #include "src/base/SkRandom.h" | |
| #include "src/core/SkRuntimeEffectPriv.h" | |
| #include "src/gpu/graphite/ContextPriv.h" | |
| #include "src/gpu/graphite/ContextUtils.h" | |
| #include "src/gpu/graphite/FactoryFunctions.h" | |
| #include "src/gpu/graphite/KeyContext.h" | |
| #include "src/gpu/graphite/KeyHelpers.h" | |
| #include "src/gpu/graphite/PaintOptionsPriv.h" | |
| #include "src/gpu/graphite/PaintParams.h" | |
| #include "src/gpu/graphite/PipelineData.h" | |
| #include "src/gpu/graphite/Precompile.h" | |
| #include "src/gpu/graphite/PublicPrecompile.h" | |
| #include "src/gpu/graphite/RecorderPriv.h" | |
| #include "src/gpu/graphite/ResourceProvider.h" | |
| #include "src/gpu/graphite/RuntimeEffectDictionary.h" | |
| #include "src/gpu/graphite/ShaderCodeDictionary.h" | |
| #include "src/gpu/graphite/UniquePaintParamsID.h" | |
| #include "src/shaders/SkImageShader.h" | |
| #include "tools/ToolUtils.h" | |
| using namespace skgpu::graphite; | |
| namespace { | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_random_shader(SkRandom*, Recorder*); | |
| std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> create_random_blender(SkRandom*); | |
| std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_random_colorfilter(SkRandom*); | |
| enum class ShaderType { | |
| kNone, | |
| kSolidColor, | |
| kLinearGradient, | |
| kRadialGradient, | |
| kSweepGradient, | |
| kConicalGradient, | |
| kLocalMatrix, | |
| kColorFilter, | |
| kImage, | |
| kBlend, | |
| kLast = kBlend | |
| }; | |
| static constexpr int kShaderTypeCount = static_cast<int>(ShaderType::kLast) + 1; | |
| // TODO: do we need to add a separable category and/or a category for dstRead requiring blends? | |
| enum class BlenderType { | |
| kNone, | |
| kPorterDuff, | |
| kShaderBased, | |
| kRuntime, | |
| kLast = kRuntime | |
| }; | |
| static constexpr int kBlenderTypeCount = static_cast<int>(BlenderType::kLast) + 1; | |
| enum class ColorFilterType { | |
| kNone, | |
| kBlend, | |
| kMatrix, | |
| kHSLAMatrix, | |
| // TODO: add more color filters | |
| kLast = kHSLAMatrix | |
| }; | |
| static constexpr int kColorFilterTypeCount = static_cast<int>(ColorFilterType::kLast) + 1; | |
| static constexpr skcms_TransferFunction gTransferFunctions[] = { | |
| SkNamedTransferFn::kSRGB, | |
| SkNamedTransferFn::k2Dot2, | |
| SkNamedTransferFn::kLinear, | |
| SkNamedTransferFn::kRec2020, | |
| SkNamedTransferFn::kPQ, | |
| SkNamedTransferFn::kHLG, | |
| }; | |
| static constexpr int kTransferFunctionCount = std::size(gTransferFunctions); | |
| static constexpr skcms_Matrix3x3 gGamuts[] = { | |
| SkNamedGamut::kSRGB, | |
| SkNamedGamut::kAdobeRGB, | |
| SkNamedGamut::kDisplayP3, | |
| SkNamedGamut::kRec2020, | |
| SkNamedGamut::kXYZ, | |
| }; | |
| static constexpr int kGamutCount = std::size(gGamuts); | |
| enum class ColorSpaceType { | |
| kNone, | |
| kSRGB, | |
| kSRGBLinear, | |
| kRGB, | |
| kLast = kRGB | |
| }; | |
| static constexpr int kColorSpaceTypeCount = static_cast<int>(ColorSpaceType::kLast) + 1; | |
| ColorSpaceType random_colorspacetype(SkRandom* rand) { | |
| return static_cast<ColorSpaceType>(rand->nextULessThan(kColorSpaceTypeCount)); | |
| } | |
| sk_sp<SkColorSpace> random_colorspace(SkRandom* rand) { | |
| ColorSpaceType cs = random_colorspacetype(rand); | |
| switch (cs) { | |
| case ColorSpaceType::kNone: | |
| return nullptr; | |
| case ColorSpaceType::kSRGB: | |
| return SkColorSpace::MakeSRGB(); | |
| case ColorSpaceType::kSRGBLinear: | |
| return SkColorSpace::MakeSRGBLinear(); | |
| case ColorSpaceType::kRGB: | |
| return SkColorSpace::MakeRGB( | |
| gTransferFunctions[rand->nextULessThan(kTransferFunctionCount)], | |
| gGamuts[rand->nextULessThan(kGamutCount)]); | |
| } | |
| SkUNREACHABLE; | |
| } | |
| SkColor random_opaque_color(SkRandom* rand) { | |
| return 0xff000000 | rand->nextU(); | |
| } | |
| SkColor4f random_color(SkRandom* rand) { | |
| SkColor4f result = { rand->nextRangeF(0.0f, 1.0f), | |
| rand->nextRangeF(0.0f, 1.0f), | |
| rand->nextRangeF(0.0f, 1.0f), | |
| rand->nextRangeF(0.0f, 1.0f) }; | |
| if (rand->nextBool()) { | |
| result.fA = 1.0f; | |
| } | |
| return result; | |
| } | |
| SkTileMode random_tilemode(SkRandom* rand) { | |
| return static_cast<SkTileMode>(rand->nextULessThan(kSkTileModeCount)); | |
| } | |
| ShaderType random_shadertype(SkRandom* rand) { | |
| return static_cast<ShaderType>(rand->nextULessThan(kShaderTypeCount)); | |
| } | |
| SkBlendMode random_porter_duff_bm(SkRandom* rand) { | |
| return static_cast<SkBlendMode>(rand->nextRangeU((unsigned int) SkBlendMode::kClear, | |
| (unsigned int) SkBlendMode::kLastCoeffMode)); | |
| } | |
| SkBlendMode random_complex_bm(SkRandom* rand) { | |
| return static_cast<SkBlendMode>(rand->nextRangeU((unsigned int) SkBlendMode::kLastCoeffMode, | |
| (unsigned int) SkBlendMode::kLastMode)); | |
| } | |
| SkBlendMode random_blend_mode(SkRandom* rand) { | |
| return static_cast<SkBlendMode>(rand->nextULessThan(kSkBlendModeCount)); | |
| } | |
| BlenderType random_blendertype(SkRandom* rand) { | |
| return static_cast<BlenderType>(rand->nextULessThan(kBlenderTypeCount)); | |
| } | |
| ColorFilterType random_colorfiltertype(SkRandom* rand) { | |
| return static_cast<ColorFilterType>(rand->nextULessThan(kColorFilterTypeCount)); | |
| } | |
| sk_sp<SkImage> make_image(SkRandom* rand, Recorder* recorder) { | |
| // TODO: add alpha-only images too | |
| SkImageInfo info = SkImageInfo::Make(32, 32, | |
| SkColorType::kRGBA_8888_SkColorType, | |
| kPremul_SkAlphaType, | |
| random_colorspace(rand)); | |
| SkBitmap bitmap; | |
| bitmap.allocPixels(info); | |
| bitmap.eraseColor(SK_ColorBLACK); | |
| sk_sp<SkImage> img = bitmap.asImage(); | |
| // TODO: fuzz mipmappedness | |
| return img->makeTextureImage(recorder, { skgpu::Mipmapped::kNo }); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_solid_shader(SkRandom* rand) { | |
| sk_sp<SkShader> s = SkShaders::Color(random_opaque_color(rand)); | |
| sk_sp<PrecompileShader> o = PrecompileShaders::Color(); | |
| return { s, o }; | |
| } | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_gradient_shader( | |
| SkRandom* rand, | |
| SkShaderBase::GradientType type) { | |
| // TODO: fuzz the gradient parameters - esp. the number of stops & hard stops | |
| SkPoint pts[2] = {{-100, -100}, | |
| {100, 100}}; | |
| SkColor colors[2] = {SK_ColorRED, SK_ColorGREEN}; | |
| SkScalar offsets[2] = {0.0f, 1.0f}; | |
| sk_sp<SkShader> s; | |
| sk_sp<PrecompileShader> o; | |
| SkTileMode tm = random_tilemode(rand); | |
| switch (type) { | |
| case SkShaderBase::GradientType::kLinear: | |
| s = SkGradientShader::MakeLinear(pts, colors, offsets, 2, tm); | |
| o = PrecompileShaders::LinearGradient(); | |
| break; | |
| case SkShaderBase::GradientType::kRadial: | |
| s = SkGradientShader::MakeRadial({0, 0}, 100, colors, offsets, 2, tm); | |
| o = PrecompileShaders::RadialGradient(); | |
| break; | |
| case SkShaderBase::GradientType::kSweep: | |
| s = SkGradientShader::MakeSweep(0, 0, colors, offsets, 2, tm, | |
| 0, 359, 0, nullptr); | |
| o = PrecompileShaders::SweepGradient(); | |
| break; | |
| case SkShaderBase::GradientType::kConical: | |
| s = SkGradientShader::MakeTwoPointConical({100, 100}, 100, | |
| {-100, -100}, 100, | |
| colors, offsets, 2, tm); | |
| o = PrecompileShaders::TwoPointConicalGradient(); | |
| break; | |
| case SkShaderBase::GradientType::kNone: | |
| case SkShaderBase::GradientType::kColor: | |
| SkASSERT(0); | |
| break; | |
| } | |
| return { s, o }; | |
| } | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_localmatrix_shader(SkRandom* rand, | |
| Recorder* recorder) { | |
| auto [s, o] = create_random_shader(rand, recorder); | |
| SkASSERT(!s == !o); | |
| if (!s) { | |
| return { nullptr, nullptr }; | |
| } | |
| SkMatrix tmp = SkMatrix::Scale(1.5f, 2.0f); // TODO: fuzz | |
| return { s->makeWithLocalMatrix(tmp), o->makeWithLocalMatrix() }; | |
| } | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_colorfilter_shader(SkRandom* rand, | |
| Recorder* recorder) { | |
| auto [s, o] = create_random_shader(rand, recorder); | |
| SkASSERT(!s == !o); | |
| if (!s) { | |
| return { nullptr, nullptr }; | |
| } | |
| auto [cf, cfO] = create_random_colorfilter(rand); | |
| return { s->makeWithColorFilter(std::move(cf)), o->makeWithColorFilter(std::move(cfO)) }; | |
| } | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_image_shader(SkRandom* rand, | |
| Recorder* recorder) { | |
| SkTileMode tmX = random_tilemode(rand); | |
| SkTileMode tmY = random_tilemode(rand); | |
| sk_sp<SkShader> s = SkImageShader::Make(make_image(rand, recorder), tmX, tmY, | |
| SkSamplingOptions(), nullptr); | |
| sk_sp<PrecompileShader> o = PrecompileShaders::Image(); | |
| return { s, o }; | |
| } | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_blend_shader(SkRandom* rand, | |
| Recorder* recorder) { | |
| // TODO: add explicit testing of the kClear, kDst and kSrc blend modes since they short | |
| // circuit creation of a true blend shader (i.e., in SkShaders::Blend). | |
| auto [blender, blenderO] = create_random_blender(rand); | |
| auto [dstS, dstO] = create_random_shader(rand, recorder); | |
| SkASSERT(!dstS == !dstO); | |
| if (!dstS) { | |
| return { nullptr, nullptr }; | |
| } | |
| auto [srcS, srcO] = create_random_shader(rand, recorder); | |
| SkASSERT(!srcS == !srcO); | |
| if (!srcS) { | |
| return { nullptr, nullptr }; | |
| } | |
| auto s = SkShaders::Blend(std::move(blender), std::move(dstS), std::move(srcS)); | |
| auto o = PrecompileShaders::Blend(SkSpan<const sk_sp<PrecompileBlender>>({ blenderO }), | |
| { dstO }, { srcO }); | |
| return { s, o }; | |
| } | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_shader(SkRandom* rand, | |
| Recorder* recorder, | |
| ShaderType shaderType) { | |
| switch (shaderType) { | |
| case ShaderType::kNone: | |
| return { nullptr, nullptr }; | |
| case ShaderType::kSolidColor: | |
| return create_solid_shader(rand); | |
| case ShaderType::kLinearGradient: | |
| return create_gradient_shader(rand, SkShaderBase::GradientType::kLinear); | |
| case ShaderType::kRadialGradient: | |
| return create_gradient_shader(rand, SkShaderBase::GradientType::kRadial); | |
| case ShaderType::kSweepGradient: | |
| return create_gradient_shader(rand, SkShaderBase::GradientType::kSweep); | |
| case ShaderType::kConicalGradient: | |
| return create_gradient_shader(rand, SkShaderBase::GradientType::kConical); | |
| case ShaderType::kLocalMatrix: | |
| return create_localmatrix_shader(rand, recorder); | |
| case ShaderType::kColorFilter: | |
| return create_colorfilter_shader(rand, recorder); | |
| case ShaderType::kImage: | |
| return create_image_shader(rand, recorder); | |
| case ShaderType::kBlend: | |
| return create_blend_shader(rand, recorder); | |
| } | |
| SkUNREACHABLE; | |
| } | |
| std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_random_shader(SkRandom* rand, | |
| Recorder* recorder) { | |
| return create_shader(rand, recorder, random_shadertype(rand)); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> src_blender() { | |
| static SkRuntimeEffect* sSrcEffect = SkMakeRuntimeEffect( | |
| SkRuntimeEffect::MakeForBlender, | |
| "half4 main(half4 src, half4 dst) {" | |
| "return src;" | |
| "}" | |
| ); | |
| sk_sp<SkBlender> b = sSrcEffect->makeBlender(/* uniforms= */ nullptr); | |
| sk_sp<PrecompileBlender> o = MakePrecompileBlender(sk_ref_sp(sSrcEffect)); | |
| return { b , o }; | |
| } | |
| std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> dest_blender() { | |
| static SkRuntimeEffect* sDestEffect = SkMakeRuntimeEffect( | |
| SkRuntimeEffect::MakeForBlender, | |
| "half4 main(half4 src, half4 dst) {" | |
| "return dst;" | |
| "}" | |
| ); | |
| sk_sp<SkBlender> b = sDestEffect->makeBlender(/* uniforms= */ nullptr); | |
| sk_sp<PrecompileBlender> o = MakePrecompileBlender(sk_ref_sp(sDestEffect)); | |
| return { b , o }; | |
| } | |
| std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> combo_blender() { | |
| static SkRuntimeEffect* sComboEffect = SkMakeRuntimeEffect( | |
| SkRuntimeEffect::MakeForBlender, | |
| "uniform float blendFrac;" | |
| "uniform blender a;" | |
| "uniform blender b;" | |
| "half4 main(half4 src, half4 dst) {" | |
| "return (blendFrac * a.eval(src, dst)) + ((1 - blendFrac) * b.eval(src, dst));" | |
| "}" | |
| ); | |
| auto [src, srcO] = src_blender(); | |
| auto [dst, dstO] = dest_blender(); | |
| SkRuntimeEffect::ChildPtr children[] = { src, dst }; | |
| const PrecompileChildPtr childOptions[] = { srcO, dstO }; | |
| const float kUniforms[] = { 1.0f }; | |
| sk_sp<SkBlender> b = sComboEffect->makeBlender(SkData::MakeWithCopy(kUniforms, | |
| sizeof(kUniforms)), | |
| children); | |
| sk_sp<PrecompileBlender> o = MakePrecompileBlender(sk_ref_sp(sComboEffect), { childOptions }); | |
| return { b , o }; | |
| } | |
| std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> create_bm_blender(SkRandom* rand, | |
| SkBlendMode bm) { | |
| return { SkBlender::Mode(bm), PrecompileBlender::Mode(bm) }; | |
| } | |
| std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> create_rt_blender(SkRandom* rand) { | |
| int option = rand->nextULessThan(3); | |
| switch (option) { | |
| case 0: return src_blender(); | |
| case 1: return dest_blender(); | |
| case 2: return combo_blender(); | |
| } | |
| return { nullptr, nullptr }; | |
| } | |
| std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> create_blender(SkRandom* rand, | |
| BlenderType type) { | |
| switch (type) { | |
| case BlenderType::kNone: | |
| return { nullptr, nullptr }; | |
| case BlenderType::kPorterDuff: | |
| return create_bm_blender(rand, random_porter_duff_bm(rand)); | |
| case BlenderType::kShaderBased: | |
| return create_bm_blender(rand, random_complex_bm(rand)); | |
| case BlenderType::kRuntime: | |
| return create_rt_blender(rand); | |
| } | |
| SkUNREACHABLE; | |
| } | |
| std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> create_random_blender(SkRandom* rand) { | |
| return create_blender(rand, random_blendertype(rand)); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_blend_colorfilter( | |
| SkRandom* rand) { | |
| sk_sp<SkColorFilter> cf; | |
| // SkColorFilters::Blend is clever and can weed out noop color filters. Loop until we get | |
| // a valid color filter. | |
| while (!cf) { | |
| cf = SkColorFilters::Blend(random_color(rand), | |
| random_colorspace(rand), | |
| random_blend_mode(rand)); | |
| } | |
| sk_sp<PrecompileColorFilter> o = PrecompileColorFilters::Blend(); | |
| return { cf, o }; | |
| } | |
| std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_matrix_colorfilter() { | |
| sk_sp<SkColorFilter> cf = SkColorFilters::Matrix( | |
| SkColorMatrix::RGBtoYUV(SkYUVColorSpace::kJPEG_Full_SkYUVColorSpace)); | |
| sk_sp<PrecompileColorFilter> o = PrecompileColorFilters::Matrix(); | |
| return { cf, o }; | |
| } | |
| std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_hsla_matrix_colorfilter() { | |
| sk_sp<SkColorFilter> cf = SkColorFilters::HSLAMatrix( | |
| SkColorMatrix::RGBtoYUV(SkYUVColorSpace::kJPEG_Full_SkYUVColorSpace)); | |
| sk_sp<PrecompileColorFilter> o = PrecompileColorFilters::HSLAMatrix(); | |
| return { cf, o }; | |
| } | |
| std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_colorfilter( | |
| SkRandom* rand, | |
| ColorFilterType type) { | |
| switch (type) { | |
| case ColorFilterType::kNone: | |
| return { nullptr, nullptr }; | |
| case ColorFilterType::kBlend: | |
| return create_blend_colorfilter(rand); | |
| case ColorFilterType::kMatrix: | |
| return create_matrix_colorfilter(); | |
| case ColorFilterType::kHSLAMatrix: | |
| return create_hsla_matrix_colorfilter(); | |
| } | |
| SkUNREACHABLE; | |
| } | |
| std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_random_colorfilter( | |
| SkRandom* rand) { | |
| return create_colorfilter(rand, random_colorfiltertype(rand)); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| std::pair<SkPaint, PaintOptions> create_paint(SkRandom* rand, | |
| Recorder* recorder, | |
| ShaderType shaderType, | |
| BlenderType blenderType, | |
| ColorFilterType colorFilterType) { | |
| SkPaint paint; | |
| paint.setColor(random_opaque_color(rand)); | |
| PaintOptions paintOptions; | |
| { | |
| auto [s, o] = create_shader(rand, recorder, shaderType); | |
| SkASSERT(!s == !o); | |
| if (s) { | |
| paint.setShader(std::move(s)); | |
| paintOptions.setShaders({o}); | |
| } | |
| } | |
| { | |
| auto [cf, o] = create_colorfilter(rand, colorFilterType); | |
| SkASSERT(!cf == !o); | |
| if (cf) { | |
| paint.setColorFilter(std::move(cf)); | |
| paintOptions.setColorFilters({o}); | |
| } | |
| } | |
| { | |
| auto [b, o] = create_blender(rand, blenderType); | |
| SkASSERT(!b == !o); | |
| if (b) { | |
| paint.setBlender(std::move(b)); | |
| paintOptions.setBlenders({o}); | |
| } | |
| } | |
| return { paint, paintOptions }; | |
| } | |
| #ifdef SK_DEBUG | |
| void dump(ShaderCodeDictionary* dict, UniquePaintParamsID id) { | |
| auto entry = dict->lookup(id); | |
| entry->paintParamsKey().dump(dict); | |
| } | |
| #endif | |
| SkPath make_path() { | |
| SkPathBuilder path; | |
| path.moveTo(0, 0); | |
| path.lineTo(8, 2); | |
| path.lineTo(16, 0); | |
| path.lineTo(14, 8); | |
| path.lineTo(16, 16); | |
| path.lineTo(8, 14); | |
| path.lineTo(0, 16); | |
| path.lineTo(2, 8); | |
| path.close(); | |
| return path.detach(); | |
| } | |
| struct DrawData { | |
| SkPath fPath; | |
| sk_sp<SkTextBlob> fBlob; | |
| sk_sp<SkVertices> fVerts; | |
| }; | |
| void check_draw(skiatest::Reporter* reporter, | |
| Context* context, | |
| Recorder* recorder, | |
| const SkPaint& paint, | |
| DrawTypeFlags dt, | |
| const DrawData& drawData) { | |
| int before = context->priv().globalCache()->numGraphicsPipelines(); | |
| { | |
| // TODO: vary the colorType of the target surface too | |
| SkImageInfo ii = SkImageInfo::Make(16, 16, | |
| kRGBA_8888_SkColorType, | |
| kPremul_SkAlphaType); | |
| sk_sp<SkSurface> surf = SkSurface::MakeGraphite(recorder, ii); | |
| SkCanvas* canvas = surf->getCanvas(); | |
| switch (dt) { | |
| case DrawTypeFlags::kShape: | |
| canvas->drawRect(SkRect::MakeWH(16, 16), paint); | |
| canvas->drawPath(drawData.fPath, paint); | |
| break; | |
| case DrawTypeFlags::kText: | |
| canvas->drawTextBlob(drawData.fBlob, 0, 16, paint); | |
| break; | |
| case DrawTypeFlags::kDrawVertices: | |
| canvas->drawVertices(drawData.fVerts, SkBlendMode::kDst, paint); | |
| break; | |
| default: | |
| SkASSERT(false); | |
| break; | |
| } | |
| std::unique_ptr<skgpu::graphite::Recording> recording = recorder->snap(); | |
| context->insertRecording({ recording.get() }); | |
| context->submit(SyncToCpu::kYes); | |
| } | |
| int after = context->priv().globalCache()->numGraphicsPipelines(); | |
| // Actually using the SkPaint with the specified type of draw shouldn't have caused | |
| // any additional compilation | |
| REPORTER_ASSERT(reporter, before == after); | |
| } | |
| } // anonymous namespace | |
| // This is intended to be a smoke test for the agreement between the two ways of creating a | |
| // PaintParamsKey: | |
| // via ExtractPaintData (i.e., from an SkPaint) | |
| // and via the pre-compilation system | |
| // | |
| // TODO: keep this as a smoke test but add a fuzzer that reuses all the helpers | |
| DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS(PaintParamsKeyTest, reporter, context) { | |
| auto recorder = context->makeRecorder(); | |
| ShaderCodeDictionary* dict = context->priv().shaderCodeDictionary(); | |
| SkColorInfo ci = SkColorInfo(kRGBA_8888_SkColorType, kPremul_SkAlphaType, | |
| SkColorSpace::MakeSRGB()); | |
| KeyContext extractPaintKeyContext(recorder.get(), {}, ci); | |
| std::unique_ptr<RuntimeEffectDictionary> rtDict = std::make_unique<RuntimeEffectDictionary>(); | |
| KeyContext precompileKeyContext(dict, rtDict.get(), ci); | |
| SkFont font(ToolUtils::create_portable_typeface(), 16); | |
| const char text[] = "hambur"; | |
| // TODO: add a drawVertices call w/o colors. That impacts whether the RenderSteps emit | |
| // a primitive color blender | |
| constexpr int kNumVerts = 4; | |
| constexpr SkPoint kPositions[kNumVerts] { {0,0}, {0,16}, {16,16}, {16,0} }; | |
| constexpr SkColor kColors[kNumVerts] = { SK_ColorBLUE, SK_ColorGREEN, | |
| SK_ColorCYAN, SK_ColorYELLOW }; | |
| DrawData drawData = { | |
| make_path(), | |
| SkTextBlob::MakeFromText(text, strlen(text), font), | |
| SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, kNumVerts, | |
| kPositions, kPositions, kColors), | |
| }; | |
| SkRandom rand; | |
| PaintParamsKeyBuilder builder(dict); | |
| PipelineDataGatherer gatherer(Layout::kMetal); | |
| for (auto s : { ShaderType::kNone, | |
| ShaderType::kSolidColor, | |
| ShaderType::kLinearGradient, | |
| ShaderType::kRadialGradient, | |
| ShaderType::kSweepGradient, | |
| ShaderType::kConicalGradient, | |
| ShaderType::kLocalMatrix, | |
| ShaderType::kImage, | |
| ShaderType::kBlend }) { | |
| for (auto bm : { BlenderType::kNone, | |
| BlenderType::kPorterDuff, | |
| BlenderType::kShaderBased, | |
| BlenderType::kRuntime }) { | |
| for (auto cf : { ColorFilterType::kNone, | |
| ColorFilterType::kBlend, | |
| ColorFilterType::kMatrix, | |
| ColorFilterType::kHSLAMatrix }) { | |
| auto [paint, paintOptions] = create_paint(&rand, recorder.get(), s, bm, cf); | |
| for (auto dt : { DrawTypeFlags::kShape, | |
| DrawTypeFlags::kText, | |
| DrawTypeFlags::kDrawVertices }) { | |
| for (bool withPrimitiveBlender : { false, true }) { | |
| sk_sp<SkBlender> primitiveBlender; | |
| if (withPrimitiveBlender) { | |
| if (dt != DrawTypeFlags::kDrawVertices) { | |
| // Only drawVertices calls need a primitive blender | |
| continue; | |
| } | |
| primitiveBlender = SkBlender::Mode(SkBlendMode::kSrcOver); | |
| } | |
| auto [paintID, uData, tData] = ExtractPaintData( | |
| recorder.get(), &gatherer, &builder, Layout::kMetal, {}, | |
| PaintParams(paint, | |
| std::move(primitiveBlender), | |
| /* skipColorXform= */ false), | |
| extractPaintKeyContext.dstColorInfo()); | |
| std::vector<UniquePaintParamsID> precompileIDs; | |
| paintOptions.priv().buildCombinations(precompileKeyContext, | |
| withPrimitiveBlender, | |
| [&](UniquePaintParamsID id) { | |
| precompileIDs.push_back(id); | |
| }); | |
| // The specific key generated by ExtractPaintData should be one of the | |
| // combinations generated by the combination system. | |
| auto result = std::find(precompileIDs.begin(), precompileIDs.end(), | |
| paintID); | |
| #ifdef SK_DEBUG | |
| if (result == precompileIDs.end()) { | |
| SkDebugf("From paint: "); | |
| dump(dict, paintID); | |
| SkDebugf("From combination builder:"); | |
| for (auto iter : precompileIDs) { | |
| dump(dict, iter); | |
| } | |
| } | |
| #endif | |
| REPORTER_ASSERT(reporter, result != precompileIDs.end()); | |
| { | |
| context->priv().globalCache()->resetGraphicsPipelines(); | |
| int before = context->priv().globalCache()->numGraphicsPipelines(); | |
| Precompile(context, paintOptions, dt); | |
| int after = context->priv().globalCache()->numGraphicsPipelines(); | |
| REPORTER_ASSERT(reporter, before == 0); | |
| REPORTER_ASSERT(reporter, after > before); | |
| check_draw(reporter, context, recorder.get(), paint, dt, drawData); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| #endif // SK_GRAPHITE |