From 71a6cbfc585959738dc0b375603696ca7f60605f Mon Sep 17 00:00:00 2001 From: reed Date: Mon, 4 May 2015 08:32:51 -0700 Subject: [PATCH] remove redundant/deprecated TwoPointRadial gradiet -- use TwoPointConical This CL derived from https://codereview.chromium.org/1114243005/ BUG=skia: Review URL: https://codereview.chromium.org/1117423003 --- bench/GradientBench.cpp | 19 - gm/blurrect.cpp | 2 +- gm/blurroundrect.cpp | 8 +- gm/gradients.cpp | 16 +- gm/gradients_no_texture.cpp | 2 +- gm/shadertext.cpp | 6 +- gm/twopointradial.cpp | 112 --- gyp/effects.gypi | 2 - gyp/gmslides.gypi | 1 - include/core/SkShader.h | 16 +- include/effects/SkGradientShader.h | 33 - samplecode/Sample2PtRadial.cpp | 10 +- samplecode/SampleGradients.cpp | 10 +- samplecode/SampleShaderText.cpp | 6 +- samplecode/SampleSlides.cpp | 6 +- src/device/xps/SkXPSDevice.cpp | 8 +- src/effects/gradients/SkGradientShader.cpp | 26 - .../gradients/SkTwoPointRadialGradient.cpp | 724 ------------------ .../gradients/SkTwoPointRadialGradient.h | 64 -- src/gpu/GrProcessor.cpp | 2 +- src/gpu/SkGpuDevice.cpp | 13 - src/pdf/SkPDFShader.cpp | 66 +- tests/GradientTest.cpp | 17 - 23 files changed, 37 insertions(+), 1132 deletions(-) delete mode 100644 gm/twopointradial.cpp delete mode 100644 src/effects/gradients/SkTwoPointRadialGradient.cpp delete mode 100644 src/effects/gradients/SkTwoPointRadialGradient.h diff --git a/bench/GradientBench.cpp b/bench/GradientBench.cpp index e5e5fc385f..f32c4ef1d2 100644 --- a/bench/GradientBench.cpp +++ b/bench/GradientBench.cpp @@ -71,20 +71,6 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, data.fPos, data.fCount); } -/// Ignores scale -static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, - SkShader::TileMode tm, float scale) { - SkPoint center0, center1; - center0.set(SkScalarAve(pts[0].fX, pts[1].fX), - SkScalarAve(pts[0].fY, pts[1].fY)); - center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), - SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial( - center1, (pts[1].fX - pts[0].fX) / 7, - center0, (pts[1].fX - pts[0].fX) / 2, - data.fColors, data.fPos, data.fCount, tm); -} - /// Ignores scale static SkShader* MakeConical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm, float scale) { @@ -149,7 +135,6 @@ static const struct { { MakeLinear, "linear" }, { MakeRadial, "radial1" }, { MakeSweep, "sweep" }, - { Make2Radial, "radial2" }, { MakeConical, "conical" }, { MakeConicalZeroRad, "conicalZero" }, { MakeConicalOutside, "conicalOut" }, @@ -160,7 +145,6 @@ enum GradType { // these must match the order in gGrads kLinear_GradType, kRadial_GradType, kSweep_GradType, - kRadial2_GradType, kConical_GradType, kConicalZero_GradType, kConicalOut_GradType, @@ -313,9 +297,6 @@ DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kR DEF_BENCH( return new GradientBench(kSweep_GradType); ) DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[1]); ) DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[2]); ) -DEF_BENCH( return new GradientBench(kRadial2_GradType); ) -DEF_BENCH( return new GradientBench(kRadial2_GradType, gGradData[1]); ) -DEF_BENCH( return new GradientBench(kRadial2_GradType, gGradData[0], SkShader::kMirror_TileMode); ) DEF_BENCH( return new GradientBench(kConical_GradType); ) DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[1]); ) DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[2]); ) diff --git a/gm/blurrect.cpp b/gm/blurrect.cpp index e6c6911380..0726f2cd52 100644 --- a/gm/blurrect.cpp +++ b/gm/blurrect.cpp @@ -74,7 +74,7 @@ static SkShader* MakeRadial() { SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial(center1, (pts[1].fX - pts[0].fX) / 7, + return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, colors, pos, SK_ARRAY_COUNT(colors), tm, 0, &scale); diff --git a/gm/blurroundrect.cpp b/gm/blurroundrect.cpp index dcb0e9765b..6b11f841c0 100644 --- a/gm/blurroundrect.cpp +++ b/gm/blurroundrect.cpp @@ -112,10 +112,10 @@ static SkShader* MakeRadial() { SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial(center1, (pts[1].fX - pts[0].fX) / 7, - center0, (pts[1].fX - pts[0].fX) / 2, - colors, pos, SK_ARRAY_COUNT(colors), tm, - 0, &scale); + return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7, + center0, (pts[1].fX - pts[0].fX) / 2, + colors, pos, SK_ARRAY_COUNT(colors), tm, + 0, &scale); } // Simpler blurred RR test cases where all the radii are the same. diff --git a/gm/gradients.cpp b/gm/gradients.cpp index 7ff9d380d1..eb1409d625 100644 --- a/gm/gradients.cpp +++ b/gm/gradients.cpp @@ -70,11 +70,11 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial( - center1, (pts[1].fX - pts[0].fX) / 7, - center0, (pts[1].fX - pts[0].fX) / 2, - data.fColors, data.fPos, data.fCount, tm, - 0, &localMatrix); + return SkGradientShader::CreateTwoPointConical( + center1, (pts[1].fX - pts[0].fX) / 7, + center0, (pts[1].fX - pts[0].fX) / 2, + data.fColors, data.fPos, data.fCount, tm, + 0, &localMatrix); } static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, @@ -273,9 +273,9 @@ protected: SkPoint c1; c1.iset(0, 25); SkScalar r1 = SkIntToScalar(150); - SkShader* s = SkGradientShader::CreateTwoPointRadial(c0, r0, c1, r1, colors, - pos, SK_ARRAY_COUNT(pos), - SkShader::kClamp_TileMode); + SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors, + pos, SK_ARRAY_COUNT(pos), + SkShader::kClamp_TileMode); SkPaint paint; paint.setShader(s)->unref(); canvas->drawPaint(paint); diff --git a/gm/gradients_no_texture.cpp b/gm/gradients_no_texture.cpp index 8b97b25ef6..dea9a65784 100644 --- a/gm/gradients_no_texture.cpp +++ b/gm/gradients_no_texture.cpp @@ -51,7 +51,7 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShade SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial( + return SkGradientShader::CreateTwoPointConical( center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); diff --git a/gm/shadertext.cpp b/gm/shadertext.cpp index 79f7b860a0..6845fa1c5c 100644 --- a/gm/shadertext.cpp +++ b/gm/shadertext.cpp @@ -64,13 +64,13 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader: return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); } -static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center0, center1; center0.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial( + return SkGradientShader::CreateTwoPointConical( center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); @@ -79,7 +79,7 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShade typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); static const GradMaker gGradMakers[] = { - MakeLinear, MakeRadial, MakeSweep, Make2Radial + MakeLinear, MakeRadial, MakeSweep, Make2Conical }; /////////////////////////////////////////////////////////////////////////////// diff --git a/gm/twopointradial.cpp b/gm/twopointradial.cpp deleted file mode 100644 index f1a27d3f83..0000000000 --- a/gm/twopointradial.cpp +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Copyright 2012 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#include "gm.h" -#include "SkCanvas.h" -#include "SkPaint.h" -#include "SkGradientShader.h" - -static void intToScalars(SkScalar dst[], const int src[], int n) { - for (int i = 0; i < n; ++i) { - dst[i] = SkIntToScalar(src[i]); - } -} - -static void drawGrad(SkCanvas* canvas, const SkScalar d0[], const SkScalar d1[]) { - const SkRect bounds = SkRect::MakeXYWH(SkIntToScalar(-50), - SkIntToScalar(-50), - SkIntToScalar(200), - SkIntToScalar(100)); - - SkPoint c0 = { d0[0], d0[1] }; - SkScalar r0 = d0[2]; - SkPoint c1 = { d1[0], d1[1] }; - SkScalar r1 = d1[2]; - - SkColor colors[] = { SK_ColorGREEN, SK_ColorRED }; - SkPaint paint; - paint.setAntiAlias(true); - sk_tool_utils::set_portable_typeface(&paint); - - SkString str; - str.printf("%g,%g,%g %g,%g,%g", - SkScalarToFloat(c0.fX), SkScalarToFloat(c0.fY), SkScalarToFloat(r0), - SkScalarToFloat(c1.fX), SkScalarToFloat(c1.fY), SkScalarToFloat(r1)); - canvas->drawText(str.c_str(), str.size(), - bounds.fLeft, bounds.fTop - paint.getTextSize()/2, paint); - - paint.setShader(SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, - colors, NULL, 2, - SkShader::kClamp_TileMode))->unref(); - canvas->drawRect(bounds, paint); - - paint.setShader(NULL); - paint.setColor(0x66000000); - paint.setStyle(SkPaint::kStroke_Style); - canvas->drawCircle(c0.fX, c0.fY, r0, paint); - canvas->drawCircle(c1.fX, c1.fY, r1, paint); - canvas->drawRect(bounds, paint); -} - -class TwoPointRadialGM : public skiagm::GM { -public: - TwoPointRadialGM() {} - -protected: - SkString onShortName() { - return SkString("twopointconical"); - } - - SkISize onISize() { return SkISize::Make(480, 780); } - - virtual void onDraw(SkCanvas* canvas) { - if (false) { - SkPaint paint; - paint.setColor(SK_ColorBLUE); - canvas->drawRect( - SkRect::MakeWH(SkIntToScalar(this->getISize().fWidth), - SkIntToScalar(this->getISize().fHeight)), - paint); - } - SkPaint paint; - const int R0 = 20; - const int R1 = 40; - - const SkScalar DX = SkIntToScalar(250); - const SkScalar DY = SkIntToScalar(130); - - canvas->translate(SkIntToScalar(60), SkIntToScalar(70)); - - static const int gData[] = { - 0, 0, R0, 0, 0, R1, - 0, 0, R0, 20, 0, R1, - 0, 0, R0, 25, 0, R1, - 0, 0, R0, 100, 0, R1, - 0, 0, R0, 25, 0, R0, - 0, 0, R0, 100, 0, R0, - }; - - int count = SK_ARRAY_COUNT(gData) / 6; - for (int i = 0; i < count; ++i) { - SkScalar data[6]; - intToScalars(data, &gData[i * 6], 6); - - int n = canvas->save(); - drawGrad(canvas, &data[0], &data[3]); - canvas->translate(DX, 0); - drawGrad(canvas, &data[3], &data[0]); - canvas->restoreToCount(n); - canvas->translate(0, DY); - } - } -}; - -////////////////////////////////////////////////////////////////////////////// - -static skiagm::GM* F(void*) { return new TwoPointRadialGM; } - -static skiagm::GMRegistry gR(F); diff --git a/gyp/effects.gypi b/gyp/effects.gypi index 5479a54e27..8b90a45137 100644 --- a/gyp/effects.gypi +++ b/gyp/effects.gypi @@ -74,8 +74,6 @@ '<(skia_src_path)/effects/gradients/SkLinearGradient.h', '<(skia_src_path)/effects/gradients/SkRadialGradient.cpp', '<(skia_src_path)/effects/gradients/SkRadialGradient.h', - '<(skia_src_path)/effects/gradients/SkTwoPointRadialGradient.cpp', - '<(skia_src_path)/effects/gradients/SkTwoPointRadialGradient.h', '<(skia_src_path)/effects/gradients/SkTwoPointConicalGradient.cpp', '<(skia_src_path)/effects/gradients/SkTwoPointConicalGradient.h', '<(skia_src_path)/effects/gradients/SkTwoPointConicalGradient_gpu.cpp', diff --git a/gyp/gmslides.gypi b/gyp/gmslides.gypi index fcdfdba42f..b57d609c9b 100644 --- a/gyp/gmslides.gypi +++ b/gyp/gmslides.gypi @@ -229,7 +229,6 @@ '../gm/tilemodes_scaled.cpp', '../gm/tinybitmap.cpp', '../gm/transparency.cpp', - '../gm/twopointradial.cpp', '../gm/typeface.cpp', '../gm/vertices.cpp', '../gm/verttext.cpp', diff --git a/include/core/SkShader.h b/include/core/SkShader.h index 91d431f11b..4c4dba3e32 100644 --- a/include/core/SkShader.h +++ b/include/core/SkShader.h @@ -246,19 +246,6 @@ public: // to (0,0) as bitmap x coord, where angle = 0 is // bitmap left edge of bitmap = 2pi is the // right edge. Bitmap is 1 pixel tall. No extras - kTwoPointRadial_BitmapType, - // - CreateTwoPointRadial returns a shader with a reference count of 1. - The caller should decrement the shader's reference count when done with the shader. - It is an error for colorCount to be < 2, for startRadius or endRadius to be < 0, or for - startRadius to be equal to endRadius. - @param start The center of the start circle for this gradient - @param startRadius Must be positive. The radius of the start circle for this gradient. - @param end The center of the end circle for this gradient - @param endRadius Must be positive. The radius of the end circle for this gradient. - @param colors The array[count] of colors, to be distributed between the center and edge of the circle - @param pos May be NULL. The array[count] of SkScalars, or NULL, of the relative position of - each corresponding color in the colors array. If this is NULL, - the the colors are distributed evenly between the center and edge of the circle. - If this is not null, the values must begin with 0, end with 1.0, and - intermediate values must be strictly increasing. - @param count Must be >= 2. The number of colors (and pos if not NULL) entries - @param mode The tiling mode - */ - static SkShader* CreateTwoPointRadial(const SkPoint& start, SkScalar startRadius, - const SkPoint& end, SkScalar endRadius, - const SkColor colors[], const SkScalar pos[], int count, - SkShader::TileMode mode, - uint32_t flags, const SkMatrix* localMatrix); - - static SkShader* CreateTwoPointRadial(const SkPoint& start, SkScalar startRadius, - const SkPoint& end, SkScalar endRadius, - const SkColor colors[], const SkScalar pos[], int count, - SkShader::TileMode mode) { - return CreateTwoPointRadial(start, startRadius, end, endRadius, colors, pos, count, mode, - 0, NULL); - } - /** * Returns a shader that generates a conical gradient given two circles, or * returns NULL if the inputs are invalid. The gradient interprets the diff --git a/samplecode/Sample2PtRadial.cpp b/samplecode/Sample2PtRadial.cpp index 073fd8241b..764c2b129c 100644 --- a/samplecode/Sample2PtRadial.cpp +++ b/samplecode/Sample2PtRadial.cpp @@ -11,15 +11,15 @@ #include "SkGradientShader.h" -class TwoPtRadialView : public SampleView { +class TwoPtConicalView : public SampleView { public: - TwoPtRadialView() {} + TwoPtConicalView() {} protected: // overrides from SkEventSink virtual bool onQuery(SkEvent* evt) { if (SampleCode::TitleQ(*evt)) { - SampleCode::TitleR(evt, "2PtRadial"); + SampleCode::TitleR(evt, "2PtConical"); return true; } return this->INHERITED::onQuery(evt); @@ -33,7 +33,7 @@ protected: SkScalar r0 = 100; SkPoint c1 = { 100, 100 }; SkScalar r1 = 100; - SkShader* s = SkGradientShader::CreateTwoPointRadial(c0, r0, c1, r1, colors, + SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors, NULL, 2, SkShader::kClamp_TileMode); @@ -48,5 +48,5 @@ private: ////////////////////////////////////////////////////////////////////////////// -static SkView* MyFactory() { return new TwoPtRadialView; } +static SkView* MyFactory() { return new TwoPtConicalView; } static SkViewRegister reg(MyFactory); diff --git a/samplecode/SampleGradients.cpp b/samplecode/SampleGradients.cpp index f328d761a5..12d24d2ae4 100644 --- a/samplecode/SampleGradients.cpp +++ b/samplecode/SampleGradients.cpp @@ -82,24 +82,24 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader: return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); } -static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center0, center1; center0.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial( + return SkGradientShader::CreateTwoPointConical( center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); } -static SkShader* Make2RadialConcentric(const SkPoint pts[2], const GradData& data, +static SkShader* Make2ConicalConcentric(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateTwoPointRadial( + return SkGradientShader::CreateTwoPointConical( center, (pts[1].fX - pts[0].fX) / 7, center, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); @@ -108,7 +108,7 @@ static SkShader* Make2RadialConcentric(const SkPoint pts[2], const GradData& dat typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); static const GradMaker gGradMakers[] = { - MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2RadialConcentric + MakeLinear, MakeRadial, MakeSweep, Make2Conical, Make2ConicalConcentric }; /////////////////////////////////////////////////////////////////////////////// diff --git a/samplecode/SampleShaderText.cpp b/samplecode/SampleShaderText.cpp index 89abfc2345..9fdae842ab 100644 --- a/samplecode/SampleShaderText.cpp +++ b/samplecode/SampleShaderText.cpp @@ -72,13 +72,13 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader: return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); } -static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center0, center1; center0.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial( + return SkGradientShader::CreateTwoPointConical( center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); @@ -87,7 +87,7 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShade typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); static const GradMaker gGradMakers[] = { - MakeLinear, MakeRadial, MakeSweep, Make2Radial + MakeLinear, MakeRadial, MakeSweep, Make2Conical }; /////////////////////////////////////////////////////////////////////////////// diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp index 6899fc111e..83e91bb4d6 100644 --- a/samplecode/SampleSlides.cpp +++ b/samplecode/SampleSlides.cpp @@ -197,13 +197,13 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader: return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); } -static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center0, center1; center0.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointRadial( + return SkGradientShader::CreateTwoPointConical( center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); @@ -211,7 +211,7 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShade typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); static const GradMaker gGradMakers[] = { - MakeLinear, MakeRadial, MakeSweep, Make2Radial + MakeLinear, MakeRadial, MakeSweep, Make2Conical }; static void gradient_slide(SkCanvas* canvas) { diff --git a/src/device/xps/SkXPSDevice.cpp b/src/device/xps/SkXPSDevice.cpp index 88d1182526..a5c001393d 100644 --- a/src/device/xps/SkXPSDevice.cpp +++ b/src/device/xps/SkXPSDevice.cpp @@ -1044,8 +1044,7 @@ HRESULT SkXPSDevice::createXpsBrush(const SkPaint& skPaint, return S_OK; } - if (SkShader::kRadial2_GradientType == gradientType || - SkShader::kConical_GradientType == gradientType) { + if (SkShader::kConical_GradientType == gradientType) { //simple if affine and one is 0, otherwise will have to fake } @@ -1061,8 +1060,6 @@ HRESULT SkXPSDevice::createXpsBrush(const SkPaint& skPaint, &outMatrix, xy); switch (bitmapType) { - case SkShader::kNone_BitmapType: - break; case SkShader::kDefault_BitmapType: { //TODO: outMatrix?? SkMatrix localMatrix = shader->getLocalMatrix(); @@ -1081,9 +1078,6 @@ HRESULT SkXPSDevice::createXpsBrush(const SkPaint& skPaint, return S_OK; } - case SkShader::kRadial_BitmapType: - case SkShader::kSweep_BitmapType: - case SkShader::kTwoPointRadial_BitmapType: default: break; } diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp index eaa7e46f76..52731b395f 100644 --- a/src/effects/gradients/SkGradientShader.cpp +++ b/src/effects/gradients/SkGradientShader.cpp @@ -8,7 +8,6 @@ #include "SkGradientShaderPriv.h" #include "SkLinearGradient.h" #include "SkRadialGradient.h" -#include "SkTwoPointRadialGradient.h" #include "SkTwoPointConicalGradient.h" #include "SkSweepGradient.h" @@ -802,30 +801,6 @@ SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, return SkNEW_ARGS(SkRadialGradient, (center, radius, desc)); } -SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start, - SkScalar startRadius, - const SkPoint& end, - SkScalar endRadius, - const SkColor colors[], - const SkScalar pos[], - int colorCount, - SkShader::TileMode mode, - uint32_t flags, - const SkMatrix* localMatrix) { - if (startRadius < 0 || endRadius < 0) { - return NULL; - } - if (!valid_grad(colors, pos, colorCount, mode)) { - return NULL; - } - EXPAND_1_COLOR(colorCount); - - SkGradientShaderBase::Descriptor desc; - desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); - return SkNEW_ARGS(SkTwoPointRadialGradient, - (start, startRadius, end, endRadius, desc)); -} - SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, SkScalar startRadius, const SkPoint& end, @@ -897,7 +872,6 @@ SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader) SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient) SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient) SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient) - SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointRadialGradient) SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient) SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp deleted file mode 100644 index 44b73d6a3e..0000000000 --- a/src/effects/gradients/SkTwoPointRadialGradient.cpp +++ /dev/null @@ -1,724 +0,0 @@ - -/* - * Copyright 2012 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#include "SkTwoPointRadialGradient.h" - -/* Two-point radial gradients are specified by two circles, each with a center - point and radius. The gradient can be considered to be a series of - concentric circles, with the color interpolated from the start circle - (at t=0) to the end circle (at t=1). - - For each point (x, y) in the span, we want to find the - interpolated circle that intersects that point. The center - of the desired circle (Cx, Cy) falls at some distance t - along the line segment between the start point (Sx, Sy) and - end point (Ex, Ey): - - Cx = (1 - t) * Sx + t * Ex (0 <= t <= 1) - Cy = (1 - t) * Sy + t * Ey - - The radius of the desired circle (r) is also a linear interpolation t - between the start and end radii (Sr and Er): - - r = (1 - t) * Sr + t * Er - - But - - (x - Cx)^2 + (y - Cy)^2 = r^2 - - so - - (x - ((1 - t) * Sx + t * Ex))^2 - + (y - ((1 - t) * Sy + t * Ey))^2 - = ((1 - t) * Sr + t * Er)^2 - - Solving for t yields - - [(Sx - Ex)^2 + (Sy - Ey)^2 - (Er - Sr)^2)] * t^2 - + [2 * (Sx - Ex)(x - Sx) + 2 * (Sy - Ey)(y - Sy) - 2 * (Er - Sr) * Sr] * t - + [(x - Sx)^2 + (y - Sy)^2 - Sr^2] = 0 - - To simplify, let Dx = Sx - Ex, Dy = Sy - Ey, Dr = Er - Sr, dx = x - Sx, dy = y - Sy - - [Dx^2 + Dy^2 - Dr^2)] * t^2 - + 2 * [Dx * dx + Dy * dy - Dr * Sr] * t - + [dx^2 + dy^2 - Sr^2] = 0 - - A quadratic in t. The two roots of the quadratic reflect the two - possible circles on which the point may fall. Solving for t yields - the gradient value to use. - - If a<0, the start circle is entirely contained in the - end circle, and one of the roots will be <0 or >1 (off the line - segment). If a>0, the start circle falls at least partially - outside the end circle (or vice versa), and the gradient - defines a "tube" where a point may be on one circle (on the - inside of the tube) or the other (outside of the tube). We choose - one arbitrarily. - - In order to keep the math to within the limits of fixed point, - we divide the entire quadratic by Dr^2, and replace - (x - Sx)/Dr with x' and (y - Sy)/Dr with y', giving - - [Dx^2 / Dr^2 + Dy^2 / Dr^2 - 1)] * t^2 - + 2 * [x' * Dx / Dr + y' * Dy / Dr - Sr / Dr] * t - + [x'^2 + y'^2 - Sr^2/Dr^2] = 0 - - (x' and y' are computed by appending the subtract and scale to the - fDstToIndex matrix in the constructor). - - Since the 'A' component of the quadratic is independent of x' and y', it - is precomputed in the constructor. Since the 'B' component is linear in - x' and y', if x and y are linear in the span, 'B' can be computed - incrementally with a simple delta (db below). If it is not (e.g., - a perspective projection), it must be computed in the loop. - -*/ - -namespace { - -inline SkFixed two_point_radial(SkScalar b, SkScalar fx, SkScalar fy, - SkScalar sr2d2, SkScalar foura, - SkScalar oneOverTwoA, bool posRoot) { - SkScalar c = SkScalarSquare(fx) + SkScalarSquare(fy) - sr2d2; - if (0 == foura) { - return SkScalarToFixed(SkScalarDiv(-c, b)); - } - - SkScalar discrim = SkScalarSquare(b) - SkScalarMul(foura, c); - if (discrim < 0) { - discrim = -discrim; - } - SkScalar rootDiscrim = SkScalarSqrt(discrim); - SkScalar result; - if (posRoot) { - result = SkScalarMul(-b + rootDiscrim, oneOverTwoA); - } else { - result = SkScalarMul(-b - rootDiscrim, oneOverTwoA); - } - return SkScalarToFixed(result); -} - -typedef void (* TwoPointRadialShadeProc)(SkScalar fx, SkScalar dx, - SkScalar fy, SkScalar dy, - SkScalar b, SkScalar db, - SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot, - SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, - int count); - -void shadeSpan_twopoint_clamp(SkScalar fx, SkScalar dx, - SkScalar fy, SkScalar dy, - SkScalar b, SkScalar db, - SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot, - SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, - int count) { - for (; count > 0; --count) { - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, - fOneOverTwoA, posRoot); - SkFixed index = SkClampMax(t, 0xFFFF); - SkASSERT(index <= 0xFFFF); - *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift]; - fx += dx; - fy += dy; - b += db; - } -} -void shadeSpan_twopoint_mirror(SkScalar fx, SkScalar dx, - SkScalar fy, SkScalar dy, - SkScalar b, SkScalar db, - SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot, - SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, - int count) { - for (; count > 0; --count) { - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, - fOneOverTwoA, posRoot); - SkFixed index = mirror_tileproc(t); - SkASSERT(index <= 0xFFFF); - *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift]; - fx += dx; - fy += dy; - b += db; - } -} - -void shadeSpan_twopoint_repeat(SkScalar fx, SkScalar dx, - SkScalar fy, SkScalar dy, - SkScalar b, SkScalar db, - SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot, - SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, - int count) { - for (; count > 0; --count) { - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, - fOneOverTwoA, posRoot); - SkFixed index = repeat_tileproc(t); - SkASSERT(index <= 0xFFFF); - *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift]; - fx += dx; - fy += dy; - b += db; - } -} -} - -///////////////////////////////////////////////////////////////////// - -static SkMatrix pts_to_unit(const SkPoint& start, SkScalar diffRadius) { - SkScalar inv = diffRadius ? SkScalarInvert(diffRadius) : 0; - SkMatrix matrix; - matrix.setTranslate(-start.fX, -start.fY); - matrix.postScale(inv, inv); - return matrix; -} - -SkTwoPointRadialGradient::SkTwoPointRadialGradient(const SkPoint& start, SkScalar startRadius, - const SkPoint& end, SkScalar endRadius, - const Descriptor& desc) - : SkGradientShaderBase(desc, pts_to_unit(start, endRadius - startRadius)) - , fCenter1(start) - , fCenter2(end) - , fRadius1(startRadius) - , fRadius2(endRadius) -{ - fDiff = fCenter1 - fCenter2; - fDiffRadius = fRadius2 - fRadius1; - // hack to avoid zero-divide for now - SkScalar inv = fDiffRadius ? SkScalarInvert(fDiffRadius) : 0; - fDiff.fX = SkScalarMul(fDiff.fX, inv); - fDiff.fY = SkScalarMul(fDiff.fY, inv); - fStartRadius = SkScalarMul(fRadius1, inv); - fSr2D2 = SkScalarSquare(fStartRadius); - fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1; - fOneOverTwoA = fA ? SkScalarInvert(fA * 2) : 0; -} - -SkShader::BitmapType SkTwoPointRadialGradient::asABitmap( - SkBitmap* bitmap, - SkMatrix* matrix, - SkShader::TileMode* xy) const { - if (bitmap) { - this->getGradientTableBitmap(bitmap); - } - SkScalar diffL = 0; // just to avoid gcc warning - if (matrix) { - diffL = SkScalarSqrt(SkScalarSquare(fDiff.fX) + - SkScalarSquare(fDiff.fY)); - } - if (matrix) { - if (diffL) { - SkScalar invDiffL = SkScalarInvert(diffL); - matrix->setSinCos(-SkScalarMul(invDiffL, fDiff.fY), - SkScalarMul(invDiffL, fDiff.fX)); - } else { - matrix->reset(); - } - matrix->preConcat(fPtsToUnit); - } - if (xy) { - xy[0] = fTileMode; - xy[1] = kClamp_TileMode; - } - return kTwoPointRadial_BitmapType; -} - -SkShader::GradientType SkTwoPointRadialGradient::asAGradient( - SkShader::GradientInfo* info) const { - if (info) { - commonAsAGradient(info); - info->fPoint[0] = fCenter1; - info->fPoint[1] = fCenter2; - info->fRadius[0] = fRadius1; - info->fRadius[1] = fRadius2; - } - return kRadial2_GradientType; -} - -size_t SkTwoPointRadialGradient::contextSize() const { - return sizeof(TwoPointRadialGradientContext); -} - -SkShader::Context* SkTwoPointRadialGradient::onCreateContext(const ContextRec& rec, - void* storage) const { - // For now, we might have divided by zero, so detect that. - if (0 == fDiffRadius) { - return NULL; - } - return SkNEW_PLACEMENT_ARGS(storage, TwoPointRadialGradientContext, (*this, rec)); -} - -SkTwoPointRadialGradient::TwoPointRadialGradientContext::TwoPointRadialGradientContext( - const SkTwoPointRadialGradient& shader, const ContextRec& rec) - : INHERITED(shader, rec) -{ - // we don't have a span16 proc - fFlags &= ~kHasSpan16_Flag; -} - -void SkTwoPointRadialGradient::TwoPointRadialGradientContext::shadeSpan( - int x, int y, SkPMColor* dstCParam, int count) { - SkASSERT(count > 0); - - const SkTwoPointRadialGradient& twoPointRadialGradient = - static_cast(fShader); - - SkPMColor* SK_RESTRICT dstC = dstCParam; - - // Zero difference between radii: fill with transparent black. - if (twoPointRadialGradient.fDiffRadius == 0) { - sk_bzero(dstC, count * sizeof(*dstC)); - return; - } - SkMatrix::MapXYProc dstProc = fDstToIndexProc; - TileProc proc = twoPointRadialGradient.fTileProc; - const SkPMColor* SK_RESTRICT cache = fCache->getCache32(); - - SkScalar foura = twoPointRadialGradient.fA * 4; - bool posRoot = twoPointRadialGradient.fDiffRadius < 0; - if (fDstToIndexClass != kPerspective_MatrixClass) { - SkPoint srcPt; - dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf, - SkIntToScalar(y) + SK_ScalarHalf, &srcPt); - SkScalar dx, fx = srcPt.fX; - SkScalar dy, fy = srcPt.fY; - - if (fDstToIndexClass == kFixedStepInX_MatrixClass) { - SkFixed fixedX, fixedY; - (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY); - dx = SkFixedToScalar(fixedX); - dy = SkFixedToScalar(fixedY); - } else { - SkASSERT(fDstToIndexClass == kLinear_MatrixClass); - dx = fDstToIndex.getScaleX(); - dy = fDstToIndex.getSkewY(); - } - SkScalar b = (SkScalarMul(twoPointRadialGradient.fDiff.fX, fx) + - SkScalarMul(twoPointRadialGradient.fDiff.fY, fy) - - twoPointRadialGradient.fStartRadius) * 2; - SkScalar db = (SkScalarMul(twoPointRadialGradient.fDiff.fX, dx) + - SkScalarMul(twoPointRadialGradient.fDiff.fY, dy)) * 2; - - TwoPointRadialShadeProc shadeProc = shadeSpan_twopoint_repeat; - if (SkShader::kClamp_TileMode == twoPointRadialGradient.fTileMode) { - shadeProc = shadeSpan_twopoint_clamp; - } else if (SkShader::kMirror_TileMode == twoPointRadialGradient.fTileMode) { - shadeProc = shadeSpan_twopoint_mirror; - } else { - SkASSERT(SkShader::kRepeat_TileMode == twoPointRadialGradient.fTileMode); - } - (*shadeProc)(fx, dx, fy, dy, b, db, - twoPointRadialGradient.fSr2D2, foura, - twoPointRadialGradient.fOneOverTwoA, posRoot, - dstC, cache, count); - } else { // perspective case - SkScalar dstX = SkIntToScalar(x); - SkScalar dstY = SkIntToScalar(y); - for (; count > 0; --count) { - SkPoint srcPt; - dstProc(fDstToIndex, dstX, dstY, &srcPt); - SkScalar fx = srcPt.fX; - SkScalar fy = srcPt.fY; - SkScalar b = (SkScalarMul(twoPointRadialGradient.fDiff.fX, fx) + - SkScalarMul(twoPointRadialGradient.fDiff.fY, fy) - - twoPointRadialGradient.fStartRadius) * 2; - SkFixed t = two_point_radial(b, fx, fy, twoPointRadialGradient.fSr2D2, foura, - twoPointRadialGradient.fOneOverTwoA, posRoot); - SkFixed index = proc(t); - SkASSERT(index <= 0xFFFF); - *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift]; - dstX += SK_Scalar1; - } - } -} - -#ifndef SK_IGNORE_TO_STRING -void SkTwoPointRadialGradient::toString(SkString* str) const { - str->append("SkTwoPointRadialGradient: ("); - - str->append("center1: ("); - str->appendScalar(fCenter1.fX); - str->append(", "); - str->appendScalar(fCenter1.fY); - str->append(") radius1: "); - str->appendScalar(fRadius1); - str->append(" "); - - str->append("center2: ("); - str->appendScalar(fCenter2.fX); - str->append(", "); - str->appendScalar(fCenter2.fY); - str->append(") radius2: "); - str->appendScalar(fRadius2); - str->append(" "); - - this->INHERITED::toString(str); - - str->append(")"); -} -#endif - -SkFlattenable* SkTwoPointRadialGradient::CreateProc(SkReadBuffer& buffer) { - DescriptorScope desc; - if (!desc.unflatten(buffer)) { - return NULL; - } - const SkPoint c1 = buffer.readPoint(); - const SkPoint c2 = buffer.readPoint(); - const SkScalar r1 = buffer.readScalar(); - const SkScalar r2 = buffer.readScalar(); - return SkGradientShader::CreateTwoPointRadial(c1, r1, c2, r2, desc.fColors, desc.fPos, - desc.fCount, desc.fTileMode, desc.fGradFlags, - desc.fLocalMatrix); -} - -void SkTwoPointRadialGradient::flatten( - SkWriteBuffer& buffer) const { - this->INHERITED::flatten(buffer); - buffer.writePoint(fCenter1); - buffer.writePoint(fCenter2); - buffer.writeScalar(fRadius1); - buffer.writeScalar(fRadius2); -} - -///////////////////////////////////////////////////////////////////// - -#if SK_SUPPORT_GPU - -#include "SkGr.h" -#include "gl/builders/GrGLProgramBuilder.h" - -// For brevity -typedef GrGLProgramDataManager::UniformHandle UniformHandle; - -class GrGLRadial2Gradient : public GrGLGradientEffect { - -public: - - GrGLRadial2Gradient(const GrProcessor&); - virtual ~GrGLRadial2Gradient() { } - - virtual void emitCode(GrGLFPBuilder*, - const GrFragmentProcessor&, - const char* outputColor, - const char* inputColor, - const TransformedCoordsArray&, - const TextureSamplerArray&) override; - void setData(const GrGLProgramDataManager&, const GrProcessor&) override; - - static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b); - -protected: - - UniformHandle fParamUni; - - const char* fVSVaryingName; - const char* fFSVaryingName; - - bool fIsDegenerate; - - // @{ - /// Values last uploaded as uniforms - - SkScalar fCachedCenter; - SkScalar fCachedRadius; - bool fCachedPosRoot; - - // @} - -private: - - typedef GrGLGradientEffect INHERITED; - -}; - -///////////////////////////////////////////////////////////////////// - -class GrRadial2Gradient : public GrGradientEffect { -public: - static GrFragmentProcessor* Create(GrContext* ctx, - const SkTwoPointRadialGradient& shader, - const SkMatrix& matrix, - SkShader::TileMode tm) { - return SkNEW_ARGS(GrRadial2Gradient, (ctx, shader, matrix, tm)); - } - - virtual ~GrRadial2Gradient() { } - - const char* name() const override { return "Two-Point Radial Gradient"; } - - virtual void getGLProcessorKey(const GrGLSLCaps& caps, - GrProcessorKeyBuilder* b) const override { - GrGLRadial2Gradient::GenKey(*this, caps, b); - } - - GrGLFragmentProcessor* createGLInstance() const override { - return SkNEW_ARGS(GrGLRadial2Gradient, (*this)); - } - - // The radial gradient parameters can collapse to a linear (instead of quadratic) equation. - bool isDegenerate() const { return SK_Scalar1 == fCenterX1; } - SkScalar center() const { return fCenterX1; } - SkScalar radius() const { return fRadius0; } - bool isPosRoot() const { return SkToBool(fPosRoot); } - -private: - bool onIsEqual(const GrFragmentProcessor& sBase) const override { - const GrRadial2Gradient& s = sBase.cast(); - return (INHERITED::onIsEqual(sBase) && - this->fCenterX1 == s.fCenterX1 && - this->fRadius0 == s.fRadius0 && - this->fPosRoot == s.fPosRoot); - } - - GrRadial2Gradient(GrContext* ctx, - const SkTwoPointRadialGradient& shader, - const SkMatrix& matrix, - SkShader::TileMode tm) - : INHERITED(ctx, shader, matrix, tm) - , fCenterX1(shader.getCenterX1()) - , fRadius0(shader.getStartRadius()) - , fPosRoot(shader.getDiffRadius() < 0) { - this->initClassID(); - // We pass the linear part of the quadratic as a varying. - // float b = 2.0 * (fCenterX1 * x - fRadius0 * z) - fBTransform = this->getCoordTransform(); - SkMatrix& bMatrix = *fBTransform.accessMatrix(); - bMatrix[SkMatrix::kMScaleX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMScaleX]) - - SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp0])); - bMatrix[SkMatrix::kMSkewX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMSkewX]) - - SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp1])); - bMatrix[SkMatrix::kMTransX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMTransX]) - - SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp2])); - this->addCoordTransform(&fBTransform); - } - - GR_DECLARE_FRAGMENT_PROCESSOR_TEST; - - // @{ - // Cache of values - these can change arbitrarily, EXCEPT - // we shouldn't change between degenerate and non-degenerate?! - - GrCoordTransform fBTransform; - SkScalar fCenterX1; - SkScalar fRadius0; - SkBool8 fPosRoot; - - // @} - - typedef GrGradientEffect INHERITED; -}; - -///////////////////////////////////////////////////////////////////// - -GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadial2Gradient); - -GrFragmentProcessor* GrRadial2Gradient::TestCreate(SkRandom* random, - GrContext* context, - const GrDrawTargetCaps&, - GrTexture**) { - SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; - SkScalar radius1 = random->nextUScalar1(); - SkPoint center2; - SkScalar radius2; - do { - center2.set(random->nextUScalar1(), random->nextUScalar1()); - radius2 = random->nextUScalar1 (); - // There is a bug in two point radial gradients with identical radii - } while (radius1 == radius2); - - SkColor colors[kMaxRandomGradientColors]; - SkScalar stopsArray[kMaxRandomGradientColors]; - SkScalar* stops = stopsArray; - SkShader::TileMode tm; - int colorCount = RandomGradientParams(random, colors, &stops, &tm); - SkAutoTUnref shader(SkGradientShader::CreateTwoPointRadial(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); - SkPaint paint; - GrFragmentProcessor* fp; - GrColor paintColor; - SkAssertResult(shader->asFragmentProcessor(context, paint, - GrTest::TestMatrix(random), NULL, - &paintColor, &fp)); - return fp; -} - -///////////////////////////////////////////////////////////////////// - -GrGLRadial2Gradient::GrGLRadial2Gradient(const GrProcessor& processor) - : fVSVaryingName(NULL) - , fFSVaryingName(NULL) - , fCachedCenter(SK_ScalarMax) - , fCachedRadius(-SK_ScalarMax) - , fCachedPosRoot(0) { - - const GrRadial2Gradient& data = processor.cast(); - fIsDegenerate = data.isDegenerate(); -} - -void GrGLRadial2Gradient::emitCode(GrGLFPBuilder* builder, - const GrFragmentProcessor& fp, - const char* outputColor, - const char* inputColor, - const TransformedCoordsArray& coords, - const TextureSamplerArray& samplers) { - const GrRadial2Gradient& ge = fp.cast(); - this->emitUniforms(builder, ge); - fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility, - kFloat_GrSLType, kDefault_GrSLPrecision, - "Radial2FSParams", 6); - - SkString cName("c"); - SkString ac4Name("ac4"); - SkString rootName("root"); - SkString t; - SkString p0; - SkString p1; - SkString p2; - SkString p3; - SkString p4; - SkString p5; - builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0); - builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1); - builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2); - builder->getUniformVariable(fParamUni).appendArrayAccess(3, &p3); - builder->getUniformVariable(fParamUni).appendArrayAccess(4, &p4); - builder->getUniformVariable(fParamUni).appendArrayAccess(5, &p5); - - GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); - // We interpolate the linear component in coords[1]. - SkASSERT(coords[0].getType() == coords[1].getType()); - const char* coords2D; - SkString bVar; - if (kVec3f_GrSLType == coords[0].getType()) { - fsBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy, %s.x) / %s.z;\n", - coords[0].c_str(), coords[1].c_str(), coords[0].c_str()); - coords2D = "interpolants.xy"; - bVar = "interpolants.z"; - } else { - coords2D = coords[0].c_str(); - bVar.printf("%s.x", coords[1].c_str()); - } - - // c = (x^2)+(y^2) - params[4] - fsBuilder->codeAppendf("\tfloat %s = dot(%s, %s) - %s;\n", - cName.c_str(), coords2D, coords2D, p4.c_str()); - - // If we aren't degenerate, emit some extra code, and accept a slightly - // more complex coord. - if (!fIsDegenerate) { - - // ac4 = 4.0 * params[0] * c - fsBuilder->codeAppendf("\tfloat %s = %s * 4.0 * %s;\n", - ac4Name.c_str(), p0.c_str(), - cName.c_str()); - - // root = sqrt(b^2-4ac) - // (abs to avoid exception due to fp precision) - fsBuilder->codeAppendf("\tfloat %s = sqrt(abs(%s*%s - %s));\n", - rootName.c_str(), bVar.c_str(), bVar.c_str(), - ac4Name.c_str()); - - // t is: (-b + params[5] * sqrt(b^2-4ac)) * params[1] - t.printf("(-%s + %s * %s) * %s", bVar.c_str(), p5.c_str(), - rootName.c_str(), p1.c_str()); - } else { - // t is: -c/b - t.printf("-%s / %s", cName.c_str(), bVar.c_str()); - } - - this->emitColor(builder, ge, t.c_str(), outputColor, inputColor, samplers); -} - -void GrGLRadial2Gradient::setData(const GrGLProgramDataManager& pdman, - const GrProcessor& processor) { - INHERITED::setData(pdman, processor); - const GrRadial2Gradient& data = processor.cast(); - SkASSERT(data.isDegenerate() == fIsDegenerate); - SkScalar centerX1 = data.center(); - SkScalar radius0 = data.radius(); - if (fCachedCenter != centerX1 || - fCachedRadius != radius0 || - fCachedPosRoot != data.isPosRoot()) { - - SkScalar a = SkScalarMul(centerX1, centerX1) - SK_Scalar1; - - // When we're in the degenerate (linear) case, the second - // value will be INF but the program doesn't read it. (We - // use the same 6 uniforms even though we don't need them - // all in the linear case just to keep the code complexity - // down). - float values[6] = { - SkScalarToFloat(a), - 1 / (2.f * SkScalarToFloat(a)), - SkScalarToFloat(centerX1), - SkScalarToFloat(radius0), - SkScalarToFloat(SkScalarMul(radius0, radius0)), - data.isPosRoot() ? 1.f : -1.f - }; - - pdman.set1fv(fParamUni, 6, values); - fCachedCenter = centerX1; - fCachedRadius = radius0; - fCachedPosRoot = data.isPosRoot(); - } -} - -void GrGLRadial2Gradient::GenKey(const GrProcessor& processor, - const GrGLSLCaps&, GrProcessorKeyBuilder* b) { - uint32_t* key = b->add32n(2); - key[0] = GenBaseGradientKey(processor); - key[1] = processor.cast().isDegenerate(); -} - -///////////////////////////////////////////////////////////////////// - -bool SkTwoPointRadialGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint, - const SkMatrix&, - const SkMatrix* localMatrix, GrColor* paintColor, - GrFragmentProcessor** fp) const { - SkASSERT(context); - - // invert the localM, translate to center1 (fPtsToUni), rotate so center2 is on x axis. - SkMatrix matrix; - if (!this->getLocalMatrix().invert(&matrix)) { - return false; - } - if (localMatrix) { - SkMatrix inv; - if (!localMatrix->invert(&inv)) { - return false; - } - matrix.postConcat(inv); - } - matrix.postConcat(fPtsToUnit); - - SkScalar diffLen = fDiff.length(); - if (0 != diffLen) { - SkScalar invDiffLen = SkScalarInvert(diffLen); - SkMatrix rot; - rot.setSinCos(-SkScalarMul(invDiffLen, fDiff.fY), - SkScalarMul(invDiffLen, fDiff.fX)); - matrix.postConcat(rot); - } - - *paintColor = SkColor2GrColorJustAlpha(paint.getColor()); - *fp = GrRadial2Gradient::Create(context, *this, matrix, fTileMode); - - return true; -} - -#else - -bool SkTwoPointRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&, - const SkMatrix*, - GrColor*, GrFragmentProcessor**) const { - SkDEBUGFAIL("Should not call in GPU-less build"); - return false; -} - -#endif diff --git a/src/effects/gradients/SkTwoPointRadialGradient.h b/src/effects/gradients/SkTwoPointRadialGradient.h deleted file mode 100644 index 7da85d6d88..0000000000 --- a/src/effects/gradients/SkTwoPointRadialGradient.h +++ /dev/null @@ -1,64 +0,0 @@ - -/* - * Copyright 2012 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - - #ifndef SkTwoPointRadialGradient_DEFINED - #define SkTwoPointRadialGradient_DEFINED - - #include "SkGradientShaderPriv.h" - -class SkTwoPointRadialGradient : public SkGradientShaderBase { -public: - SkTwoPointRadialGradient(const SkPoint& start, SkScalar startRadius, - const SkPoint& end, SkScalar endRadius, - const Descriptor&); - - virtual BitmapType asABitmap(SkBitmap* bitmap, - SkMatrix* matrix, - TileMode* xy) const override; - GradientType asAGradient(GradientInfo* info) const override; - virtual bool asFragmentProcessor(GrContext* context, const SkPaint&, const SkMatrix& viewM, - const SkMatrix*, GrColor*, - GrFragmentProcessor**) const override; - - size_t contextSize() const override; - - class TwoPointRadialGradientContext : public SkGradientShaderBase::GradientShaderBaseContext { - public: - TwoPointRadialGradientContext(const SkTwoPointRadialGradient&, const ContextRec&); - - void shadeSpan(int x, int y, SkPMColor dstC[], int count) override; - - private: - typedef SkGradientShaderBase::GradientShaderBaseContext INHERITED; - }; - - SkScalar getCenterX1() const { return fDiff.length(); } - SkScalar getStartRadius() const { return fStartRadius; } - SkScalar getDiffRadius() const { return fDiffRadius; } - - SK_TO_STRING_OVERRIDE() - SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTwoPointRadialGradient) - -protected: - SkTwoPointRadialGradient(SkReadBuffer& buffer); - void flatten(SkWriteBuffer& buffer) const override; - Context* onCreateContext(const ContextRec&, void* storage) const override; - -private: - const SkPoint fCenter1; - const SkPoint fCenter2; - const SkScalar fRadius1; - const SkScalar fRadius2; - SkPoint fDiff; - SkScalar fStartRadius, fDiffRadius, fSr2D2, fA, fOneOverTwoA; - - friend class SkGradientShader; - typedef SkGradientShaderBase INHERITED; -}; - -#endif diff --git a/src/gpu/GrProcessor.cpp b/src/gpu/GrProcessor.cpp index 9be9e4063b..23f0ed16d8 100644 --- a/src/gpu/GrProcessor.cpp +++ b/src/gpu/GrProcessor.cpp @@ -49,7 +49,7 @@ GrProcessorTestFactory::GetFactories() { * we verify the count is as expected. If a new factory is added, then these numbers must be * manually adjusted. */ -static const int kFPFactoryCount = 38; +static const int kFPFactoryCount = 37; static const int kGPFactoryCount = 14; static const int kXPFactoryCount = 5; diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp index 37f2e51e4a..5fcc4355cd 100644 --- a/src/gpu/SkGpuDevice.cpp +++ b/src/gpu/SkGpuDevice.cpp @@ -347,19 +347,6 @@ void SkGpuDevice::replaceRenderTarget(bool shouldRetainContent) { /////////////////////////////////////////////////////////////////////////////// -SK_COMPILE_ASSERT(SkShader::kNone_BitmapType == 0, shader_type_mismatch); -SK_COMPILE_ASSERT(SkShader::kDefault_BitmapType == 1, shader_type_mismatch); -SK_COMPILE_ASSERT(SkShader::kRadial_BitmapType == 2, shader_type_mismatch); -SK_COMPILE_ASSERT(SkShader::kSweep_BitmapType == 3, shader_type_mismatch); -SK_COMPILE_ASSERT(SkShader::kTwoPointRadial_BitmapType == 4, - shader_type_mismatch); -SK_COMPILE_ASSERT(SkShader::kTwoPointConical_BitmapType == 5, - shader_type_mismatch); -SK_COMPILE_ASSERT(SkShader::kLinear_BitmapType == 6, shader_type_mismatch); -SK_COMPILE_ASSERT(SkShader::kLast_BitmapType == 6, shader_type_mismatch); - -/////////////////////////////////////////////////////////////////////////////// - void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) { CHECK_SHOULD_DRAW(draw); GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPaint", fContext); diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp index cf4188123a..c2f0bc4677 100644 --- a/src/pdf/SkPDFShader.cpp +++ b/src/pdf/SkPDFShader.cpp @@ -290,58 +290,6 @@ static SkString radialCode(const SkShader::GradientInfo& info, return function; } -/* The math here is all based on the description in Two_Point_Radial_Gradient, - with one simplification, the coordinate space has been scaled so that - Dr = 1. This means we don't need to scale the entire equation by 1/Dr^2. - */ -static SkString twoPointRadialCode(const SkShader::GradientInfo& info, - const SkMatrix& perspectiveRemover) { - SkScalar dx = info.fPoint[0].fX - info.fPoint[1].fX; - SkScalar dy = info.fPoint[0].fY - info.fPoint[1].fY; - SkScalar sr = info.fRadius[0]; - SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) - SK_Scalar1; - bool posRoot = info.fRadius[1] > info.fRadius[0]; - - // We start with a stack of (x y), copy it and then consume one copy in - // order to calculate b and the other to calculate c. - SkString function("{"); - - function.append(apply_perspective_to_coordinates(perspectiveRemover)); - - function.append("2 copy "); - - // Calculate -b and b^2. - function.appendScalar(dy); - function.append(" mul exch "); - function.appendScalar(dx); - function.append(" mul add "); - function.appendScalar(sr); - function.append(" sub 2 mul neg dup dup mul\n"); - - // Calculate c - function.append("4 2 roll dup mul exch dup mul add "); - function.appendScalar(SkScalarMul(sr, sr)); - function.append(" sub\n"); - - // Calculate the determinate - function.appendScalar(SkScalarMul(SkIntToScalar(4), a)); - function.append(" mul sub abs sqrt\n"); - - // And then the final value of t. - if (posRoot) { - function.append("sub "); - } else { - function.append("add "); - } - function.appendScalar(SkScalarMul(SkIntToScalar(2), a)); - function.append(" div\n"); - - tileModeCode(info.fTileMode, &function); - gradientFunctionCode(info, &function); - function.append("}"); - return function; -} - /* Conical gradient shader, based on the Canvas spec for radial gradients See: http://www.w3.org/TR/2dcontext/#dom-context-2d-createradialgradient */ @@ -782,17 +730,6 @@ SkPDFFunctionShader* SkPDFFunctionShader::Create( transformPoints[1].fX += info->fRadius[0]; codeFunction = &radialCode; break; - case SkShader::kRadial2_GradientType: { - // Bail out if the radii are the same. - if (info->fRadius[0] == info->fRadius[1]) { - return NULL; - } - transformPoints[1] = transformPoints[0]; - SkScalar dr = info->fRadius[1] - info->fRadius[0]; - transformPoints[1].fX += dr; - codeFunction = &twoPointRadialCode; - break; - } case SkShader::kConical_GradientType: { transformPoints[1] = transformPoints[0]; transformPoints[1].fX += SK_Scalar1; @@ -852,7 +789,7 @@ SkPDFFunctionShader* SkPDFFunctionShader::Create( // state.fInfo // in translating from x, y coordinates to the t parameter. So, we have // to transform the points and radii according to the calculated matrix. - if (state.fType == SkShader::kRadial2_GradientType) { + if (state.fType == SkShader::kConical_GradientType) { SkShader::GradientInfo twoPointRadialInfo = *info; SkMatrix inverseMapperMatrix; if (!mapperMatrix.invert(&inverseMapperMatrix)) { @@ -1143,7 +1080,6 @@ bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const { return false; } break; - case SkShader::kRadial2_GradientType: case SkShader::kConical_GradientType: if (fInfo.fPoint[1] != b.fInfo.fPoint[1] || fInfo.fRadius[0] != b.fInfo.fRadius[0] || diff --git a/tests/GradientTest.cpp b/tests/GradientTest.cpp index f530b3e263..a2814a3961 100644 --- a/tests/GradientTest.cpp +++ b/tests/GradientTest.cpp @@ -107,22 +107,6 @@ static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& rec) { REPORTER_ASSERT(reporter, info.fRadius[0] == rec.fRadius[0]); } -static void radial2_gradproc(skiatest::Reporter* reporter, const GradRec& rec) { - SkAutoTUnref s(SkGradientShader::CreateTwoPointRadial(rec.fPoint[0], - rec.fRadius[0], - rec.fPoint[1], - rec.fRadius[1], - rec.fColors, - rec.fPos, - rec.fColorCount, - rec.fTileMode)); - - SkShader::GradientInfo info; - rec.gradCheck(reporter, s, &info, SkShader::kRadial2_GradientType); - REPORTER_ASSERT(reporter, !memcmp(info.fPoint, rec.fPoint, 2 * sizeof(SkPoint))); - REPORTER_ASSERT(reporter, !memcmp(info.fRadius, rec.fRadius, 2 * sizeof(SkScalar))); -} - static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& rec) { SkAutoTUnref s(SkGradientShader::CreateSweep(rec.fPoint[0].fX, rec.fPoint[0].fY, @@ -203,7 +187,6 @@ static void TestGradientShaders(skiatest::Reporter* reporter) { color_gradproc, linear_gradproc, radial_gradproc, - radial2_gradproc, sweep_gradproc, conical_gradproc, };