Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
third_party
skia
src
gpu
ganesh
effects
GrCoverageSetOpXP.cpp
Go to the documentation of this file.
1
/*
2
* Copyright 2014 Google Inc.
3
*
4
* Use of this source code is governed by a BSD-style license that can be
5
* found in the LICENSE file.
6
*/
7
8
#include "
src/gpu/ganesh/effects/GrCoverageSetOpXP.h
"
9
10
#include "
include/private/SkColorData.h
"
11
#include "
include/private/base/SkAssert.h
"
12
#include "
src/base/SkRandom.h
"
13
#include "
src/gpu/Blend.h
"
14
#include "
src/gpu/KeyBuilder.h
"
15
#include "
src/gpu/ganesh/GrXferProcessor.h
"
16
#include "
src/gpu/ganesh/glsl/GrGLSLFragmentShaderBuilder.h
"
17
18
#include <memory>
19
20
enum class
GrClampType
;
21
struct
GrShaderCaps
;
22
23
class
CoverageSetOpXP
:
public
GrXferProcessor
{
24
public
:
25
CoverageSetOpXP
(
SkRegion::Op
regionOp,
bool
invertCoverage)
26
:
INHERITED
(
kCoverageSetOpXP_ClassID
)
27
, fRegionOp(regionOp)
28
, fInvertCoverage(invertCoverage) {}
29
30
const
char
*
name
()
const override
{
return
"Coverage Set Op"
; }
31
32
std::unique_ptr<ProgramImpl>
makeProgramImpl
()
const override
;
33
34
private
:
35
void
onAddToKey
(
const
GrShaderCaps
&,
skgpu::KeyBuilder
*)
const override
;
36
37
void
onGetBlendInfo
(
skgpu::BlendInfo
* blendInfo)
const override
;
38
39
bool
onIsEqual
(
const
GrXferProcessor
& xpBase)
const override
{
40
const
CoverageSetOpXP
& xp = xpBase.
cast
<
CoverageSetOpXP
>();
41
return
(fRegionOp == xp.fRegionOp &&
42
fInvertCoverage == xp.fInvertCoverage);
43
}
44
45
SkRegion::Op
fRegionOp;
46
bool
fInvertCoverage;
47
48
using
INHERITED =
GrXferProcessor
;
49
};
50
51
void
CoverageSetOpXP::onAddToKey
(
const
GrShaderCaps
& caps,
skgpu::KeyBuilder
*
b
)
const
{
52
b
->addBool(fInvertCoverage,
"invert coverage"
);
53
}
54
55
std::unique_ptr<GrXferProcessor::ProgramImpl>
CoverageSetOpXP::makeProgramImpl
()
const
{
56
class
Impl :
public
ProgramImpl
{
57
private
:
58
void
emitOutputsForBlendState(
const
EmitArgs&
args
)
override
{
59
const
CoverageSetOpXP
& xp =
args
.fXP.
cast
<
CoverageSetOpXP
>();
60
GrGLSLXPFragmentBuilder
* fb =
args
.fXPFragBuilder;
61
if
(xp.fInvertCoverage) {
62
fb->
codeAppendf
(
"%s = 1.0 - %s;"
,
args
.fOutputPrimary,
args
.fInputCoverage);
63
}
else
{
64
fb->codeAppendf(
"%s = %s;"
,
args
.fOutputPrimary,
args
.fInputCoverage);
65
}
66
}
67
};
68
return
std::make_unique<Impl>();
69
}
70
71
void
CoverageSetOpXP::onGetBlendInfo
(
skgpu::BlendInfo
* blendInfo)
const
{
72
switch
(fRegionOp) {
73
case
SkRegion::kReplace_Op
:
74
blendInfo->
fSrcBlend
=
skgpu::BlendCoeff::kOne
;
75
blendInfo->
fDstBlend
=
skgpu::BlendCoeff::kZero
;
76
break
;
77
case
SkRegion::kIntersect_Op
:
78
blendInfo->
fSrcBlend
=
skgpu::BlendCoeff::kDC
;
79
blendInfo->
fDstBlend
=
skgpu::BlendCoeff::kZero
;
80
break
;
81
case
SkRegion::kUnion_Op
:
82
blendInfo->
fSrcBlend
=
skgpu::BlendCoeff::kOne
;
83
blendInfo->
fDstBlend
=
skgpu::BlendCoeff::kISC
;
84
break
;
85
case
SkRegion::kXOR_Op
:
86
blendInfo->
fSrcBlend
=
skgpu::BlendCoeff::kIDC
;
87
blendInfo->
fDstBlend
=
skgpu::BlendCoeff::kISC
;
88
break
;
89
case
SkRegion::kDifference_Op
:
90
blendInfo->
fSrcBlend
=
skgpu::BlendCoeff::kZero
;
91
blendInfo->
fDstBlend
=
skgpu::BlendCoeff::kISC
;
92
break
;
93
case
SkRegion::kReverseDifference_Op
:
94
blendInfo->
fSrcBlend
=
skgpu::BlendCoeff::kIDC
;
95
blendInfo->
fDstBlend
=
skgpu::BlendCoeff::kZero
;
96
break
;
97
}
98
blendInfo->
fBlendConstant
=
SK_PMColor4fTRANSPARENT
;
99
}
100
101
///////////////////////////////////////////////////////////////////////////////
102
103
constexpr
GrCoverageSetOpXPFactory::GrCoverageSetOpXPFactory(
SkRegion::Op
regionOp,
104
bool
invertCoverage)
105
: fRegionOp(regionOp), fInvertCoverage(invertCoverage) {}
106
107
const
GrXPFactory
*
GrCoverageSetOpXPFactory::Get
(
SkRegion::Op
regionOp,
bool
invertCoverage) {
108
switch
(regionOp) {
109
case
SkRegion::kReplace_Op
: {
110
if
(invertCoverage) {
111
static
constexpr
const
GrCoverageSetOpXPFactory
gReplaceCDXPFI(
112
SkRegion::kReplace_Op
,
true
);
113
return
&gReplaceCDXPFI;
114
}
else
{
115
static
constexpr
const
GrCoverageSetOpXPFactory
gReplaceCDXPF(
SkRegion::kReplace_Op
,
116
false
);
117
return
&gReplaceCDXPF;
118
}
119
}
120
case
SkRegion::kIntersect_Op
: {
121
if
(invertCoverage) {
122
static
constexpr
const
GrCoverageSetOpXPFactory
gIntersectCDXPFI(
123
SkRegion::kIntersect_Op
,
true
);
124
return
&gIntersectCDXPFI;
125
}
else
{
126
static
constexpr
const
GrCoverageSetOpXPFactory
gIntersectCDXPF(
127
SkRegion::kIntersect_Op
,
false
);
128
return
&gIntersectCDXPF;
129
}
130
}
131
case
SkRegion::kUnion_Op
: {
132
if
(invertCoverage) {
133
static
constexpr
const
GrCoverageSetOpXPFactory
gUnionCDXPFI(
SkRegion::kUnion_Op
,
134
true
);
135
return
&gUnionCDXPFI;
136
}
else
{
137
static
constexpr
const
GrCoverageSetOpXPFactory
gUnionCDXPF(
SkRegion::kUnion_Op
,
138
false
);
139
return
&gUnionCDXPF;
140
}
141
}
142
case
SkRegion::kXOR_Op
: {
143
if
(invertCoverage) {
144
static
constexpr
const
GrCoverageSetOpXPFactory
gXORCDXPFI(
SkRegion::kXOR_Op
,
true
);
145
return
&gXORCDXPFI;
146
}
else
{
147
static
constexpr
const
GrCoverageSetOpXPFactory
gXORCDXPF(
SkRegion::kXOR_Op
,
false
);
148
return
&gXORCDXPF;
149
}
150
}
151
case
SkRegion::kDifference_Op
: {
152
if
(invertCoverage) {
153
static
constexpr
const
GrCoverageSetOpXPFactory
gDifferenceCDXPFI(
154
SkRegion::kDifference_Op
,
true
);
155
return
&gDifferenceCDXPFI;
156
}
else
{
157
static
constexpr
const
GrCoverageSetOpXPFactory
gDifferenceCDXPF(
158
SkRegion::kDifference_Op
,
false
);
159
return
&gDifferenceCDXPF;
160
}
161
}
162
case
SkRegion::kReverseDifference_Op
: {
163
if
(invertCoverage) {
164
static
constexpr
const
GrCoverageSetOpXPFactory
gRevDiffCDXPFI(
165
SkRegion::kReverseDifference_Op
,
true
);
166
return
&gRevDiffCDXPFI;
167
}
else
{
168
static
constexpr
const
GrCoverageSetOpXPFactory
gRevDiffCDXPF(
169
SkRegion::kReverseDifference_Op
,
false
);
170
return
&gRevDiffCDXPF;
171
}
172
}
173
}
174
SK_ABORT
(
"Unknown region op."
);
175
}
176
177
sk_sp<const GrXferProcessor>
GrCoverageSetOpXPFactory::makeXferProcessor
(
178
const
GrProcessorAnalysisColor
&,
179
GrProcessorAnalysisCoverage
,
180
const
GrCaps
& caps,
181
GrClampType
)
const
{
182
return
sk_sp<GrXferProcessor>
(
new
CoverageSetOpXP
(fRegionOp, fInvertCoverage));
183
}
184
185
GR_DEFINE_XP_FACTORY_TEST
(
GrCoverageSetOpXPFactory
)
186
187
#if defined(GR_TEST_UTILS)
188
const
GrXPFactory
* GrCoverageSetOpXPFactory::TestGet(GrProcessorTestData*
d
) {
189
SkRegion::Op
regionOp =
SkRegion::Op
(
d
->fRandom->nextULessThan(
SkRegion::kLastOp
+ 1));
190
bool
invertCoverage =
d
->fRandom->nextBool();
191
return
GrCoverageSetOpXPFactory::Get
(regionOp, invertCoverage);
192
}
193
#endif
Blend.h
GrCoverageSetOpXP.h
GrGLSLFragmentShaderBuilder.h
GrProcessorAnalysisCoverage
GrProcessorAnalysisCoverage
Definition
GrProcessorAnalysis.h:89
GR_DEFINE_XP_FACTORY_TEST
#define GR_DEFINE_XP_FACTORY_TEST(...)
Definition
GrProcessorUnitTest.h:187
GrClampType
GrClampType
Definition
GrTypesPriv.h:227
GrXferProcessor.h
KeyBuilder.h
SkAssert.h
SK_ABORT
#define SK_ABORT(message,...)
Definition
SkAssert.h:70
SkColorData.h
SK_PMColor4fTRANSPARENT
constexpr SkPMColor4f SK_PMColor4fTRANSPARENT
Definition
SkColorData.h:378
SkRandom.h
CoverageSetOpXP
Definition
GrCoverageSetOpXP.cpp:23
CoverageSetOpXP::onGetBlendInfo
void onGetBlendInfo(skgpu::BlendInfo *blendInfo) const override
Definition
GrCoverageSetOpXP.cpp:71
CoverageSetOpXP::onAddToKey
void onAddToKey(const GrShaderCaps &, skgpu::KeyBuilder *) const override
Definition
GrCoverageSetOpXP.cpp:51
CoverageSetOpXP::CoverageSetOpXP
CoverageSetOpXP(SkRegion::Op regionOp, bool invertCoverage)
Definition
GrCoverageSetOpXP.cpp:25
CoverageSetOpXP::makeProgramImpl
std::unique_ptr< ProgramImpl > makeProgramImpl() const override
Definition
GrCoverageSetOpXP.cpp:55
CoverageSetOpXP::onIsEqual
bool onIsEqual(const GrXferProcessor &xpBase) const override
Definition
GrCoverageSetOpXP.cpp:39
CoverageSetOpXP::name
const char * name() const override
Definition
GrCoverageSetOpXP.cpp:30
GrCaps
Definition
GrCaps.h:57
GrCoverageSetOpXPFactory
Definition
GrCoverageSetOpXP.h:35
GrCoverageSetOpXPFactory::Get
static const GrXPFactory * Get(SkRegion::Op regionOp, bool invertCoverage=false)
Definition
GrCoverageSetOpXP.cpp:107
GrCoverageSetOpXPFactory::makeXferProcessor
sk_sp< const GrXferProcessor > makeXferProcessor(const GrProcessorAnalysisColor &, GrProcessorAnalysisCoverage, const GrCaps &, GrClampType) const override
Definition
GrCoverageSetOpXP.cpp:177
GrGLSLShaderBuilder::codeAppendf
void codeAppendf(const char format[],...) SK_PRINTF_LIKE(2
GrGLSLXPFragmentBuilder
Definition
GrGLSLFragmentShaderBuilder.h:63
GrProcessorAnalysisColor
Definition
GrProcessorAnalysis.h:19
GrProcessor::cast
const T & cast() const
Definition
GrProcessor.h:127
GrProcessor::kCoverageSetOpXP_ClassID
@ kCoverageSetOpXP_ClassID
Definition
GrProcessor.h:36
GrXPFactory
Definition
GrXferProcessor.h:202
GrXferProcessor::ProgramImpl
Definition
GrXferProcessor.h:282
GrXferProcessor
Definition
GrXferProcessor.h:69
SkRegion::Op
Op
Definition
SkRegion.h:366
SkRegion::kReverseDifference_Op
@ kReverseDifference_Op
operand minus target
Definition
SkRegion.h:371
SkRegion::kUnion_Op
@ kUnion_Op
target unioned with operand
Definition
SkRegion.h:369
SkRegion::kLastOp
@ kLastOp
last operator
Definition
SkRegion.h:373
SkRegion::kReplace_Op
@ kReplace_Op
replace target with operand
Definition
SkRegion.h:372
SkRegion::kIntersect_Op
@ kIntersect_Op
target intersected with operand
Definition
SkRegion.h:368
SkRegion::kDifference_Op
@ kDifference_Op
target minus operand
Definition
SkRegion.h:367
SkRegion::kXOR_Op
@ kXOR_Op
target exclusive or with operand
Definition
SkRegion.h:370
sk_sp
Definition
SkRefCnt.h:220
skgpu::KeyBuilder
Definition
KeyBuilder.h:20
d
VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE auto & d
Definition
main.cc:19
b
static bool b
Definition
ffi_native_test_module.c:74
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition
fl_event_channel.h:89
skgpu::BlendCoeff::kDC
@ kDC
skgpu::BlendCoeff::kIDC
@ kIDC
skgpu::BlendCoeff::kOne
@ kOne
skgpu::BlendCoeff::kZero
@ kZero
skgpu::BlendCoeff::kISC
@ kISC
GrShaderCaps
Definition
GrShaderCaps.h:17
skgpu::BlendInfo
Definition
Blend.h:83
skgpu::BlendInfo::fDstBlend
skgpu::BlendCoeff fDstBlend
Definition
Blend.h:96
skgpu::BlendInfo::fBlendConstant
SkPMColor4f fBlendConstant
Definition
Blend.h:97
skgpu::BlendInfo::fSrcBlend
skgpu::BlendCoeff fSrcBlend
Definition
Blend.h:95
Generated on Fri Apr 26 2024 06:16:58 for Flutter Engine by
1.9.8