1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrClearOp_DEFINED
#define GrClearOp_DEFINED
#include "GrFixedClip.h"
#include "GrGpuCommandBuffer.h"
#include "GrOp.h"
#include "GrOpFlushState.h"
#include "GrResourceProvider.h"
class GrClearOp final : public GrOp {
public:
DEFINE_OP_CLASS_ID
static std::unique_ptr<GrClearOp> Make(const GrFixedClip& clip, GrColor color,
GrSurfaceProxy* dstProxy) {
const SkIRect rect = SkIRect::MakeWH(dstProxy->width(), dstProxy->height());
if (clip.scissorEnabled() && !SkIRect::Intersects(clip.scissorRect(), rect)) {
return nullptr;
}
return std::unique_ptr<GrClearOp>(new GrClearOp(clip, color, dstProxy));
}
static std::unique_ptr<GrClearOp> Make(const SkIRect& rect, GrColor color,
bool fullScreen) {
SkASSERT(fullScreen || !rect.isEmpty());
return std::unique_ptr<GrClearOp>(new GrClearOp(rect, color, fullScreen));
}
const char* name() const override { return "Clear"; }
SkString dumpInfo() const override {
SkString string;
string.append(INHERITED::dumpInfo());
string.appendf("Scissor [ ");
if (fClip.scissorEnabled()) {
const SkIRect& r = fClip.scissorRect();
string.appendf("L: %d, T: %d, R: %d, B: %d", r.fLeft, r.fTop, r.fRight, r.fBottom);
} else {
string.append("disabled");
}
string.appendf("], Color: 0x%08x\n", fColor);
return string;
}
GrColor color() const { return fColor; }
void setColor(GrColor color) { fColor = color; }
private:
GrClearOp(const GrFixedClip& clip, GrColor color, GrSurfaceProxy* proxy)
: INHERITED(ClassID())
, fClip(clip)
, fColor(color) {
const SkIRect rtRect = SkIRect::MakeWH(proxy->width(), proxy->height());
if (fClip.scissorEnabled()) {
// Don't let scissors extend outside the RT. This may improve op combining.
if (!fClip.intersect(rtRect)) {
SkASSERT(0); // should be caught upstream
fClip = GrFixedClip(SkIRect::MakeEmpty());
}
if (GrResourceProvider::IsFunctionallyExact(proxy) && fClip.scissorRect() == rtRect) {
fClip.disableScissor();
}
}
this->setBounds(SkRect::Make(fClip.scissorEnabled() ? fClip.scissorRect() : rtRect),
HasAABloat::kNo, IsZeroArea::kNo);
}
GrClearOp(const SkIRect& rect, GrColor color, bool fullScreen)
: INHERITED(ClassID())
, fClip(GrFixedClip(rect))
, fColor(color) {
if (fullScreen) {
fClip.disableScissor();
}
this->setBounds(SkRect::Make(rect), HasAABloat::kNo, IsZeroArea::kNo);
}
bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
// This could be much more complicated. Currently we look at cases where the new clear
// contains the old clear, or when the new clear is a subset of the old clear and is the
// same color.
GrClearOp* cb = t->cast<GrClearOp>();
if (fClip.windowRectsState() != cb->fClip.windowRectsState()) {
return false;
}
if (cb->contains(this)) {
fClip = cb->fClip;
this->replaceBounds(*t);
fColor = cb->fColor;
return true;
} else if (cb->fColor == fColor && this->contains(cb)) {
return true;
}
return false;
}
bool contains(const GrClearOp* that) const {
// The constructor ensures that scissor gets disabled on any clip that fills the entire RT.
return !fClip.scissorEnabled() ||
(that->fClip.scissorEnabled() &&
fClip.scissorRect().contains(that->fClip.scissorRect()));
}
void onPrepare(GrOpFlushState*) override {}
void onExecute(GrOpFlushState* state) override {
SkASSERT(state->drawOpArgs().fRenderTarget);
state->commandBuffer()->clear(state->drawOpArgs().fRenderTarget, fClip, fColor);
}
GrFixedClip fClip;
GrColor fColor;
typedef GrOp INHERITED;
};
#endif
|
