Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 1 | /* |
| 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 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "include/core/SkBitmap.h" |
| 9 | #include "include/core/SkColor.h" |
| 10 | #include "include/core/SkColorSpace.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 11 | #include "include/core/SkFont.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 12 | #include "include/core/SkImageInfo.h" |
| 13 | #include "include/core/SkMatrix.h" |
| 14 | #include "include/core/SkPaint.h" |
| 15 | #include "include/core/SkPoint.h" |
| 16 | #include "include/core/SkRefCnt.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 17 | #include "include/core/SkSize.h" |
| 18 | #include "include/core/SkTypes.h" |
| 19 | #include "include/gpu/GrBackendSurface.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 20 | #include "include/gpu/GrContext.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 21 | #include "include/private/GrTypesPriv.h" |
| 22 | #include "src/core/SkIPoint16.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 23 | #include "src/gpu/GrCaps.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 24 | #include "src/gpu/GrContextPriv.h" |
| 25 | #include "src/gpu/GrDeferredUpload.h" |
| 26 | #include "src/gpu/GrDrawOpAtlas.h" |
| 27 | #include "src/gpu/GrDrawingManager.h" |
| 28 | #include "src/gpu/GrMemoryPool.h" |
| 29 | #include "src/gpu/GrOnFlushResourceProvider.h" |
| 30 | #include "src/gpu/GrOpFlushState.h" |
| 31 | #include "src/gpu/GrRenderTargetContext.h" |
Greg Daniel | f91aeb2 | 2019-06-18 09:58:02 -0400 | [diff] [blame] | 32 | #include "src/gpu/GrTextureProxy.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 33 | #include "src/gpu/GrXferProcessor.h" |
| 34 | #include "src/gpu/ops/GrDrawOp.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 35 | #include "src/gpu/ops/GrOp.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 36 | #include "src/gpu/text/GrAtlasManager.h" |
| 37 | #include "src/gpu/text/GrTextContext.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 38 | #include "tests/Test.h" |
| 39 | #include "tools/gpu/GrContextFactory.h" |
Ben Wagner | d90cd3b | 2018-05-22 10:48:08 -0400 | [diff] [blame] | 40 | |
| 41 | #include <memory> |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 42 | #include <utility> |
Ben Wagner | d90cd3b | 2018-05-22 10:48:08 -0400 | [diff] [blame] | 43 | |
| 44 | class GrResourceProvider; |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 45 | |
| 46 | static const int kNumPlots = 2; |
| 47 | static const int kPlotSize = 32; |
| 48 | static const int kAtlasSize = kNumPlots * kPlotSize; |
| 49 | |
| 50 | int GrDrawOpAtlas::numAllocated_TestingOnly() const { |
| 51 | int count = 0; |
| 52 | for (uint32_t i = 0; i < this->maxPages(); ++i) { |
Greg Daniel | 9715b6c | 2019-12-10 15:03:10 -0500 | [diff] [blame] | 53 | if (fViews[i].proxy()->isInstantiated()) { |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 54 | ++count; |
| 55 | } |
| 56 | } |
| 57 | |
| 58 | return count; |
| 59 | } |
| 60 | |
Kevin Lubick | b5502b2 | 2018-03-12 10:17:06 -0400 | [diff] [blame] | 61 | void GrAtlasManager::setMaxPages_TestingOnly(uint32_t maxPages) { |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 62 | for (int i = 0; i < kMaskFormatCount; i++) { |
| 63 | if (fAtlases[i]) { |
Kevin Lubick | b5502b2 | 2018-03-12 10:17:06 -0400 | [diff] [blame] | 64 | fAtlases[i]->setMaxPages_TestingOnly(maxPages); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 65 | } |
| 66 | } |
| 67 | } |
| 68 | |
| 69 | void GrDrawOpAtlas::setMaxPages_TestingOnly(uint32_t maxPages) { |
| 70 | SkASSERT(!fNumActivePages); |
| 71 | |
| 72 | fMaxPages = maxPages; |
| 73 | } |
| 74 | |
Herb Derby | 1a496c5 | 2020-01-22 17:26:56 -0500 | [diff] [blame] | 75 | class DummyEvict : public GrDrawOpAtlas::EvictionCallback { |
| 76 | public: |
| 77 | void evict(GrDrawOpAtlas::AtlasID id) override { |
| 78 | SkASSERT(0); // The unit test shouldn't exercise this code path |
| 79 | } |
| 80 | }; |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 81 | |
| 82 | static void check(skiatest::Reporter* r, GrDrawOpAtlas* atlas, |
| 83 | uint32_t expectedActive, uint32_t expectedMax, int expectedAlloced) { |
| 84 | REPORTER_ASSERT(r, expectedActive == atlas->numActivePages()); |
| 85 | REPORTER_ASSERT(r, expectedMax == atlas->maxPages()); |
| 86 | REPORTER_ASSERT(r, expectedAlloced == atlas->numAllocated_TestingOnly()); |
| 87 | } |
| 88 | |
| 89 | class TestingUploadTarget : public GrDeferredUploadTarget { |
| 90 | public: |
| 91 | TestingUploadTarget() { } |
| 92 | |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 93 | const GrTokenTracker* tokenTracker() final { return &fTokenTracker; } |
| 94 | GrTokenTracker* writeableTokenTracker() { return &fTokenTracker; } |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 95 | |
| 96 | GrDeferredUploadToken addInlineUpload(GrDeferredTextureUploadFn&&) final { |
| 97 | SkASSERT(0); // this test shouldn't invoke this code path |
| 98 | return fTokenTracker.nextDrawToken(); |
| 99 | } |
| 100 | |
| 101 | virtual GrDeferredUploadToken addASAPUpload(GrDeferredTextureUploadFn&& upload) final { |
| 102 | return fTokenTracker.nextTokenToFlush(); |
| 103 | } |
| 104 | |
| 105 | void issueDrawToken() { fTokenTracker.issueDrawToken(); } |
| 106 | void flushToken() { fTokenTracker.flushToken(); } |
| 107 | |
| 108 | private: |
| 109 | GrTokenTracker fTokenTracker; |
| 110 | |
| 111 | typedef GrDeferredUploadTarget INHERITED; |
| 112 | }; |
| 113 | |
| 114 | static bool fill_plot(GrDrawOpAtlas* atlas, |
| 115 | GrResourceProvider* resourceProvider, |
| 116 | GrDeferredUploadTarget* target, |
| 117 | GrDrawOpAtlas::AtlasID* atlasID, |
| 118 | int alpha) { |
| 119 | SkImageInfo ii = SkImageInfo::MakeA8(kPlotSize, kPlotSize); |
| 120 | |
| 121 | SkBitmap data; |
| 122 | data.allocPixels(ii); |
| 123 | data.eraseARGB(alpha, 0, 0, 0); |
| 124 | |
| 125 | SkIPoint16 loc; |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 126 | GrDrawOpAtlas::ErrorCode code; |
| 127 | code = atlas->addToAtlas(resourceProvider, atlasID, target, kPlotSize, kPlotSize, |
| 128 | data.getAddr(0, 0), &loc); |
| 129 | return GrDrawOpAtlas::ErrorCode::kSucceeded == code; |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 130 | } |
| 131 | |
| 132 | |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 133 | // This is a basic DrawOpAtlas test. It simply verifies that multitexture atlases correctly |
| 134 | // add and remove pages. Note that this is simulating flush-time behavior. |
| 135 | DEF_GPUTEST_FOR_RENDERING_CONTEXTS(BasicDrawOpAtlas, reporter, ctxInfo) { |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 136 | auto context = ctxInfo.grContext(); |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 137 | auto proxyProvider = context->priv().proxyProvider(); |
| 138 | auto resourceProvider = context->priv().resourceProvider(); |
| 139 | auto drawingManager = context->priv().drawingManager(); |
Robert Phillips | 0a15cc6 | 2019-07-30 12:49:10 -0400 | [diff] [blame] | 140 | const GrCaps* caps = context->priv().caps(); |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 141 | |
| 142 | GrOnFlushResourceProvider onFlushResourceProvider(drawingManager); |
| 143 | TestingUploadTarget uploadTarget; |
| 144 | |
Robert Phillips | 0a15cc6 | 2019-07-30 12:49:10 -0400 | [diff] [blame] | 145 | GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kAlpha_8, |
| 146 | GrRenderable::kNo); |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 147 | |
Herb Derby | 1a496c5 | 2020-01-22 17:26:56 -0500 | [diff] [blame] | 148 | DummyEvict evictor; |
| 149 | |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 150 | std::unique_ptr<GrDrawOpAtlas> atlas = GrDrawOpAtlas::Make( |
| 151 | proxyProvider, |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 152 | format, |
Robert Phillips | 42dda08 | 2019-05-14 13:29:45 -0400 | [diff] [blame] | 153 | GrColorType::kAlpha_8, |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 154 | kAtlasSize, kAtlasSize, |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 155 | kAtlasSize/kNumPlots, kAtlasSize/kNumPlots, |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 156 | GrDrawOpAtlas::AllowMultitexturing::kYes, |
Herb Derby | 1a496c5 | 2020-01-22 17:26:56 -0500 | [diff] [blame] | 157 | &evictor); |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 158 | check(reporter, atlas.get(), 0, 4, 0); |
| 159 | |
| 160 | // Fill up the first level |
| 161 | GrDrawOpAtlas::AtlasID atlasIDs[kNumPlots * kNumPlots]; |
| 162 | for (int i = 0; i < kNumPlots * kNumPlots; ++i) { |
| 163 | bool result = fill_plot(atlas.get(), resourceProvider, &uploadTarget, &atlasIDs[i], i*32); |
| 164 | REPORTER_ASSERT(reporter, result); |
| 165 | check(reporter, atlas.get(), 1, 4, 1); |
| 166 | } |
| 167 | |
| 168 | atlas->instantiate(&onFlushResourceProvider); |
| 169 | check(reporter, atlas.get(), 1, 4, 1); |
| 170 | |
| 171 | // Force allocation of a second level |
| 172 | GrDrawOpAtlas::AtlasID atlasID; |
| 173 | bool result = fill_plot(atlas.get(), resourceProvider, &uploadTarget, &atlasID, 4*32); |
| 174 | REPORTER_ASSERT(reporter, result); |
| 175 | check(reporter, atlas.get(), 2, 4, 2); |
| 176 | |
| 177 | // Simulate a lot of draws using only the first plot. The last texture should be compacted. |
| 178 | for (int i = 0; i < 512; ++i) { |
| 179 | atlas->setLastUseToken(atlasIDs[0], uploadTarget.tokenTracker()->nextDrawToken()); |
| 180 | uploadTarget.issueDrawToken(); |
| 181 | uploadTarget.flushToken(); |
| 182 | atlas->compact(uploadTarget.tokenTracker()->nextTokenToFlush()); |
| 183 | } |
| 184 | |
| 185 | check(reporter, atlas.get(), 1, 4, 1); |
| 186 | } |
| 187 | |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 188 | // This test verifies that the GrAtlasTextOp::onPrepare method correctly handles a failure |
| 189 | // when allocating an atlas page. |
| 190 | DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrAtlasTextOpPreparation, reporter, ctxInfo) { |
| 191 | |
| 192 | auto context = ctxInfo.grContext(); |
| 193 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 194 | auto gpu = context->priv().getGpu(); |
| 195 | auto resourceProvider = context->priv().resourceProvider(); |
| 196 | auto drawingManager = context->priv().drawingManager(); |
Herb Derby | 26cbe51 | 2018-05-24 14:39:01 -0400 | [diff] [blame] | 197 | auto textContext = drawingManager->getTextContext(); |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 198 | auto opMemoryPool = context->priv().opMemoryPool(); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 199 | |
Greg Daniel | e20fcad | 2020-01-08 11:52:34 -0500 | [diff] [blame] | 200 | auto rtc = GrRenderTargetContext::Make( |
| 201 | context, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kApprox, {32, 32}); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 202 | |
| 203 | SkPaint paint; |
| 204 | paint.setColor(SK_ColorRED); |
Mike Reed | 191e64b | 2019-01-02 15:35:29 -0500 | [diff] [blame] | 205 | |
| 206 | SkFont font; |
| 207 | font.setEdging(SkFont::Edging::kAlias); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 208 | |
| 209 | const char* text = "a"; |
| 210 | |
Herb Derby | bc6f9c9 | 2018-08-08 13:58:45 -0400 | [diff] [blame] | 211 | std::unique_ptr<GrDrawOp> op = textContext->createOp_TestingOnly( |
Mike Reed | 191e64b | 2019-01-02 15:35:29 -0500 | [diff] [blame] | 212 | context, textContext, rtc.get(), paint, font, SkMatrix::I(), text, 16, 16); |
Chris Dalton | 6ce447a | 2019-06-23 18:07:38 -0600 | [diff] [blame] | 213 | bool hasMixedSampledCoverage = false; |
| 214 | op->finalize(*context->priv().caps(), nullptr, hasMixedSampledCoverage, GrClampType::kAuto); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 215 | |
| 216 | TestingUploadTarget uploadTarget; |
| 217 | |
Robert Phillips | e5f7328 | 2019-06-18 17:15:04 -0400 | [diff] [blame] | 218 | GrOpFlushState flushState(gpu, resourceProvider, uploadTarget.writeableTokenTracker()); |
Greg Daniel | 16f5c65 | 2019-10-29 11:26:01 -0400 | [diff] [blame] | 219 | |
| 220 | GrSurfaceProxyView surfaceView = rtc->outputSurfaceView(); |
Robert Phillips | 901aff0 | 2019-10-08 12:32:56 -0400 | [diff] [blame] | 221 | GrOpFlushState::OpArgs opArgs(op.get(), |
Greg Daniel | 16f5c65 | 2019-10-29 11:26:01 -0400 | [diff] [blame] | 222 | &surfaceView, |
Robert Phillips | 901aff0 | 2019-10-08 12:32:56 -0400 | [diff] [blame] | 223 | nullptr, |
Greg Daniel | 524e28b | 2019-11-01 11:48:53 -0400 | [diff] [blame] | 224 | GrXferProcessor::DstProxyView(GrSurfaceProxyView(), |
| 225 | SkIPoint::Make(0, 0))); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 226 | |
| 227 | // Cripple the atlas manager so it can't allocate any pages. This will force a failure |
| 228 | // in the preparation of the text op |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 229 | auto atlasManager = context->priv().getAtlasManager(); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 230 | unsigned int numProxies; |
Greg Daniel | 9715b6c | 2019-12-10 15:03:10 -0500 | [diff] [blame] | 231 | atlasManager->getViews(kA8_GrMaskFormat, &numProxies); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 232 | atlasManager->setMaxPages_TestingOnly(0); |
| 233 | |
| 234 | flushState.setOpArgs(&opArgs); |
| 235 | op->prepare(&flushState); |
| 236 | flushState.setOpArgs(nullptr); |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 237 | opMemoryPool->release(std::move(op)); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 238 | } |
Herb Derby | 15d9ef2 | 2018-10-18 13:41:32 -0400 | [diff] [blame] | 239 | |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 240 | void test_atlas_config(skiatest::Reporter* reporter, int maxTextureSize, size_t maxBytes, |
| 241 | GrMaskFormat maskFormat, SkISize expectedDimensions, |
| 242 | SkISize expectedPlotDimensions) { |
| 243 | GrDrawOpAtlasConfig config(maxTextureSize, maxBytes); |
| 244 | REPORTER_ASSERT(reporter, config.atlasDimensions(maskFormat) == expectedDimensions); |
| 245 | REPORTER_ASSERT(reporter, config.plotDimensions(maskFormat) == expectedPlotDimensions); |
| 246 | } |
| 247 | |
Herb Derby | 15d9ef2 | 2018-10-18 13:41:32 -0400 | [diff] [blame] | 248 | DEF_GPUTEST(GrDrawOpAtlasConfig_Basic, reporter, options) { |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 249 | // 1/4 MB |
| 250 | test_atlas_config(reporter, 65536, 256 * 1024, kARGB_GrMaskFormat, |
| 251 | { 256, 256 }, { 256, 256 }); |
| 252 | test_atlas_config(reporter, 65536, 256 * 1024, kA8_GrMaskFormat, |
| 253 | { 512, 512 }, { 256, 256 }); |
| 254 | // 1/2 MB |
| 255 | test_atlas_config(reporter, 65536, 512 * 1024, kARGB_GrMaskFormat, |
| 256 | { 512, 256 }, { 256, 256 }); |
| 257 | test_atlas_config(reporter, 65536, 512 * 1024, kA8_GrMaskFormat, |
| 258 | { 1024, 512 }, { 256, 256 }); |
| 259 | // 1 MB |
| 260 | test_atlas_config(reporter, 65536, 1024 * 1024, kARGB_GrMaskFormat, |
| 261 | { 512, 512 }, { 256, 256 }); |
| 262 | test_atlas_config(reporter, 65536, 1024 * 1024, kA8_GrMaskFormat, |
| 263 | { 1024, 1024 }, { 256, 256 }); |
| 264 | // 2 MB |
| 265 | test_atlas_config(reporter, 65536, 2 * 1024 * 1024, kARGB_GrMaskFormat, |
| 266 | { 1024, 512 }, { 256, 256 }); |
| 267 | test_atlas_config(reporter, 65536, 2 * 1024 * 1024, kA8_GrMaskFormat, |
| 268 | { 2048, 1024 }, { 512, 256 }); |
| 269 | // 4 MB |
| 270 | test_atlas_config(reporter, 65536, 4 * 1024 * 1024, kARGB_GrMaskFormat, |
| 271 | { 1024, 1024 }, { 256, 256 }); |
| 272 | test_atlas_config(reporter, 65536, 4 * 1024 * 1024, kA8_GrMaskFormat, |
Jim Van Verth | 578b089 | 2018-12-20 20:48:55 +0000 | [diff] [blame] | 273 | { 2048, 2048 }, { 512, 512 }); |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 274 | // 8 MB |
| 275 | test_atlas_config(reporter, 65536, 8 * 1024 * 1024, kARGB_GrMaskFormat, |
| 276 | { 2048, 1024 }, { 256, 256 }); |
| 277 | test_atlas_config(reporter, 65536, 8 * 1024 * 1024, kA8_GrMaskFormat, |
Jim Van Verth | 578b089 | 2018-12-20 20:48:55 +0000 | [diff] [blame] | 278 | { 2048, 2048 }, { 512, 512 }); |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 279 | // 16 MB (should be same as 8 MB) |
| 280 | test_atlas_config(reporter, 65536, 16 * 1024 * 1024, kARGB_GrMaskFormat, |
| 281 | { 2048, 1024 }, { 256, 256 }); |
| 282 | test_atlas_config(reporter, 65536, 16 * 1024 * 1024, kA8_GrMaskFormat, |
Jim Van Verth | 578b089 | 2018-12-20 20:48:55 +0000 | [diff] [blame] | 283 | { 2048, 2048 }, { 512, 512 }); |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 284 | |
| 285 | // 4MB, restricted texture size |
| 286 | test_atlas_config(reporter, 1024, 8 * 1024 * 1024, kARGB_GrMaskFormat, |
| 287 | { 1024, 1024 }, { 256, 256 }); |
| 288 | test_atlas_config(reporter, 1024, 8 * 1024 * 1024, kA8_GrMaskFormat, |
| 289 | { 1024, 1024 }, { 256, 256 }); |
| 290 | |
| 291 | // 3 MB (should be same as 2 MB) |
| 292 | test_atlas_config(reporter, 65536, 3 * 1024 * 1024, kARGB_GrMaskFormat, |
| 293 | { 1024, 512 }, { 256, 256 }); |
| 294 | test_atlas_config(reporter, 65536, 3 * 1024 * 1024, kA8_GrMaskFormat, |
| 295 | { 2048, 1024 }, { 512, 256 }); |
| 296 | |
| 297 | // minimum size |
| 298 | test_atlas_config(reporter, 65536, 0, kARGB_GrMaskFormat, |
| 299 | { 256, 256 }, { 256, 256 }); |
| 300 | test_atlas_config(reporter, 65536, 0, kA8_GrMaskFormat, |
| 301 | { 512, 512 }, { 256, 256 }); |
Brian Salomon | 58f153c | 2018-10-18 21:51:15 -0400 | [diff] [blame] | 302 | } |