blob: 10bc51d56d74276fa5b3d02d44a08c50e70b9bfc [file] [log] [blame]
Robert Phillips4bc70112018-03-01 10:24:02 -05001/*
2 * Copyright 2018 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 "SkTypes.h"
9
Ben Wagnerd90cd3b2018-05-22 10:48:08 -040010#include "GrContext.h"
11#include "GrContextFactory.h"
Robert Phillips4bc70112018-03-01 10:24:02 -050012#include "GrContextPriv.h"
Ben Wagnerd90cd3b2018-05-22 10:48:08 -040013#include "GrDeferredUpload.h"
14#include "GrDrawOpAtlas.h"
15#include "GrDrawingManager.h"
Robert Phillipsc994a932018-06-19 13:09:54 -040016#include "GrMemoryPool.h"
Ben Wagnerd90cd3b2018-05-22 10:48:08 -040017#include "GrOnFlushResourceProvider.h"
18#include "GrOpFlushState.h"
19#include "GrRenderTargetContext.h"
20#include "GrSurfaceProxyPriv.h"
21#include "GrTextureProxy.h"
22#include "GrTypesPriv.h"
23#include "GrXferProcessor.h"
24#include "SkBitmap.h"
25#include "SkColor.h"
26#include "SkColorSpace.h"
27#include "SkIPoint16.h"
28#include "SkImageInfo.h"
29#include "SkMatrix.h"
30#include "SkPaint.h"
31#include "SkPoint.h"
32#include "SkRefCnt.h"
Robert Phillips4bc70112018-03-01 10:24:02 -050033#include "Test.h"
Ben Wagnerd90cd3b2018-05-22 10:48:08 -040034#include "ops/GrDrawOp.h"
35#include "text/GrAtlasManager.h"
Herb Derby26cbe512018-05-24 14:39:01 -040036#include "text/GrTextContext.h"
Herb Derbyc1b482c2018-08-09 15:02:27 -040037#include "text/GrTextTarget.h"
Ben Wagnerd90cd3b2018-05-22 10:48:08 -040038
39#include <memory>
40
41class GrResourceProvider;
Robert Phillips4bc70112018-03-01 10:24:02 -050042
43static const int kNumPlots = 2;
44static const int kPlotSize = 32;
45static const int kAtlasSize = kNumPlots * kPlotSize;
46
47int GrDrawOpAtlas::numAllocated_TestingOnly() const {
48 int count = 0;
49 for (uint32_t i = 0; i < this->maxPages(); ++i) {
Brian Salomonfd98c2c2018-07-31 17:25:29 -040050 if (fProxies[i]->isInstantiated()) {
Robert Phillips4bc70112018-03-01 10:24:02 -050051 ++count;
52 }
53 }
54
55 return count;
56}
57
Kevin Lubickb5502b22018-03-12 10:17:06 -040058void GrAtlasManager::setMaxPages_TestingOnly(uint32_t maxPages) {
Robert Phillipsd2e9f762018-03-07 11:54:37 -050059 for (int i = 0; i < kMaskFormatCount; i++) {
60 if (fAtlases[i]) {
Kevin Lubickb5502b22018-03-12 10:17:06 -040061 fAtlases[i]->setMaxPages_TestingOnly(maxPages);
Robert Phillipsd2e9f762018-03-07 11:54:37 -050062 }
63 }
64}
65
66void GrDrawOpAtlas::setMaxPages_TestingOnly(uint32_t maxPages) {
67 SkASSERT(!fNumActivePages);
68
69 fMaxPages = maxPages;
70}
71
Robert Phillips4bc70112018-03-01 10:24:02 -050072void EvictionFunc(GrDrawOpAtlas::AtlasID atlasID, void*) {
73 SkASSERT(0); // The unit test shouldn't exercise this code path
74}
75
76static void check(skiatest::Reporter* r, GrDrawOpAtlas* atlas,
77 uint32_t expectedActive, uint32_t expectedMax, int expectedAlloced) {
78 REPORTER_ASSERT(r, expectedActive == atlas->numActivePages());
79 REPORTER_ASSERT(r, expectedMax == atlas->maxPages());
80 REPORTER_ASSERT(r, expectedAlloced == atlas->numAllocated_TestingOnly());
81}
82
83class TestingUploadTarget : public GrDeferredUploadTarget {
84public:
85 TestingUploadTarget() { }
86
Robert Phillipsd2e9f762018-03-07 11:54:37 -050087 const GrTokenTracker* tokenTracker() final { return &fTokenTracker; }
88 GrTokenTracker* writeableTokenTracker() { return &fTokenTracker; }
Robert Phillips4bc70112018-03-01 10:24:02 -050089
90 GrDeferredUploadToken addInlineUpload(GrDeferredTextureUploadFn&&) final {
91 SkASSERT(0); // this test shouldn't invoke this code path
92 return fTokenTracker.nextDrawToken();
93 }
94
95 virtual GrDeferredUploadToken addASAPUpload(GrDeferredTextureUploadFn&& upload) final {
96 return fTokenTracker.nextTokenToFlush();
97 }
98
99 void issueDrawToken() { fTokenTracker.issueDrawToken(); }
100 void flushToken() { fTokenTracker.flushToken(); }
101
102private:
103 GrTokenTracker fTokenTracker;
104
105 typedef GrDeferredUploadTarget INHERITED;
106};
107
108static bool fill_plot(GrDrawOpAtlas* atlas,
109 GrResourceProvider* resourceProvider,
110 GrDeferredUploadTarget* target,
111 GrDrawOpAtlas::AtlasID* atlasID,
112 int alpha) {
113 SkImageInfo ii = SkImageInfo::MakeA8(kPlotSize, kPlotSize);
114
115 SkBitmap data;
116 data.allocPixels(ii);
117 data.eraseARGB(alpha, 0, 0, 0);
118
119 SkIPoint16 loc;
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500120 GrDrawOpAtlas::ErrorCode code;
121 code = atlas->addToAtlas(resourceProvider, atlasID, target, kPlotSize, kPlotSize,
122 data.getAddr(0, 0), &loc);
123 return GrDrawOpAtlas::ErrorCode::kSucceeded == code;
Robert Phillips4bc70112018-03-01 10:24:02 -0500124}
125
126
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500127// This is a basic DrawOpAtlas test. It simply verifies that multitexture atlases correctly
128// add and remove pages. Note that this is simulating flush-time behavior.
129DEF_GPUTEST_FOR_RENDERING_CONTEXTS(BasicDrawOpAtlas, reporter, ctxInfo) {
Robert Phillips4bc70112018-03-01 10:24:02 -0500130 auto context = ctxInfo.grContext();
131 auto proxyProvider = context->contextPriv().proxyProvider();
132 auto resourceProvider = context->contextPriv().resourceProvider();
133 auto drawingManager = context->contextPriv().drawingManager();
134
135 GrOnFlushResourceProvider onFlushResourceProvider(drawingManager);
136 TestingUploadTarget uploadTarget;
137
Greg Daniel4065d452018-11-16 15:43:41 -0500138 GrBackendFormat format =
139 context->contextPriv().caps()->getBackendFormatFromColorType(kAlpha_8_SkColorType);
140
Robert Phillips4bc70112018-03-01 10:24:02 -0500141 std::unique_ptr<GrDrawOpAtlas> atlas = GrDrawOpAtlas::Make(
142 proxyProvider,
Greg Daniel4065d452018-11-16 15:43:41 -0500143 format,
Robert Phillips4bc70112018-03-01 10:24:02 -0500144 kAlpha_8_GrPixelConfig,
145 kAtlasSize, kAtlasSize,
146 kNumPlots, kNumPlots,
147 GrDrawOpAtlas::AllowMultitexturing::kYes,
148 EvictionFunc, nullptr);
149 check(reporter, atlas.get(), 0, 4, 0);
150
151 // Fill up the first level
152 GrDrawOpAtlas::AtlasID atlasIDs[kNumPlots * kNumPlots];
153 for (int i = 0; i < kNumPlots * kNumPlots; ++i) {
154 bool result = fill_plot(atlas.get(), resourceProvider, &uploadTarget, &atlasIDs[i], i*32);
155 REPORTER_ASSERT(reporter, result);
156 check(reporter, atlas.get(), 1, 4, 1);
157 }
158
159 atlas->instantiate(&onFlushResourceProvider);
160 check(reporter, atlas.get(), 1, 4, 1);
161
162 // Force allocation of a second level
163 GrDrawOpAtlas::AtlasID atlasID;
164 bool result = fill_plot(atlas.get(), resourceProvider, &uploadTarget, &atlasID, 4*32);
165 REPORTER_ASSERT(reporter, result);
166 check(reporter, atlas.get(), 2, 4, 2);
167
168 // Simulate a lot of draws using only the first plot. The last texture should be compacted.
169 for (int i = 0; i < 512; ++i) {
170 atlas->setLastUseToken(atlasIDs[0], uploadTarget.tokenTracker()->nextDrawToken());
171 uploadTarget.issueDrawToken();
172 uploadTarget.flushToken();
173 atlas->compact(uploadTarget.tokenTracker()->nextTokenToFlush());
174 }
175
176 check(reporter, atlas.get(), 1, 4, 1);
177}
178
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500179// This test verifies that the GrAtlasTextOp::onPrepare method correctly handles a failure
180// when allocating an atlas page.
181DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrAtlasTextOpPreparation, reporter, ctxInfo) {
182
183 auto context = ctxInfo.grContext();
184
185 auto gpu = context->contextPriv().getGpu();
186 auto resourceProvider = context->contextPriv().resourceProvider();
187 auto drawingManager = context->contextPriv().drawingManager();
Herb Derby26cbe512018-05-24 14:39:01 -0400188 auto textContext = drawingManager->getTextContext();
Robert Phillipsc994a932018-06-19 13:09:54 -0400189 auto opMemoryPool = context->contextPriv().opMemoryPool();
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500190
Greg Daniel4065d452018-11-16 15:43:41 -0500191 GrBackendFormat format =
192 context->contextPriv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);
193
194 auto rtc = context->contextPriv().makeDeferredRenderTargetContext(format,
195 SkBackingFit::kApprox,
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500196 32, 32,
197 kRGBA_8888_GrPixelConfig,
198 nullptr);
199
200 SkPaint paint;
201 paint.setColor(SK_ColorRED);
202 paint.setLCDRenderText(false);
203 paint.setAntiAlias(false);
204 paint.setSubpixelText(false);
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500205
206 const char* text = "a";
207
Herb Derbybc6f9c92018-08-08 13:58:45 -0400208 std::unique_ptr<GrDrawOp> op = textContext->createOp_TestingOnly(
209 context, textContext, rtc.get(), paint, SkMatrix::I(), text, 16, 16);
Brian Osman532b3f92018-07-11 10:02:07 -0400210 op->finalize(*context->contextPriv().caps(), nullptr);
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500211
212 TestingUploadTarget uploadTarget;
213
Brian Salomon58f153c2018-10-18 21:51:15 -0400214 GrOpFlushState flushState(gpu, resourceProvider, uploadTarget.writeableTokenTracker(), nullptr,
215 nullptr);
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500216 GrOpFlushState::OpArgs opArgs = {
217 op.get(),
218 rtc->asRenderTargetProxy(),
219 nullptr,
220 GrXferProcessor::DstProxy(nullptr, SkIPoint::Make(0, 0))
221 };
222
223 // Cripple the atlas manager so it can't allocate any pages. This will force a failure
224 // in the preparation of the text op
Robert Phillips5a66efb2018-03-07 15:13:18 -0500225 auto atlasManager = context->contextPriv().getAtlasManager();
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500226 unsigned int numProxies;
227 atlasManager->getProxies(kA8_GrMaskFormat, &numProxies);
228 atlasManager->setMaxPages_TestingOnly(0);
229
230 flushState.setOpArgs(&opArgs);
231 op->prepare(&flushState);
232 flushState.setOpArgs(nullptr);
Robert Phillipsc994a932018-06-19 13:09:54 -0400233 opMemoryPool->release(std::move(op));
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500234}
Herb Derby15d9ef22018-10-18 13:41:32 -0400235
236DEF_GPUTEST(GrDrawOpAtlasConfig_Basic, reporter, options) {
237 REPORTER_ASSERT(reporter, GrDrawOpAtlasConfig::PlotsPerLongDimensionForARGB( 1) == 1);
238 REPORTER_ASSERT(reporter, GrDrawOpAtlasConfig::PlotsPerLongDimensionForARGB( 256) == 1);
239 REPORTER_ASSERT(reporter, GrDrawOpAtlasConfig::PlotsPerLongDimensionForARGB( 512) == 2);
240 REPORTER_ASSERT(reporter, GrDrawOpAtlasConfig::PlotsPerLongDimensionForARGB(1024) == 4);
241 REPORTER_ASSERT(reporter, GrDrawOpAtlasConfig::PlotsPerLongDimensionForARGB(2048) == 8);
242 REPORTER_ASSERT(reporter, GrDrawOpAtlasConfig::PlotsPerLongDimensionForARGB(4096) == 8);
Brian Salomon58f153c2018-10-18 21:51:15 -0400243}