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

Push full screen clears up to OpList

Browse Source 
Change-Id: Icfc09b3b25f4d3834bee93286e2b24a559f44ed8
Reviewed-on: https://skia-review.googlesource.com/40120
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
This commit is contained in:
Robert Phillips 2017-08-30 07:41:07 -04:00 committed by Skia Commit-Bot
parent fb4a20c7f5
commit 380b90c92b
5 changed files with 38 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/gpu/GrOpList.h
View File

@ -101,8 +101,7 @@ public:
SkDEBUGCODE(virtual int numOps() const = 0;)
SkDEBUGCODE(virtual int numClips() const { return 0; })
void setColorLoadOp(GrLoadOp loadOp) { fColorLoadOp = loadOp; }
void setLoadClearColor(GrColor color) { fLoadClearColor = color; }
// TODO: it would be nice for this to be hidden
void setStencilLoadOp(GrLoadOp loadOp) { fStencilLoadOp = loadOp; }
protected:

17
src/gpu/GrRenderTargetContext.cpp
View File

@ -220,22 +220,7 @@ void GrRenderTargetContext::discard() {
AutoCheckFlush acf(this->drawingManager());
// Discard calls to in-progress opLists are ignored. Calls at the start update the
// opLists' color & stencil load ops.
if (this->getRTOpList()->isEmpty()) {
if (this->caps()->discardRenderTargetSupport()) {
this->getRTOpList()->setColorLoadOp(GrLoadOp::kDiscard);
this->getRTOpList()->setStencilLoadOp(GrLoadOp::kDiscard);
} else {
// skbug.com/6956 (Extra clear confuses Nexus7)
#if 0
// Surely, if a discard was requested, a clear should be acceptable
this->getRTOpList()->setColorLoadOp(GrLoadOp::kClear);
this->getRTOpList()->setLoadClearColor(0x0);
this->getRTOpList()->setStencilLoadOp(GrLoadOp::kClear);
#endif
}
}
this->getRTOpList()->discard();
}
void GrRenderTargetContext::clear(const SkIRect* rect,

52
src/gpu/GrRenderTargetOpList.cpp
View File

@ -133,7 +133,7 @@ static inline void finish_command_buffer(GrGpuRTCommandBuffer* buffer) {
// is at flush time). However, we need to store the RenderTargetProxy in the
// Ops and instantiate them here.
bool GrRenderTargetOpList::onExecute(GrOpFlushState* flushState) {
if (0 == fRecordedOps.count()) {
if (0 == fRecordedOps.count() && GrLoadOp::kClear != fColorLoadOp) {
return false;
}
@ -180,7 +180,6 @@ bool GrRenderTargetOpList::onExecute(GrOpFlushState* flushState) {
}
void GrRenderTargetOpList::reset() {
fLastFullClearOp = nullptr;
fLastClipStackGenID = SK_InvalidUniqueID;
fRecordedOps.reset();
if (fInstancedRendering) {
@ -203,30 +202,35 @@ void GrRenderTargetOpList::freeGpuResources() {
}
}
void GrRenderTargetOpList::discard() {
// Discard calls to in-progress opLists are ignored. Calls at the start update the
// opLists' color & stencil load ops.
if (this->isEmpty()) {
fColorLoadOp = GrLoadOp::kDiscard;
fStencilLoadOp = GrLoadOp::kDiscard;
}
}
void GrRenderTargetOpList::fullClear(const GrCaps& caps, GrColor color) {
// Currently this just inserts or updates the last clear op. However, once in MDB this can
// remove all the previously recorded ops and change the load op to clear with supplied
// color.
if (fLastFullClearOp) {
// As currently implemented, fLastFullClearOp should be the last op because we would
// have cleared it when another op was recorded.
SkASSERT(fRecordedOps.back().fOp.get() == fLastFullClearOp);
GrOP_INFO("opList: %d Fusing clears (opID: %d Color: 0x%08x -> 0x%08x)\n",
this->uniqueID(),
fLastFullClearOp->uniqueID(),
fLastFullClearOp->color(), color);
fLastFullClearOp->setColor(color);
// This is conservative. If the opList is marked as needing a stencil buffer then there
// may be a prior op that writes to the stencil buffer. Although the clear will ignore the
// stencil buffer, following draw ops may not so we can't get rid of all the preceding ops.
// Beware! If we ever add any ops that have a side effect beyond modifying the stencil
// buffer we will need a more elaborate tracking system (skbug.com/7002).
if (this->isEmpty() || !fTarget.get()->asRenderTargetProxy()->needsStencil()) {
fRecordedOps.reset();
fColorLoadOp = GrLoadOp::kClear;
fLoadClearColor = color;
return;
}
std::unique_ptr<GrClearOp> op(GrClearOp::Make(GrFixedClip::Disabled(), color, fTarget.get()));
if (!op) {
return;
}
if (GrOp* clearOp = this->recordOp(std::move(op), caps)) {
// This is either the clear op we just created or another one that it combined with.
fLastFullClearOp = static_cast<GrClearOp*>(clearOp);
}
this->recordOp(std::move(op), caps);
}
////////////////////////////////////////////////////////////////////////////////
@ -277,10 +281,10 @@ bool GrRenderTargetOpList::combineIfPossible(const RecordedOp& a, GrOp* b,
return a.fOp->combineIfPossible(b, caps);
}
GrOp* GrRenderTargetOpList::recordOp(std::unique_ptr<GrOp> op,
const GrCaps& caps,
GrAppliedClip* clip,
const DstProxy* dstProxy) {
void GrRenderTargetOpList::recordOp(std::unique_ptr<GrOp> op,
const GrCaps& caps,
GrAppliedClip* clip,
const DstProxy* dstProxy) {
SkASSERT(fTarget.get());
// A closed GrOpList should never receive new/more ops
@ -313,7 +317,7 @@ GrOp* GrRenderTargetOpList::recordOp(std::unique_ptr<GrOp> op,
GrOP_INFO("\t\t\tBackward: Combined op info:\n");
GrOP_INFO(SkTabString(candidate.fOp->dumpInfo(), 4).c_str());
GR_AUDIT_TRAIL_OPS_RESULT_COMBINED(fAuditTrail, candidate.fOp.get(), op.get());
return candidate.fOp.get();
return;
}
// Stop going backwards if we would cause a painter's order violation.
if (!can_reorder(fRecordedOps.fromBack(i).fOp->bounds(), op->bounds())) {
@ -337,8 +341,6 @@ GrOp* GrRenderTargetOpList::recordOp(std::unique_ptr<GrOp> op,
}
fRecordedOps.emplace_back(std::move(op), clip, dstProxy);
fRecordedOps.back().fOp->wasRecorded(this);
fLastFullClearOp = nullptr;
return fRecordedOps.back().fOp.get();
}
void GrRenderTargetOpList::forwardCombine(const GrCaps& caps) {

11
src/gpu/GrRenderTargetOpList.h
View File

@ -45,7 +45,6 @@ public:
return;
}
fLastFullClearOp = nullptr;
this->forwardCombine(caps);
INHERITED::makeClosed(caps);
@ -78,6 +77,8 @@ public:
return this->uniqueID();
}
void discard();
/** Clears the entire render target */
void fullClear(const GrCaps& caps, GrColor color);
@ -124,10 +125,8 @@ private:
GrAppliedClip* fAppliedClip;
};
// If the input op is combined with an earlier op, this returns the combined op. Otherwise, it
// returns the input op.
GrOp* recordOp(std::unique_ptr<GrOp>, const GrCaps& caps,
GrAppliedClip* = nullptr, const DstProxy* = nullptr);
void recordOp(std::unique_ptr<GrOp>, const GrCaps& caps,
GrAppliedClip* = nullptr, const DstProxy* = nullptr);
void forwardCombine(const GrCaps&);
@ -135,8 +134,6 @@ private:
bool combineIfPossible(const RecordedOp& a, GrOp* b, const GrAppliedClip* bClip,
const DstProxy* bDstTexture, const GrCaps&);
GrClearOp* fLastFullClearOp = nullptr;
std::unique_ptr<gr_instanced::InstancedRendering> fInstancedRendering;
uint32_t fLastClipStackGenID;

6
src/gpu/vk/GrVkGpuCommandBuffer.cpp
View File

@ -116,7 +116,11 @@ void GrVkGpuRTCommandBuffer::init() {
cbInfo.fColorClearValue.color.float32[2] = fClearColor.fRGBA[2];
cbInfo.fColorClearValue.color.float32[3] = fClearColor.fRGBA[3];
cbInfo.fBounds.setEmpty();
if (VK_ATTACHMENT_LOAD_OP_CLEAR == fVkColorLoadOp) {
cbInfo.fBounds = SkRect::MakeWH(vkRT->width(), vkRT->height());
} else {
cbInfo.fBounds.setEmpty();
}
cbInfo.fIsEmpty = true;
cbInfo.fStartsWithClear = false;