AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "Revert "Delete SkGaussianEdgeShader""

Browse Source 
This reverts commit 9d14f936cc.

Reason for revert: Android fix merged.

Original change's description:
> Revert "Delete SkGaussianEdgeShader"
> 
> This reverts commit 64790a3714.
> 
> Reason for revert: pending Android fix merge.
> 
> Original change's description:
> > Delete SkGaussianEdgeShader
> > 
> > No longer used.
> > 
> > Change-Id: I65a61696060ca19f528066ea587e140798450e36
> > Reviewed-on: https://skia-review.googlesource.com/18132
> > Reviewed-by: Jim Van Verth <jvanverth@google.com>
> > Commit-Queue: Florin Malita <fmalita@chromium.org>
> > 
> 
> TBR=jvanverth@google.com,fmalita@chromium.org,reed@google.com
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> 
> Change-Id: I88a428e942c78b1fc8e70501ba7fdda5727b2ab2
> Reviewed-on: https://skia-review.googlesource.com/18156
> Reviewed-by: Florin Malita <fmalita@chromium.org>
> Commit-Queue: Florin Malita <fmalita@chromium.org>
> 

TBR=mtklein@google.com,jvanverth@google.com,reviews@skia.org,fmalita@chromium.org,reed@google.com
No-Presubmit: true
No-Tree-Checks: true
No-Try: true

Change-Id: Ia6c97a79a6425a28fab49984691505bf89ac9736
Reviewed-on: https://skia-review.googlesource.com/18227
Reviewed-by: Florin Malita <fmalita@chromium.org>
Commit-Queue: Florin Malita <fmalita@chromium.org>
This commit is contained in:
Florin Malita 2017-05-31 14:20:12 +00:00 committed by Skia Commit-Bot
parent 0cc507d225
commit bb3f5621a9
10 changed files with 3 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fuzz/FuzzCanvas.cpp
View File

@ -38,7 +38,6 @@
#include "SkDiscretePathEffect.h"
#include "SkDisplacementMapEffect.h"
#include "SkDropShadowImageFilter.h"
#include "SkGaussianEdgeShader.h"
#include "SkGradientShader.h"
#include "SkHighContrastFilter.h"
#include "SkImageSource.h"
@ -382,7 +381,8 @@ static sk_sp<SkShader> make_fuzz_shader(Fuzz* fuzz, int depth) {
}
// EFFECTS:
case 9:
return SkGaussianEdgeShader::Make();
// Deprecated SkGaussianEdgeShader
return nullptr;
case 10: {
constexpr int kMaxColors = 12;
SkPoint pts[2];

222
gm/gaussianedge.cpp
View File

@ -1,222 +0,0 @@
/*
* Copyright 2016 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 "SkColorFilter.h"
#include "SkGaussianEdgeShader.h"
#include "SkRRect.h"
//#define VIZ 1
#ifdef VIZ
#include "SkStroke.h"
static void draw_stroke(SkCanvas* canvas, const SkRRect& rr, const SkPaint& p, SkColor color) {
SkPath output;
if (SkPaint::kFill_Style == p.getStyle()) {
output.addRRect(rr);
} else {
SkPath input;
input.addRRect(rr);
SkStroke stroke(p);
stroke.strokePath(input, &output);
}
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
paint.setColor(color);
canvas->drawPath(output, paint);
}
static void extract_pts(const SkBitmap& bm, SkTDArray<SkPoint>* pts,
int xOff, int width) {
pts->rewind();
for (int x = 0; x < width; ++x) {
SkColor color = bm.getColor(xOff+x, 0);
pts->append()->set(SkIntToScalar(x), 255.0f-SkColorGetB(color));
if (x > 0 && x < width-1) {
pts->append()->set(SkIntToScalar(x), 255.0f-SkColorGetB(color));
}
}
}
static void draw_row(SkCanvas* canvas, int row, int width) {
SkPaint paint;
paint.setAntiAlias(true);
SkBitmap readback;
if (!canvas->readPixels(SkIRect::MakeXYWH(0, row, width, 1), &readback)) {
return;
}
SkTDArray<SkPoint> pts;
pts.setReserve(width/3);
extract_pts(readback, &pts, 0, width/3);
paint.setColor(SK_ColorRED);
canvas->drawPoints(SkCanvas::kLines_PointMode, pts.count(), pts.begin(), paint);
extract_pts(readback, &pts, width/3, width/3);
paint.setColor(SK_ColorGREEN);
canvas->drawPoints(SkCanvas::kLines_PointMode, pts.count(), pts.begin(), paint);
extract_pts(readback, &pts, 2*width/3, width/3);
paint.setColor(SK_ColorBLUE);
canvas->drawPoints(SkCanvas::kLines_PointMode, pts.count(), pts.begin(), paint);
}
#endif
namespace skiagm {
// This GM exercises the SkGaussianEdgeShader.
// It draws three columns showing filled, stroked, and stroke and filled rendering.
// It draws three rows showing a blur radius smaller than, equal to
// and, finally, double the RRect's corner radius
// In VIZ mode an extra column is drawn showing the blur ramps (they should all line up).
class GaussianEdgeGM : public GM {
public:
GaussianEdgeGM() {
this->setBGColor(SK_ColorWHITE);
}
protected:
SkString onShortName() override {
return SkString("gaussianedge");
}
SkISize onISize() override {
int numCols = kNumBaseCols;
#ifdef VIZ
numCols++;
#endif
return SkISize::Make(kPad + numCols*(kCellWidth+kPad),
kPad + kNumRows*(kCellWidth+kPad));
}
static void DrawRow(SkCanvas* canvas, int blurRad, int midLine) {
SkAutoCanvasRestore acr(canvas, true);
SkRRect rrects[kNumBaseCols];
SkPaint paints[kNumBaseCols];
{
const SkRect r = SkRect::MakeIWH(kRRSize, kRRSize);
const SkRRect baseRR = SkRRect::MakeRectXY(r,
SkIntToScalar(kRRRad),
SkIntToScalar(kRRRad));
SkPaint basePaint;
basePaint.setAntiAlias(true);
basePaint.setColor(SkColorSetARGB(255, (4 * blurRad) >> 8, (4 * blurRad) & 0xff, 0));
basePaint.setShader(SkGaussianEdgeShader::Make());
basePaint.setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorRED,
SkBlendMode::kModulate));
//----
paints[0] = basePaint;
rrects[0] = baseRR;
//----
paints[1] = basePaint;
paints[1].setStyle(SkPaint::kStroke_Style);
rrects[1] = baseRR;
if (blurRad/2.0f < kRRRad) {
rrects[1].inset(blurRad/2.0f, blurRad/2.0f);
paints[1].setStrokeWidth(SkIntToScalar(blurRad));
} else {
SkScalar inset = kRRRad - 0.5f;
rrects[1].inset(inset, inset);
SkScalar pad = blurRad/2.0f - inset;
paints[1].setStrokeWidth(blurRad + 2.0f * pad);
paints[1].setColor(SkColorSetARGB(255, (4 * blurRad) >> 8, (4 * blurRad) & 0xff,
(int)(4.0f*pad)));
}
//----
paints[2] = basePaint;
paints[2].setStyle(SkPaint::kStrokeAndFill_Style);
rrects[2] = baseRR;
if (blurRad/2.0f < kRRRad) {
rrects[2].inset(blurRad/2.0f, blurRad/2.0f);
paints[2].setStrokeWidth(SkIntToScalar(blurRad));
} else {
SkScalar inset = kRRRad - 0.5f;
rrects[2].inset(inset, inset);
SkScalar pad = blurRad/2.0f - inset;
paints[2].setStrokeWidth(blurRad + 2.0f * pad);
paints[2].setColor(SkColorSetARGB(255, (4 * blurRad) >> 8, (4 * blurRad) & 0xff,
(int)(4.0f*pad)));
}
}
//----
canvas->save();
// draw the shadows
for (int i = 0; i < kNumBaseCols; ++i) {
canvas->drawRRect(rrects[i], paints[i]);
canvas->translate(SkIntToScalar(kCellWidth+kPad), 0.0f);
}
#ifdef VIZ
// draw the visualization of the shadow ramps
draw_row(canvas, midLine, 3*(kRRSize+kPad));
#endif
canvas->restore();
#ifdef VIZ
const SkColor colors[kNumBaseCols] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
// circle back and draw the stroked geometry (they would mess up the viz otherwise)
for (int i = 0; i < kNumBaseCols; ++i) {
draw_stroke(canvas, rrects[i], paints[i], colors[i]);
canvas->translate(SkIntToScalar(kCellWidth+kPad), 0.0f);
}
#endif
}
void onDraw(SkCanvas* canvas) override {
GrRenderTargetContext* renderTargetContext =
canvas->internal_private_accessTopLayerRenderTargetContext();
if (!renderTargetContext) {
skiagm::GM::DrawGpuOnlyMessage(canvas);
return;
}
const int blurRadii[kNumRows] = { kRRRad/2, kRRRad, 2*kRRRad };
canvas->translate(SkIntToScalar(kPad), SkIntToScalar(kPad));
for (int i = 0; i < kNumRows; ++i) {
DrawRow(canvas, blurRadii[i], kPad+(i*kRRSize)+kRRSize/2);
canvas->translate(0.0f, SkIntToScalar(kCellWidth+kPad));
}
}
private:
static const int kNumRows = 3;
static const int kNumBaseCols = 3;
static const int kPad = 5;
static const int kRRSize = 256;
static const int kRRRad = 64;
static const int kCellWidth = kRRSize;
typedef GM INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
DEF_GM(return new GaussianEdgeGM;)
}

17
gm/reveal.cpp
View File

@ -9,7 +9,6 @@
#include "sk_tool_utils.h"
#include "SkAnimTimer.h"
#include "SkBlurMaskFilter.h"
#include "SkGaussianEdgeShader.h"
#include "SkRRectsGaussianEdgeMaskFilter.h"
#include "SkPath.h"
#include "SkPathOps.h"
@ -314,7 +313,6 @@ namespace skiagm {
class RevealGM : public GM {
public:
enum Mode {
kGaussianEdge_Mode,
kBlurMask_Mode,
kRRectsGaussianEdge_Mode,
@ -386,20 +384,7 @@ protected:
// The goal is to replace this clipped draw (which clips the
// shadow) with a draw using the geometric clip
if (kGaussianEdge_Mode == fMode) {
canvas->save();
clipObj->clip(canvas);
// Draw with GaussianEdgeShader
SkPaint paint;
paint.setAntiAlias(true);
// G channel is an F6.2 radius
int iBlurRad = (int)(4.0f * fBlurRadius);
paint.setColor(SkColorSetARGB(255, iBlurRad >> 8, iBlurRad & 0xFF, 0));
paint.setShader(SkGaussianEdgeShader::Make());
drawObj->draw(canvas, paint);
canvas->restore();
} else if (kBlurMask_Mode == fMode) {
if (kBlurMask_Mode == fMode) {
SkPath clippedPath;
SkScalar sigma = fBlurRadius / 4.0f;

2
gn/effects.gni
View File

@ -38,8 +38,6 @@ skia_effects_sources = [
"$_src/effects/SkEmbossMask_Table.h",
"$_src/effects/SkEmbossMaskFilter.cpp",
"$_src/effects/SkImageSource.cpp",
"$_src/effects/SkGaussianEdgeShader.cpp",
"$_src/effects/SkGaussianEdgeShader.h",
"$_src/effects/SkHighContrastFilter.cpp",
"$_src/effects/SkLayerDrawLooper.cpp",
"$_src/effects/SkLayerRasterizer.cpp",

1
gn/gm.gni
View File

@ -135,7 +135,6 @@ gm_sources = [
"$_gm/gammaencodedpremul.cpp",
"$_gm/gammatext.cpp",
"$_gm/gamut.cpp",
"$_gm/gaussianedge.cpp",
"$_gm/getpostextpath.cpp",
"$_gm/giantbitmap.cpp",
"$_gm/glyph_pos.cpp",

1
samplecode/SampleAndroidShadows.cpp
View File

@ -12,7 +12,6 @@
#include "SkColorFilter.h"
#include "SkCamera.h"
#include "SkCanvas.h"
#include "SkGaussianEdgeShader.h"
#include "SkPath.h"
#include "SkPathOps.h"
#include "SkPoint3.h"

1
samplecode/SampleShadowUtils.cpp
View File

@ -12,7 +12,6 @@
#include "SkColorFilter.h"
#include "SkCamera.h"
#include "SkCanvas.h"
#include "SkGaussianEdgeShader.h"
#include "SkPath.h"
#include "SkPathOps.h"
#include "SkPoint3.h"

95
src/effects/SkGaussianEdgeShader.cpp
View File

@ -1,95 +0,0 @@
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkGaussianEdgeShader.h"
#include "SkReadBuffer.h"
#include "SkWriteBuffer.h"
class SkArenaAlloc;
/** \class SkGaussianEdgeShaderImpl
This subclass of shader applies a Gaussian to shadow edge
If the primitive supports an implicit distance to the edge, the radius of the blur is specified
by r & g values of the color in 14.2 fixed point. For spot shadows, we increase the stroke width
to set the shadow against the shape. This pad is specified by b, also in 6.2 fixed point.
When not using implicit distance, then b in the input color represents the input to the
blur function.
*/
class SkGaussianEdgeShaderImpl : public SkShaderBase {
public:
SkGaussianEdgeShaderImpl() {}
bool isOpaque() const override;
#if SK_SUPPORT_GPU
sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkGaussianEdgeShaderImpl)
protected:
void flatten(SkWriteBuffer&) const override;
Context* onMakeContext(const ContextRec& rec, SkArenaAlloc* storage) const override {
return nullptr;
}
private:
friend class SkGaussianEdgeShader;
typedef SkShaderBase INHERITED;
};
////////////////////////////////////////////////////////////////////////////
#if SK_SUPPORT_GPU
#include "effects/GrBlurredEdgeFragmentProcessor.h"
////////////////////////////////////////////////////////////////////////////
sk_sp<GrFragmentProcessor> SkGaussianEdgeShaderImpl::asFragmentProcessor(const AsFPArgs&) const {
return GrBlurredEdgeFP::Make(GrBlurredEdgeFP::kGaussian_Mode);
}
#endif
////////////////////////////////////////////////////////////////////////////
bool SkGaussianEdgeShaderImpl::isOpaque() const {
return false;
}
////////////////////////////////////////////////////////////////////////////
#ifndef SK_IGNORE_TO_STRING
void SkGaussianEdgeShaderImpl::toString(SkString* str) const {
str->appendf("GaussianEdgeShader: ()");
}
#endif
sk_sp<SkFlattenable> SkGaussianEdgeShaderImpl::CreateProc(SkReadBuffer& buf) {
return sk_make_sp<SkGaussianEdgeShaderImpl>();
}
void SkGaussianEdgeShaderImpl::flatten(SkWriteBuffer& buf) const {
}
///////////////////////////////////////////////////////////////////////////////
sk_sp<SkShader> SkGaussianEdgeShader::Make() {
return sk_make_sp<SkGaussianEdgeShaderImpl>();
}
///////////////////////////////////////////////////////////////////////////////
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGaussianEdgeShader)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkGaussianEdgeShaderImpl)
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
///////////////////////////////////////////////////////////////////////////////

27
src/effects/SkGaussianEdgeShader.h
View File

@ -1,27 +0,0 @@
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkGaussianEdgeShader_DEFINED
#define SkGaussianEdgeShader_DEFINED
#include "SkShaderBase.h"
class SK_API SkGaussianEdgeShader {
public:
/** Returns a shader that applies a Gaussian blur depending on distance to the edge
* Currently this is only useable with Circle and RRect shapes on the GPU backend.
* Raster will draw nothing.
*/
static sk_sp<SkShader> Make();
SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
private:
SkGaussianEdgeShader(); // can't be instantiated
};
#endif

2
src/ports/SkGlobalInitialization_default.cpp
View File

@ -22,7 +22,6 @@
#include "SkDisplacementMapEffect.h"
#include "SkDropShadowImageFilter.h"
#include "../../src/effects/SkEmbossMaskFilter.h"
#include "../../src/effects/SkGaussianEdgeShader.h"
#include "SkGradientShader.h"
#include "SkHighContrastFilter.h"
#include "SkImageSource.h"
@ -92,7 +91,6 @@ void SkFlattenable::PrivateInitializer::InitEffects() {
SkGradientShader::InitializeFlattenables();
SkLightingShader::InitializeFlattenables();
SkNormalSource::InitializeFlattenables();
SkGaussianEdgeShader::InitializeFlattenables();
// PathEffect
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkArcToPathEffect)