void GrDrawTarget::recordBatch(GrBatch* batch, const SkRect& clippedBounds) {
// A closed drawTarget should never receive new/more batches
SkASSERT(!this->isClosed());
// Check if there is a Batch Draw we can batch with by linearly searching back until we either
// 1) check every draw
// 2) intersect with something
// 3) find a 'blocker'
GR_AUDIT_TRAIL_ADDBATCH(fAuditTrail, batch);
GrBATCH_INFO("Re-Recording (%s, B%u)\n"
"\tBounds LRTB (%f, %f, %f, %f)\n",
batch->name(),
batch->uniqueID(),
batch->bounds().fLeft, batch->bounds().fRight,
batch->bounds().fTop, batch->bounds().fBottom);
GrBATCH_INFO(SkTabString(batch->dumpInfo(), 1).c_str());
GrBATCH_INFO("\tClipped Bounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
clippedBounds.fLeft, clippedBounds.fTop, clippedBounds.fRight,
clippedBounds.fBottom);
GrBATCH_INFO("\tOutcome:\n");
int maxCandidates = SkTMin(fMaxBatchLookback, fRecordedBatches.count());
if (maxCandidates) {
int i = 0;
while (true) {
GrBatch* candidate = fRecordedBatches.fromBack(i).fBatch.get();
// We cannot continue to search backwards if the render target changes
if (candidate->renderTargetUniqueID() != batch->renderTargetUniqueID()) {
GrBATCH_INFO("\t\tBreaking because of (%s, B%u) Rendertarget\n",
candidate->name(), candidate->uniqueID());
break;
}
if (candidate->combineIfPossible(batch, *this->caps())) {
GrBATCH_INFO("\t\tCombining with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
GR_AUDIT_TRAIL_BATCHING_RESULT_COMBINED(fAuditTrail, candidate, batch);
join(&fRecordedBatches.fromBack(i).fClippedBounds,
fRecordedBatches.fromBack(i).fClippedBounds, clippedBounds);
return;
}
// Stop going backwards if we would cause a painter's order violation.
const SkRect& candidateBounds = fRecordedBatches.fromBack(i).fClippedBounds;
if (!can_reorder(candidateBounds, clippedBounds)) {
GrBATCH_INFO("\t\tIntersects with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
break;
}
++i;
if (i == maxCandidates) {
GrBATCH_INFO("\t\tReached max lookback or beginning of batch array %d\n", i);
break;
}
}
} else {
GrBATCH_INFO("\t\tFirstBatch\n");
}
GR_AUDIT_TRAIL_BATCHING_RESULT_NEW(fAuditTrail, batch);
fRecordedBatches.emplace_back(RecordedBatch{sk_ref_sp(batch), clippedBounds});
}
GrTargetCommands::Cmd* GrInOrderCommandBuilder::recordDrawBatch(GrBatch* batch,
const GrCaps& caps) {
GrBATCH_INFO("In-Recording (%s, %u)\n", batch->name(), batch->uniqueID());
if (!this->cmdBuffer()->empty() &&
Cmd::kDrawBatch_CmdType == this->cmdBuffer()->back().type()) {
DrawBatch* previous = static_cast<DrawBatch*>(&this->cmdBuffer()->back());
if (previous->batch()->combineIfPossible(batch, caps)) {
GrBATCH_INFO("\tBatching with (%s, %u)\n",
previous->batch()->name(), previous->batch()->uniqueID());
return nullptr;
}
}
return GrNEW_APPEND_TO_RECORDER(*this->cmdBuffer(), DrawBatch, (batch));
}
GrTargetCommands::Cmd* GrCommandBuilder::recordDiscard(GrRenderTarget* renderTarget) {
SkASSERT(renderTarget);
Clear* clr = GrNEW_APPEND_TO_RECORDER(*this->cmdBuffer(), Clear, (renderTarget));
clr->fColor = GrColor_ILLEGAL;
GrBATCH_INFO("Recording discard %d\n", clr->uniqueID());
return clr;
}
void GrDrawTarget::recordBatch(GrBatch* batch) {
// A closed drawTarget should never receive new/more batches
SkASSERT(!this->isClosed());
// Check if there is a Batch Draw we can batch with by linearly searching back until we either
// 1) check every draw
// 2) intersect with something
// 3) find a 'blocker'
GR_AUDIT_TRAIL_ADDBATCH(fAuditTrail, batch);
GrBATCH_INFO("Re-Recording (%s, B%u)\n"
"\tBounds LRTB (%f, %f, %f, %f)\n",
batch->name(),
batch->uniqueID(),
batch->bounds().fLeft, batch->bounds().fRight,
batch->bounds().fTop, batch->bounds().fBottom);
GrBATCH_INFO(SkTabString(batch->dumpInfo(), 1).c_str());
GrBATCH_INFO("\tOutcome:\n");
int maxCandidates = SkTMin(fMaxBatchLookback, fBatches.count());
if (maxCandidates) {
int i = 0;
while (true) {
GrBatch* candidate = fBatches.fromBack(i);
// We cannot continue to search backwards if the render target changes
if (candidate->renderTargetUniqueID() != batch->renderTargetUniqueID()) {
GrBATCH_INFO("\t\tBreaking because of (%s, B%u) Rendertarget\n",
candidate->name(), candidate->uniqueID());
break;
}
if (candidate->combineIfPossible(batch, *this->caps())) {
GrBATCH_INFO("\t\tCombining with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
GR_AUDIT_TRAIL_BATCHING_RESULT_COMBINED(fAuditTrail, candidate, batch);
return;
}
// Stop going backwards if we would cause a painter's order violation.
// TODO: The bounds used here do not fully consider the clip. It may be advantageous
// to clip each batch's bounds to the clip.
if (intersect(candidate->bounds(), batch->bounds())) {
GrBATCH_INFO("\t\tIntersects with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
break;
}
++i;
if (i == maxCandidates) {
GrBATCH_INFO("\t\tReached max lookback or beginning of batch array %d\n", i);
break;
}
}
} else {
GrBATCH_INFO("\t\tFirstBatch\n");
}
GR_AUDIT_TRAIL_BATCHING_RESULT_NEW(fAuditTrail, batch);
fBatches.push_back().reset(SkRef(batch));
}
void GrDrawTarget::recordBatch(GrBatch* batch) {
// Check if there is a Batch Draw we can batch with by linearly searching back until we either
// 1) check every draw
// 2) intersect with something
// 3) find a 'blocker'
// Experimentally we have found that most batching occurs within the first 10 comparisons.
static const int kMaxLookback = 10;
GrBATCH_INFO("Re-Recording (%s, B%u)\n"
"\tBounds LRTB (%f, %f, %f, %f)\n",
batch->name(),
batch->uniqueID(),
batch->bounds().fLeft, batch->bounds().fRight,
batch->bounds().fTop, batch->bounds().fBottom);
GrBATCH_INFO(SkTabString(batch->dumpInfo(), 1).c_str());
GrBATCH_INFO("\tOutcome:\n");
int maxCandidates = SkTMin(kMaxLookback, fBatches.count());
if (maxCandidates) {
int i = 0;
while (true) {
GrBatch* candidate = fBatches.fromBack(i);
// We cannot continue to search backwards if the render target changes
if (candidate->renderTargetUniqueID() != batch->renderTargetUniqueID()) {
GrBATCH_INFO("\t\tBreaking because of (%s, B%u) Rendertarget\n",
candidate->name(), candidate->uniqueID());
break;
}
if (candidate->combineIfPossible(batch, *this->caps())) {
GrBATCH_INFO("\t\tCombining with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
return;
}
// Stop going backwards if we would cause a painter's order violation.
if (intersect(candidate->bounds(), batch->bounds())) {
GrBATCH_INFO("\t\tIntersects with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
break;
}
++i;
if (i == maxCandidates) {
GrBATCH_INFO("\t\tReached max lookback or beginning of batch array %d\n", i);
break;
}
}
} else {
GrBATCH_INFO("\t\tFirstBatch\n");
}
fBatches.push_back().reset(SkRef(batch));
if (fBatches.count() > kMaxLookback) {
SkASSERT(fBatches.count() - kMaxLookback - fFirstUnpreparedBatch == 1);
fBatches[fFirstUnpreparedBatch++]->prepare(&fFlushState);
}
}
GrTargetCommands::Cmd* GrCommandBuilder::recordCopySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
CopySurface* cs = GrNEW_APPEND_TO_RECORDER(*this->cmdBuffer(), CopySurface, (dst, src));
cs->fSrcRect = srcRect;
cs->fDstPoint = dstPoint;
GrBATCH_INFO("Recording copysurface %d\n", cs->uniqueID());
return cs;
}
void GrDrawTarget::forwardCombine() {
for (int i = 0; i < fRecordedBatches.count() - 2; ++i) {
GrBatch* batch = fRecordedBatches[i].fBatch.get();
const SkRect& batchBounds = fRecordedBatches[i].fClippedBounds;
int maxCandidateIdx = SkTMin(i + fMaxBatchLookahead, fRecordedBatches.count() - 1);
int j = i + 1;
while (true) {
GrBatch* candidate = fRecordedBatches[j].fBatch.get();
// We cannot continue to search if the render target changes
if (candidate->renderTargetUniqueID() != batch->renderTargetUniqueID()) {
GrBATCH_INFO("\t\tBreaking because of (%s, B%u) Rendertarget\n",
candidate->name(), candidate->uniqueID());
break;
}
if (j == i +1) {
// We assume batch would have combined with candidate when the candidate was added
// via backwards combining in recordBatch.
SkASSERT(!batch->combineIfPossible(candidate, *this->caps()));
} else if (batch->combineIfPossible(candidate, *this->caps())) {
GrBATCH_INFO("\t\tCombining with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
GR_AUDIT_TRAIL_BATCHING_RESULT_COMBINED(fAuditTrail, batch, candidate);
fRecordedBatches[j].fBatch = std::move(fRecordedBatches[i].fBatch);
join(&fRecordedBatches[j].fClippedBounds, fRecordedBatches[j].fClippedBounds,
batchBounds);
break;
}
// Stop going traversing if we would cause a painter's order violation.
const SkRect& candidateBounds = fRecordedBatches[j].fClippedBounds;
if (!can_reorder(candidateBounds, batchBounds)) {
GrBATCH_INFO("\t\tIntersects with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
break;
}
++j;
if (j > maxCandidateIdx) {
GrBATCH_INFO("\t\tReached max lookahead or end of batch array %d\n", i);
break;
}
}
}
}
void GrDrawTarget::forwardCombine() {
for (int i = 0; i < fBatches.count() - 2; ++i) {
GrBatch* batch = fBatches[i];
int maxCandidateIdx = SkTMin(i + fMaxBatchLookahead, fBatches.count() - 1);
int j = i + 1;
while (true) {
GrBatch* candidate = fBatches[j];
// We cannot continue to search if the render target changes
if (candidate->renderTargetUniqueID() != batch->renderTargetUniqueID()) {
GrBATCH_INFO("\t\tBreaking because of (%s, B%u) Rendertarget\n",
candidate->name(), candidate->uniqueID());
break;
}
if (j == i +1) {
// We assume batch would have combined with candidate when the candidate was added
// via backwards combining in recordBatch.
SkASSERT(!batch->combineIfPossible(candidate, *this->caps()));
} else if (batch->combineIfPossible(candidate, *this->caps())) {
GrBATCH_INFO("\t\tCombining with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
GR_AUDIT_TRAIL_BATCHING_RESULT_COMBINED(fAuditTrail, batch, candidate);
fBatches[j].reset(SkRef(batch));
fBatches[i].reset(nullptr);
break;
}
// Stop going traversing if we would cause a painter's order violation.
// TODO: The bounds used here do not fully consider the clip. It may be advantageous
// to clip each batch's bounds to the clip.
if (intersect(candidate->bounds(), batch->bounds())) {
GrBATCH_INFO("\t\tIntersects with (%s, B%u)\n", candidate->name(),
candidate->uniqueID());
break;
}
++j;
if (j > maxCandidateIdx) {
GrBATCH_INFO("\t\tReached max lookahead or end of batch array %d\n", i);
break;
}
}
}
}
GrTargetCommands::Cmd* GrCommandBuilder::recordClearStencilClip(const SkIRect& rect,
bool insideClip,
GrRenderTarget* renderTarget) {
SkASSERT(renderTarget);
ClearStencilClip* clr = GrNEW_APPEND_TO_RECORDER(*this->cmdBuffer(),
ClearStencilClip,
(renderTarget));
clr->fRect = rect;
clr->fInsideClip = insideClip;
GrBATCH_INFO("Recording clear stencil clip %d\n", clr->uniqueID());
return clr;
}
GrTargetCommands::Cmd* GrCommandBuilder::recordClear(const SkIRect& rect,
GrColor color,
GrRenderTarget* renderTarget) {
SkASSERT(renderTarget);
SkASSERT(rect.fLeft <= rect.fRight && rect.fTop <= rect.fBottom);
Clear* clr = GrNEW_APPEND_TO_RECORDER(*this->cmdBuffer(), Clear, (renderTarget));
GrColorIsPMAssert(color);
clr->fColor = color;
clr->fRect = rect;
GrBATCH_INFO("Recording clear %d\n", clr->uniqueID());
return clr;
}
GrTargetCommands::Cmd* GrReorderCommandBuilder::recordDrawBatch(State* state, GrBatch* batch) {
// Check if there is a Batch Draw we can batch with by linearly searching back until we either
// 1) check every draw
// 2) intersect with something
// 3) find a 'blocker'
// Experimentally we have found that most batching occurs within the first 10 comparisons.
static const int kMaxLookback = 10;
int i = 0;
batch->setPipeline(state->getPipeline());
GrRenderTarget* rt = state->getPipeline()->getRenderTarget();
GrBATCH_INFO("Re-Recording (%s, B%u)\n"
"\tRenderTarget %p\n"
"\tBounds (%f, %f, %f, %f)\n",
batch->name(),
batch->uniqueID(), rt,
batch->bounds().fLeft, batch->bounds().fRight,
batch->bounds().fTop, batch->bounds().fBottom);
#if GR_BATCH_SPEW
SkDebugf("\tColorStages:\n");
for (int i = 0; i < state->getPipeline()->numColorFragmentStages(); i++) {
SkDebugf("\t\t%s\n", state->getPipeline()->getColorStage(i).processor()->name());
}
SkDebugf("\tCoverageStages:\n");
for (int i = 0; i < state->getPipeline()->numCoverageFragmentStages(); i++) {
SkDebugf("\t\t%s\n", state->getPipeline()->getCoverageStage(i).processor()->name());
}
SkDebugf("\tXP: %s\n", state->getPipeline()->getXferProcessor()->name());
#endif
GrBATCH_INFO("\tOutcome:\n");
if (!this->cmdBuffer()->empty()) {
GrTargetCommands::CmdBuffer::ReverseIter reverseIter(*this->cmdBuffer());
do {
if (Cmd::kDrawBatch_CmdType == reverseIter->type()) {
DrawBatch* previous = static_cast<DrawBatch*>(reverseIter.get());
if (previous->fBatch->pipeline()->getRenderTarget() != rt) {
GrBATCH_INFO("\t\tBreaking because of (%s, B%u) Rendertarget\n",
previous->fBatch->name(), previous->fBatch->uniqueID());
break;
}
// We cannot continue to search backwards if the render target changes
if (previous->fBatch->combineIfPossible(batch)) {
GrBATCH_INFO("\t\tCombining with (%s, B%u)\n",
previous->fBatch->name(), previous->fBatch->uniqueID());
return NULL;
}
if (intersect(previous->fBatch->bounds(), batch->bounds())) {
GrBATCH_INFO("\t\tIntersects with (%s, B%u)\n",
previous->fBatch->name(), previous->fBatch->uniqueID());
break;
}
} else if (Cmd::kClear_CmdType == reverseIter->type()) {
Clear* previous = static_cast<Clear*>(reverseIter.get());
// We cannot continue to search backwards if the render target changes
if (previous->renderTarget() != rt) {
GrBATCH_INFO("\t\tBreaking because of Clear's Rendertarget change\n");
break;
}
// We set the color to illegal if we are doing a discard.
if (previous->fColor == GrColor_ILLEGAL ||
intersect(batch->bounds(), previous->fRect)) {
GrBATCH_INFO("\t\tBreaking because of Clear intersection\n");
break;
}
} else {
GrBATCH_INFO("\t\tBreaking because of other %08x\n", reverseIter->type());
// TODO temporary until we can navigate the other types of commands
break;
}
} while (reverseIter.previous() && ++i < kMaxLookback);
#if GR_BATCH_SPEW
if (!reverseIter.get()) {
GrBATCH_INFO("\t\tNo more commands to try and batch with\n");
} else if (i >= kMaxLookback) {
GrBATCH_INFO("\t\tReached max lookback %d\n", i);
}
#endif
}
#if GR_BATCH_SPEW
else {
GrBATCH_INFO("\t\tBreaking because empty command buffer\n");
}
#endif
return GrNEW_APPEND_TO_RECORDER(*this->cmdBuffer(), DrawBatch, (state, batch,
this->batchTarget()));
}