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

Revert of Add gpu implementation of OverdrawXfermode (patchset #6 id:100001 of https://codereview.chromium.org/1607253002/ )

Browse Source 
Reason for revert:
Overdraw Xfer mode using new fangled glsl features

Original issue's description:
> Add gpu implementation of OverdrawXfermode
> GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1607253002
>
> Committed: https://skia.googlesource.com/skia/+/8bc3cf88bbf5e5d5724356f076931bb70a6117ba

TBR=egdaniel@google.com
# Not skipping CQ checks because original CL landed more than 1 days ago.

Review URL: https://codereview.chromium.org/1626443002
This commit is contained in:
robertphillips 2016-01-22 06:53:57 -08:00 committed by Commit bot
parent aa97a84404
commit e429c88a81
16 changed files with 91 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
debugger/QT/SkDebuggerGUI.cpp
View File

@ -202,6 +202,7 @@ void SkDebuggerGUI::actionPlay() {
void SkDebuggerGUI::actionRasterSettingsChanged() {
fCanvasWidget.setWidgetVisibility(SkCanvasWidget::kRaster_8888_WidgetType,
!fSettingsWidget.isRasterEnabled());
fDebugger.setOverdrawViz(fSettingsWidget.isOverdrawVizEnabled());
this->updateImage();
}
@ -209,7 +210,6 @@ void SkDebuggerGUI::actionVisualizationsChanged() {
fDebugger.setMegaViz(fSettingsWidget.isMegaVizEnabled());
fDebugger.setPathOps(fSettingsWidget.isPathOpsEnabled());
fDebugger.highlightCurrentCommand(fSettingsWidget.isVisibilityFilterEnabled());
fDebugger.setOverdrawViz(fSettingsWidget.isOverdrawVizEnabled());
this->updateImage();
}

12
debugger/QT/SkSettingsWidget.cpp
View File

@ -21,36 +21,30 @@ SkSettingsWidget::SkSettingsWidget() : QFrame()
// Visualizations toggles.
fVisualizationsGroup.setTitle("Visualizations");
fVisibilityFilterCheckBox.setText("Visibility Filter");
fVisualizationsLayout.addWidget(&fVisibilityFilterCheckBox);
fMegaVizCheckBox.setText("Mega Viz");
fVisualizationsLayout.addWidget(&fMegaVizCheckBox);
fPathOpsCheckBox.setText("PathOps ");
fVisualizationsLayout.addWidget(&fPathOpsCheckBox);
fOverdrawVizCheckBox.setText("Overdraw Viz");
fVisualizationsLayout.addWidget(&fOverdrawVizCheckBox);
fVisualizationsGroup.setLayout(&fVisualizationsLayout);
connect(&fVisibilityFilterCheckBox, SIGNAL(toggled(bool)), this,
SIGNAL(visualizationsChanged()));
connect(&fMegaVizCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(visualizationsChanged()));
connect(&fPathOpsCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(visualizationsChanged()));
connect(&fOverdrawVizCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(visualizationsChanged()));
fVerticalLayout.addRow(&fVisualizationsGroup);
// Raster toggles.
fRasterGroup.setTitle("Raster");
fRasterGroup.setCheckable(true);
fOverdrawVizCheckBox.setText("Overdraw Viz");
fRasterLayout.addWidget(&fOverdrawVizCheckBox);
fRasterGroup.setLayout(&fRasterLayout);
fVerticalLayout.addRow(&fRasterGroup);
connect(&fRasterGroup, SIGNAL(toggled(bool)), this, SIGNAL(rasterSettingsChanged()));
connect(&fOverdrawVizCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(rasterSettingsChanged()));
#if SK_SUPPORT_GPU
fGLGroup.setTitle("OpenGL");

2
gyp/debugger.gyp
View File

@ -101,8 +101,6 @@
'../src/utils/debugger/SkDrawCommand.cpp',
'../src/utils/debugger/SkObjectParser.h',
'../src/utils/debugger/SkObjectParser.cpp',
'../src/utils/debugger/SkOverdrawMode.h',
'../src/utils/debugger/SkOverdrawMode.cpp',
'../debugger/debuggermain.cpp',
'../debugger/QT/SkDebuggerGUI.cpp',
'../debugger/QT/SkDebuggerGUI.h',

2
gyp/dm.gypi
View File

@ -44,8 +44,6 @@
'../src/utils/debugger/SkDebugCanvas.cpp',
'../src/utils/debugger/SkDrawCommand.cpp',
'../src/utils/debugger/SkObjectParser.cpp',
'../src/utils/debugger/SkOverdrawMode.h',
'../src/utils/debugger/SkOverdrawMode.cpp',
],
'conditions': [
[ 'skia_gpu == 1', {

2
gyp/gmslides.gypi
View File

@ -27,8 +27,6 @@
'../src/utils/debugger/SkDebugCanvas.cpp',
'../src/utils/debugger/SkObjectParser.h',
'../src/utils/debugger/SkObjectParser.cpp',
'../src/utils/debugger/SkOverdrawMode.h',
'../src/utils/debugger/SkOverdrawMode.cpp',
],
}],
],

2
gyp/tests.gypi
View File

@ -57,8 +57,6 @@
'../src/utils/debugger/SkDebugCanvas.cpp',
'../src/utils/debugger/SkObjectParser.h',
'../src/utils/debugger/SkObjectParser.cpp',
'../src/utils/debugger/SkOverdrawMode.h',
'../src/utils/debugger/SkOverdrawMode.cpp',
],
'sources!': [
'../tests/SkpSkGrTest.cpp',

8
src/effects/SkArithmeticMode.cpp
View File

@ -21,13 +21,13 @@ static const bool gUseUnpremul = false;
class SkArithmeticMode_scalar : public SkXfermode {
public:
static SkXfermode* Create(SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4,
bool enforcePMColor) {
static SkArithmeticMode_scalar* Create(SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4,
bool enforcePMColor) {
return new SkArithmeticMode_scalar(k1, k2, k3, k4, enforcePMColor);
}
void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
const SkAlpha aa[]) const override;
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
const SkAlpha aa[]) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkArithmeticMode_scalar)

13
src/effects/SkArithmeticMode_gpu.cpp
View File

@ -226,8 +226,17 @@ private:
add_arithmetic_code(fragBuilder, srcColor, dstColor, outColor, kUni, fEnforcePMColor);
// Apply coverage.
INHERITED::DefaultCoverageModulation(fragBuilder, srcCoverage, dstColor, outColor,
outColorSecondary, proc);
if (proc.dstReadUsesMixedSamples()) {
if (srcCoverage) {
fragBuilder->codeAppendf("%s *= %s;", outColor, srcCoverage);
fragBuilder->codeAppendf("%s = %s;", outColorSecondary, srcCoverage);
} else {
fragBuilder->codeAppendf("%s = vec4(1.0);", outColorSecondary);
}
} else if (srcCoverage) {
fragBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
outColor, srcCoverage, outColor, srcCoverage, dstColor);
}
}
void onSetData(const GrGLSLProgramDataManager& pdman,

4
src/gpu/GrProcessor.cpp
View File

@ -48,9 +48,9 @@ GrProcessorTestFactory<GrGeometryProcessor>::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 = 39;
static const int kFPFactoryCount = 38;
static const int kGPFactoryCount = 14;
static const int kXPFactoryCount = 6;
static const int kXPFactoryCount = 5;
template<>
void GrProcessorTestFactory<GrFragmentProcessor>::VerifyFactoryCount() {

13
src/gpu/effects/GrCustomXfermode.cpp
View File

@ -175,8 +175,17 @@ private:
GrGLSLBlend::AppendMode(fragBuilder, srcColor, dstColor, outColor, xp.mode());
// Apply coverage.
INHERITED::DefaultCoverageModulation(fragBuilder, srcCoverage, dstColor, outColor,
outColorSecondary, xp);
if (xp.dstReadUsesMixedSamples()) {
if (srcCoverage) {
fragBuilder->codeAppendf("%s *= %s;", outColor, srcCoverage);
fragBuilder->codeAppendf("%s = %s;", outColorSecondary, srcCoverage);
} else {
fragBuilder->codeAppendf("%s = vec4(1.0);", outColorSecondary);
}
} else if (srcCoverage) {
fragBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
outColor, srcCoverage, outColor, srcCoverage, dstColor);
}
}
void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) override {}

13
src/gpu/effects/GrPorterDuffXferProcessor.cpp
View File

@ -559,8 +559,17 @@ private:
GrGLSLBlend::AppendMode(fragBuilder, srcColor, dstColor, outColor, xp.getXfermode());
// Apply coverage.
INHERITED::DefaultCoverageModulation(fragBuilder, srcCoverage, dstColor, outColor,
outColorSecondary, xp);
if (xp.dstReadUsesMixedSamples()) {
if (srcCoverage) {
fragBuilder->codeAppendf("%s *= %s;", outColor, srcCoverage);
fragBuilder->codeAppendf("%s = %s;", outColorSecondary, srcCoverage);
} else {
fragBuilder->codeAppendf("%s = vec4(1.0);", outColorSecondary);
}
} else if (srcCoverage) {
fragBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
outColor, srcCoverage, outColor, srcCoverage, dstColor);
}
}
void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) override {}

18
src/gpu/glsl/GrGLSLXferProcessor.cpp
View File

@ -88,21 +88,3 @@ void GrGLSLXferProcessor::setData(const GrGLSLProgramDataManager& pdm, const GrX
this->onSetData(pdm, xp);
}
void GrGLSLXferProcessor::DefaultCoverageModulation(GrGLSLXPFragmentBuilder* fragBuilder,
const char* srcCoverage,
const char* dstColor,
const char* outColor,
const char* outColorSecondary,
const GrXferProcessor& proc) {
if (proc.dstReadUsesMixedSamples()) {
if (srcCoverage) {
fragBuilder->codeAppendf("%s *= %s;", outColor, srcCoverage);
fragBuilder->codeAppendf("%s = %s;", outColorSecondary, srcCoverage);
} else {
fragBuilder->codeAppendf("%s = vec4(1.0);", outColorSecondary);
}
} else if (srcCoverage) {
fragBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
outColor, srcCoverage, outColor, srcCoverage, dstColor);
}
}

8
src/gpu/glsl/GrGLSLXferProcessor.h
View File

@ -71,14 +71,6 @@ public:
*/
void setData(const GrGLSLProgramDataManager& pdm, const GrXferProcessor& xp);
protected:
static void DefaultCoverageModulation(GrGLSLXPFragmentBuilder* fragBuilder,
const char* srcCoverage,
const char* dstColor,
const char* outColor,
const char* outColorSecondary,
const GrXferProcessor& proc);
private:
/**
* Called by emitCode() when the XP will not be performing a dst read. This method is

50
src/utils/debugger/SkDebugCanvas.cpp
View File

@ -6,11 +6,55 @@
*/
#include "SkClipStack.h"
#include "SkColorPriv.h"
#include "SkDebugCanvas.h"
#include "SkDrawCommand.h"
#include "SkDevice.h"
#include "SkPaintFilterCanvas.h"
#include "SkOverdrawMode.h"
#include "SkXfermode.h"
namespace {
class OverdrawXfermode : public SkXfermode {
public:
SkPMColor xferColor(SkPMColor src, SkPMColor dst) const override {
// This table encodes the color progression of the overdraw visualization
static const SkPMColor gTable[] = {
SkPackARGB32(0x00, 0x00, 0x00, 0x00),
SkPackARGB32(0xFF, 128, 158, 255),
SkPackARGB32(0xFF, 170, 185, 212),
SkPackARGB32(0xFF, 213, 195, 170),
SkPackARGB32(0xFF, 255, 192, 127),
SkPackARGB32(0xFF, 255, 185, 85),
SkPackARGB32(0xFF, 255, 165, 42),
SkPackARGB32(0xFF, 255, 135, 0),
SkPackARGB32(0xFF, 255, 95, 0),
SkPackARGB32(0xFF, 255, 50, 0),
SkPackARGB32(0xFF, 255, 0, 0)
};
int idx;
if (SkColorGetR(dst) < 64) { // 0
idx = 0;
} else if (SkColorGetG(dst) < 25) { // 10
idx = 9; // cap at 9 for upcoming increment
} else if ((SkColorGetB(dst)+21)/42 > 0) { // 1-6
idx = 7 - (SkColorGetB(dst)+21)/42;
} else { // 7-9
idx = 10 - (SkColorGetG(dst)+22)/45;
}
++idx;
SkASSERT(idx < (int)SK_ARRAY_COUNT(gTable));
return gTable[idx];
}
Factory getFactory() const override { return nullptr; }
#ifndef SK_IGNORE_TO_STRING
void toString(SkString* str) const override { str->set("OverdrawXfermode"); }
#endif
};
class DebugPaintFilterCanvas : public SkPaintFilterCanvas {
public:
@ -20,7 +64,7 @@ public:
bool overrideFilterQuality,
SkFilterQuality quality)
: INHERITED(width, height)
, fOverdrawXfermode(overdrawViz ? SkOverdrawMode::Create() : nullptr)
, fOverdrawXfermode(overdrawViz ? new OverdrawXfermode : nullptr)
, fOverrideFilterQuality(overrideFilterQuality)
, fFilterQuality(quality) {}
@ -55,6 +99,8 @@ private:
typedef SkPaintFilterCanvas INHERITED;
};
}
SkDebugCanvas::SkDebugCanvas(int width, int height)
: INHERITED(width, height)
, fPicture(nullptr)

323
src/utils/debugger/SkOverdrawMode.cpp
View File

@ -1,323 +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 "SkColorPriv.h"
#include "SkOverdrawMode.h"
#include "SkString.h"
#include "SkXfermode.h"
#if SK_SUPPORT_GPU
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
#include "GrXferProcessor.h"
#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLXferProcessor.h"
///////////////////////////////////////////////////////////////////////////////
// Fragment Processor
///////////////////////////////////////////////////////////////////////////////
class GLOverdrawFP;
class GrOverdrawFP : public GrFragmentProcessor {
public:
static const GrFragmentProcessor* Create(const GrFragmentProcessor* dst) {
return new GrOverdrawFP(dst);
}
~GrOverdrawFP() override { }
const char* name() const override { return "Overdraw"; }
SkString dumpInfo() const override {
SkString str;
return str;
}
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder* b) const override;
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
}
GrOverdrawFP(const GrFragmentProcessor* dst) {
this->initClassID<GrOverdrawFP>();
SkASSERT(dst);
SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(dst);
SkASSERT(0 == dstIndex);
}
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrFragmentProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
static void add_overdraw_code(GrGLSLFragmentBuilder* fragBuilder,
const char* dstColor,
const char* outputColor) {
fragBuilder->codeAppend("vec4 gTable[11] = vec4[11](");
fragBuilder->codeAppend("vec4(0, 0, 0, 0.0),");
fragBuilder->codeAppend("vec4(0.5, 0.617, 1.0, 1.0),");
fragBuilder->codeAppend("vec4(0.664, 0.723, 0.83, 1.0),");
fragBuilder->codeAppend("vec4(0.832, 0.762, 0.664, 1.0),");
fragBuilder->codeAppend("vec4(1, 0.75, 0.496, 1.0),");
fragBuilder->codeAppend("vec4(1, 0.723, 0.332, 1.0),");
fragBuilder->codeAppend("vec4(1, 0.645, 0.164, 1.0),");
fragBuilder->codeAppend("vec4(1, 0.527, 0, 1.0),");
fragBuilder->codeAppend("vec4(1, 0.371, 0, 1.0),");
fragBuilder->codeAppend("vec4(1, 0.195, 0, 1.0),");
fragBuilder->codeAppend("vec4(1, 0, 0, 1.0)");
fragBuilder->codeAppend(");");
fragBuilder->codeAppend("int nextIdx;");
fragBuilder->codeAppendf("vec4 dst = %s;", dstColor);
fragBuilder->codeAppend("if (dst.r < 0.25) { nextIdx = 1; }");
// cap 'idx' at 10
fragBuilder->codeAppend("else if (dst.g < 0.0977) { nextIdx = 10; }");
fragBuilder->codeAppend("else if (dst.b > 0.08) { nextIdx = 8 - int(6 * dst.b + 0.5); }");
fragBuilder->codeAppend("else { nextIdx = 11 - int(5.7 * dst.g + 0.5); }");
fragBuilder->codeAppendf("%s = gTable[nextIdx];", outputColor);
}
class GLOverdrawFP : public GrGLSLFragmentProcessor {
public:
GLOverdrawFP(const GrOverdrawFP&) {}
~GLOverdrawFP() override {}
void emitCode(EmitArgs& args) override {
GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
SkString dstColor("dstColor");
this->emitChild(0, nullptr, &dstColor, args);
add_overdraw_code(fragBuilder, dstColor.c_str(), args.fOutputColor);
}
static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) { }
private:
typedef GrGLSLFragmentProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
GrGLSLFragmentProcessor* GrOverdrawFP::onCreateGLSLInstance() const {
return new GLOverdrawFP(*this);
}
void GrOverdrawFP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
GLOverdrawFP::GenKey(*this, caps, b);
}
const GrFragmentProcessor* GrOverdrawFP::TestCreate(GrProcessorTestData* d) {
SkAutoTUnref<const GrFragmentProcessor> dst(GrProcessorUnitTest::CreateChildFP(d));
return new GrOverdrawFP(dst);
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrOverdrawFP);
///////////////////////////////////////////////////////////////////////////////
// Xfer Processor
///////////////////////////////////////////////////////////////////////////////
class OverdrawXP : public GrXferProcessor {
public:
OverdrawXP(const DstTexture* dstTexture, bool hasMixedSamples)
: INHERITED(dstTexture, true, hasMixedSamples) {
this->initClassID<OverdrawXP>();
}
const char* name() const override { return "Overdraw"; }
GrGLSLXferProcessor* createGLSLInstance() const override;
private:
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) const override {
// We never look at the color input
return GrXferProcessor::kIgnoreColor_OptFlag;
}
void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
bool onIsEqual(const GrXferProcessor&) const override { return true; }
typedef GrXferProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
class GLOverdrawXP : public GrGLSLXferProcessor {
public:
GLOverdrawXP(const OverdrawXP&) { }
~GLOverdrawXP() override {}
static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) { }
private:
void emitBlendCodeForDstRead(GrGLSLXPFragmentBuilder* fragBuilder,
GrGLSLUniformHandler* uniformHandler,
const char* srcColor,
const char* srcCoverage,
const char* dstColor,
const char* outColor,
const char* outColorSecondary,
const GrXferProcessor& proc) override {
add_overdraw_code(fragBuilder, dstColor, outColor);
// Apply coverage.
INHERITED::DefaultCoverageModulation(fragBuilder, srcCoverage, dstColor, outColor,
outColorSecondary, proc);
}
void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) override { };
typedef GrGLSLXferProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
void OverdrawXP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
GLOverdrawXP::GenKey(*this, caps, b);
}
GrGLSLXferProcessor* OverdrawXP::createGLSLInstance() const { return new GLOverdrawXP(*this); }
///////////////////////////////////////////////////////////////////////////////
class GrOverdrawXPFactory : public GrXPFactory {
public:
static GrXPFactory* Create() { return new GrOverdrawXPFactory(); }
void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
GrXPFactory::InvariantBlendedColor* blendedColor) const override {
blendedColor->fWillBlendWithDst = true;
blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
}
private:
GrOverdrawXPFactory() {
this->initClassID<GrOverdrawXPFactory>();
}
GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture* dstTexture) const override {
return new OverdrawXP(dstTexture, hasMixedSamples);
}
bool onWillReadDstColor(const GrCaps& caps,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const override {
return true;
}
bool onIsEqual(const GrXPFactory& xpfBase) const override { return true; }
GR_DECLARE_XP_FACTORY_TEST;
typedef GrXPFactory INHERITED;
};
GR_DEFINE_XP_FACTORY_TEST(GrOverdrawXPFactory);
const GrXPFactory* GrOverdrawXPFactory::TestCreate(GrProcessorTestData* d) {
return GrOverdrawXPFactory::Create();
}
#endif
///////////////////////////////////////////////////////////////////////////////
class SkOverdrawXfermode : public SkXfermode {
public:
static SkXfermode* Create() {
return new SkOverdrawXfermode;
}
SkPMColor xferColor(SkPMColor src, SkPMColor dst) const override {
// This table encodes the color progression of the overdraw visualization
static const SkPMColor gTable[] = {
SkPackARGB32(0x00, 0x00, 0x00, 0x00),
SkPackARGB32(0xFF, 128, 158, 255),
SkPackARGB32(0xFF, 170, 185, 212),
SkPackARGB32(0xFF, 213, 195, 170),
SkPackARGB32(0xFF, 255, 192, 127),
SkPackARGB32(0xFF, 255, 185, 85),
SkPackARGB32(0xFF, 255, 165, 42),
SkPackARGB32(0xFF, 255, 135, 0),
SkPackARGB32(0xFF, 255, 95, 0),
SkPackARGB32(0xFF, 255, 50, 0),
SkPackARGB32(0xFF, 255, 0, 0)
};
int nextIdx;
if (SkColorGetR(dst) < 64) { // dst color is the 0th color so the next color is 1
nextIdx = 1;
} else if (SkColorGetG(dst) < 25) { // dst color is the 10th color so cap there
nextIdx = 10;
} else if ((SkColorGetB(dst)+21)/42 > 0) { // dst color is one of 1-6
nextIdx = 8 - (SkColorGetB(dst)+21)/42;
} else { // dst color is between 7 and 9
nextIdx = 11 - (SkColorGetG(dst)+22)/45;
}
SkASSERT(nextIdx < (int)SK_ARRAY_COUNT(gTable));
return gTable[nextIdx];
}
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkOverdrawXfermode)
#if SK_SUPPORT_GPU
bool asFragmentProcessor(const GrFragmentProcessor** output,
const GrFragmentProcessor* dst) const override {
if (output) {
*output = GrOverdrawFP::Create(dst);
}
return true;
}
bool asXPFactory(GrXPFactory** xpf) const override {
if (xpf) {
*xpf = GrOverdrawXPFactory::Create();
}
return true;
}
#endif
#ifndef SK_IGNORE_TO_STRING
void toString(SkString* str) const override { str->set("SkOverdrawXfermode"); }
#endif
private:
friend class SkOverdrawMode;
void flatten(SkWriteBuffer& buffer) const override { }
typedef SkXfermode INHERITED;
};
SkFlattenable* SkOverdrawXfermode::CreateProc(SkReadBuffer& buffer) {
return Create();
}
SkXfermode* SkOverdrawMode::Create() { return new SkOverdrawXfermode; }
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkOverdrawMode)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkOverdrawXfermode)
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END

25
src/utils/debugger/SkOverdrawMode.h
View File

@ -1,25 +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 SkOverdrawMode_DEFINED
#define SkOverdrawMode_DEFINED
#include "SkFlattenable.h"
class SkXfermode;
class SkOverdrawMode {
public:
static SkXfermode* Create();
SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP();
private:
SkOverdrawMode(); // can't be instantiated
};
#endif