commit-bot@chromium.org | 78a1078 | 2013-08-21 19:27:48 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2013 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 "GrTest.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 9 | #include <algorithm> |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 10 | #include "GrBackendSurface.h" |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 11 | #include "GrContextOptions.h" |
Chris Dalton | fe199b7 | 2017-05-05 11:26:15 -0400 | [diff] [blame] | 12 | #include "GrContextPriv.h" |
Brian Salomon | 2ee084e | 2016-12-16 18:59:19 -0500 | [diff] [blame] | 13 | #include "GrDrawOpAtlas.h" |
robertphillips | 77a2e52 | 2015-10-17 07:43:27 -0700 | [diff] [blame] | 14 | #include "GrDrawingManager.h" |
Robert Phillips | fbcef6e | 2017-06-15 12:07:18 -0400 | [diff] [blame] | 15 | #include "GrGpu.h" |
bsalomon | 3582d3e | 2015-02-13 14:20:05 -0800 | [diff] [blame] | 16 | #include "GrGpuResourceCacheAccess.h" |
robertphillips | 5fa7f30 | 2016-07-21 09:21:04 -0700 | [diff] [blame] | 17 | #include "GrPipelineBuilder.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 18 | #include "GrRenderTargetContext.h" |
Brian Salomon | 2ee084e | 2016-12-16 18:59:19 -0500 | [diff] [blame] | 19 | #include "GrRenderTargetContextPriv.h" |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 20 | #include "GrRenderTargetProxy.h" |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 21 | #include "GrResourceCache.h" |
Greg Daniel | 6be3523 | 2017-03-01 17:01:09 -0500 | [diff] [blame] | 22 | #include "GrSemaphore.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 23 | #include "GrSurfaceContextPriv.h" |
Robert Phillips | 646e429 | 2017-06-13 12:44:56 -0400 | [diff] [blame] | 24 | #include "GrTexture.h" |
Brian Osman | 3b65598 | 2017-03-07 16:58:08 -0500 | [diff] [blame] | 25 | #include "SkGr.h" |
Robert Phillips | 22f4a1f | 2016-12-20 08:57:26 -0500 | [diff] [blame] | 26 | #include "SkImage_Gpu.h" |
halcanary | 4dbbd04 | 2016-06-07 17:21:10 -0700 | [diff] [blame] | 27 | #include "SkMathPriv.h" |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 28 | #include "SkString.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 29 | #include "ops/GrMeshDrawOp.h" |
Brian Salomon | f856fd1 | 2016-12-16 14:24:34 -0500 | [diff] [blame] | 30 | #include "text/GrAtlasGlyphCache.h" |
joshualitt | e804292 | 2015-12-11 06:11:21 -0800 | [diff] [blame] | 31 | #include "text/GrTextBlobCache.h" |
| 32 | |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 33 | namespace GrTest { |
| 34 | void SetupAlwaysEvictAtlas(GrContext* context) { |
| 35 | // These sizes were selected because they allow each atlas to hold a single plot and will thus |
| 36 | // stress the atlas |
Brian Salomon | 2ee084e | 2016-12-16 18:59:19 -0500 | [diff] [blame] | 37 | int dim = GrDrawOpAtlas::kGlyphMaxDim; |
| 38 | GrDrawOpAtlasConfig configs[3]; |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 39 | configs[kA8_GrMaskFormat].fWidth = dim; |
| 40 | configs[kA8_GrMaskFormat].fHeight = dim; |
jvanverth | 7023a00 | 2016-02-22 11:25:32 -0800 | [diff] [blame] | 41 | configs[kA8_GrMaskFormat].fLog2Width = SkNextLog2(dim); |
| 42 | configs[kA8_GrMaskFormat].fLog2Height = SkNextLog2(dim); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 43 | configs[kA8_GrMaskFormat].fPlotWidth = dim; |
| 44 | configs[kA8_GrMaskFormat].fPlotHeight = dim; |
| 45 | |
| 46 | configs[kA565_GrMaskFormat].fWidth = dim; |
| 47 | configs[kA565_GrMaskFormat].fHeight = dim; |
jvanverth | 7023a00 | 2016-02-22 11:25:32 -0800 | [diff] [blame] | 48 | configs[kA565_GrMaskFormat].fLog2Width = SkNextLog2(dim); |
| 49 | configs[kA565_GrMaskFormat].fLog2Height = SkNextLog2(dim); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 50 | configs[kA565_GrMaskFormat].fPlotWidth = dim; |
| 51 | configs[kA565_GrMaskFormat].fPlotHeight = dim; |
| 52 | |
| 53 | configs[kARGB_GrMaskFormat].fWidth = dim; |
| 54 | configs[kARGB_GrMaskFormat].fHeight = dim; |
jvanverth | 7023a00 | 2016-02-22 11:25:32 -0800 | [diff] [blame] | 55 | configs[kARGB_GrMaskFormat].fLog2Width = SkNextLog2(dim); |
| 56 | configs[kARGB_GrMaskFormat].fLog2Height = SkNextLog2(dim); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 57 | configs[kARGB_GrMaskFormat].fPlotWidth = dim; |
| 58 | configs[kARGB_GrMaskFormat].fPlotHeight = dim; |
| 59 | |
| 60 | context->setTextContextAtlasSizes_ForTesting(configs); |
| 61 | } |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 62 | |
| 63 | GrBackendTexture CreateBackendTexture(GrBackend backend, int width, int height, |
| 64 | GrPixelConfig config, GrBackendObject handle) { |
Mike Reed | d20b5c4 | 2017-06-14 06:03:10 -0400 | [diff] [blame] | 65 | #ifdef SK_VULKAN |
Robert Phillips | fcd5fdd | 2017-06-14 01:43:29 +0000 | [diff] [blame] | 66 | if (kVulkan_GrBackend == backend) { |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 67 | GrVkImageInfo* vkInfo = (GrVkImageInfo*)(handle); |
Greg Daniel | 207282e | 2017-04-26 13:29:21 -0400 | [diff] [blame] | 68 | return GrBackendTexture(width, height, *vkInfo); |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 69 | } |
Robert Phillips | fcd5fdd | 2017-06-14 01:43:29 +0000 | [diff] [blame] | 70 | #endif |
| 71 | SkASSERT(kOpenGL_GrBackend == backend); |
| 72 | GrGLTextureInfo* glInfo = (GrGLTextureInfo*)(handle); |
| 73 | return GrBackendTexture(width, height, config, *glInfo); |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 74 | } |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 75 | }; |
| 76 | |
Robert Phillips | eaa8625 | 2016-11-08 13:49:39 +0000 | [diff] [blame] | 77 | bool GrSurfaceProxy::isWrapped_ForTesting() const { |
| 78 | return SkToBool(fTarget); |
| 79 | } |
| 80 | |
| 81 | bool GrRenderTargetContext::isWrapped_ForTesting() const { |
| 82 | return fRenderTargetProxy->isWrapped_ForTesting(); |
| 83 | } |
| 84 | |
joshualitt | 17d833b | 2015-08-03 10:17:44 -0700 | [diff] [blame] | 85 | void GrContext::setTextBlobCacheLimit_ForTesting(size_t bytes) { |
| 86 | fTextBlobCache->setBudget(bytes); |
| 87 | } |
| 88 | |
Brian Salomon | 2ee084e | 2016-12-16 18:59:19 -0500 | [diff] [blame] | 89 | void GrContext::setTextContextAtlasSizes_ForTesting(const GrDrawOpAtlasConfig* configs) { |
Brian Salomon | f856fd1 | 2016-12-16 14:24:34 -0500 | [diff] [blame] | 90 | fAtlasGlyphCache->setAtlasSizes_ForTesting(configs); |
joshualitt | da04e0e | 2015-08-19 08:16:43 -0700 | [diff] [blame] | 91 | } |
| 92 | |
commit-bot@chromium.org | 78a1078 | 2013-08-21 19:27:48 +0000 | [diff] [blame] | 93 | /////////////////////////////////////////////////////////////////////////////// |
| 94 | |
robertphillips@google.com | 94d8f1e | 2013-12-18 17:25:33 +0000 | [diff] [blame] | 95 | void GrContext::purgeAllUnlockedResources() { |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 96 | fResourceCache->purgeAllUnlocked(); |
robertphillips@google.com | 94d8f1e | 2013-12-18 17:25:33 +0000 | [diff] [blame] | 97 | } |
bsalomon | 3343557 | 2014-11-05 14:47:41 -0800 | [diff] [blame] | 98 | |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 99 | void GrContext::resetGpuStats() const { |
| 100 | #if GR_GPU_STATS |
| 101 | fGpu->stats()->reset(); |
| 102 | #endif |
| 103 | } |
| 104 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 105 | void GrContext::dumpCacheStats(SkString* out) const { |
| 106 | #if GR_CACHE_STATS |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 107 | fResourceCache->dumpStats(out); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 108 | #endif |
| 109 | } |
| 110 | |
joshualitt | dc5685a | 2015-12-02 14:08:25 -0800 | [diff] [blame] | 111 | void GrContext::dumpCacheStatsKeyValuePairs(SkTArray<SkString>* keys, |
| 112 | SkTArray<double>* values) const { |
| 113 | #if GR_CACHE_STATS |
| 114 | fResourceCache->dumpStatsKeyValuePairs(keys, values); |
| 115 | #endif |
| 116 | } |
| 117 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 118 | void GrContext::printCacheStats() const { |
| 119 | SkString out; |
| 120 | this->dumpCacheStats(&out); |
kkinnunen | 297aaf9 | 2015-02-19 06:32:12 -0800 | [diff] [blame] | 121 | SkDebugf("%s", out.c_str()); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 122 | } |
| 123 | |
| 124 | void GrContext::dumpGpuStats(SkString* out) const { |
| 125 | #if GR_GPU_STATS |
| 126 | return fGpu->stats()->dump(out); |
| 127 | #endif |
| 128 | } |
| 129 | |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 130 | void GrContext::dumpGpuStatsKeyValuePairs(SkTArray<SkString>* keys, |
| 131 | SkTArray<double>* values) const { |
| 132 | #if GR_GPU_STATS |
| 133 | return fGpu->stats()->dumpKeyValuePairs(keys, values); |
| 134 | #endif |
| 135 | } |
| 136 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 137 | void GrContext::printGpuStats() const { |
| 138 | SkString out; |
| 139 | this->dumpGpuStats(&out); |
kkinnunen | 297aaf9 | 2015-02-19 06:32:12 -0800 | [diff] [blame] | 140 | SkDebugf("%s", out.c_str()); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 141 | } |
| 142 | |
Robert Phillips | c37e614 | 2017-01-20 10:03:25 -0500 | [diff] [blame] | 143 | sk_sp<SkImage> GrContext::getFontAtlasImage_ForTesting(GrMaskFormat format) { |
Brian Salomon | f856fd1 | 2016-12-16 14:24:34 -0500 | [diff] [blame] | 144 | GrAtlasGlyphCache* cache = this->getAtlasGlyphCache(); |
jvanverth | 629162d | 2015-11-08 08:07:24 -0800 | [diff] [blame] | 145 | |
Robert Phillips | 32f2818 | 2017-02-28 16:20:03 -0500 | [diff] [blame] | 146 | sk_sp<GrTextureProxy> proxy = cache->getProxy(format); |
| 147 | if (!proxy) { |
| 148 | return nullptr; |
| 149 | } |
| 150 | |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 151 | SkASSERT(proxy->priv().isExact()); |
| 152 | sk_sp<SkImage> image(new SkImage_Gpu(this, kNeedNewImageUniqueID, kPremul_SkAlphaType, |
| 153 | std::move(proxy), nullptr, SkBudgeted::kNo)); |
Robert Phillips | 22f4a1f | 2016-12-20 08:57:26 -0500 | [diff] [blame] | 154 | return image; |
jvanverth | 0671b96 | 2015-12-08 18:53:44 -0800 | [diff] [blame] | 155 | } |
jvanverth | 629162d | 2015-11-08 08:07:24 -0800 | [diff] [blame] | 156 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 157 | #if GR_GPU_STATS |
| 158 | void GrGpu::Stats::dump(SkString* out) { |
| 159 | out->appendf("Render Target Binds: %d\n", fRenderTargetBinds); |
| 160 | out->appendf("Shader Compilations: %d\n", fShaderCompilations); |
bsalomon | b12ea41 | 2015-02-02 21:19:50 -0800 | [diff] [blame] | 161 | out->appendf("Textures Created: %d\n", fTextureCreates); |
| 162 | out->appendf("Texture Uploads: %d\n", fTextureUploads); |
jvanverth | 17aa047 | 2016-01-05 10:41:27 -0800 | [diff] [blame] | 163 | out->appendf("Transfers to Texture: %d\n", fTransfersToTexture); |
egdaniel | 8dc7c3a | 2015-04-16 11:22:42 -0700 | [diff] [blame] | 164 | out->appendf("Stencil Buffer Creates: %d\n", fStencilAttachmentCreates); |
joshualitt | 87a5c9f | 2015-09-08 13:42:05 -0700 | [diff] [blame] | 165 | out->appendf("Number of draws: %d\n", fNumDraws); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 166 | } |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 167 | |
| 168 | void GrGpu::Stats::dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) { |
| 169 | keys->push_back(SkString("render_target_binds")); values->push_back(fRenderTargetBinds); |
| 170 | keys->push_back(SkString("shader_compilations")); values->push_back(fShaderCompilations); |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 171 | keys->push_back(SkString("texture_uploads")); values->push_back(fTextureUploads); |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 172 | keys->push_back(SkString("number_of_draws")); values->push_back(fNumDraws); |
bsalomon | 1d417a8 | 2016-03-23 11:50:26 -0700 | [diff] [blame] | 173 | keys->push_back(SkString("number_of_failed_draws")); values->push_back(fNumFailedDraws); |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 174 | } |
| 175 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 176 | #endif |
| 177 | |
| 178 | #if GR_CACHE_STATS |
robertphillips | 60029a5 | 2015-11-09 13:51:06 -0800 | [diff] [blame] | 179 | void GrResourceCache::getStats(Stats* stats) const { |
| 180 | stats->reset(); |
| 181 | |
| 182 | stats->fTotal = this->getResourceCount(); |
| 183 | stats->fNumNonPurgeable = fNonpurgeableResources.count(); |
| 184 | stats->fNumPurgeable = fPurgeableQueue.count(); |
| 185 | |
| 186 | for (int i = 0; i < fNonpurgeableResources.count(); ++i) { |
| 187 | stats->update(fNonpurgeableResources[i]); |
| 188 | } |
| 189 | for (int i = 0; i < fPurgeableQueue.count(); ++i) { |
| 190 | stats->update(fPurgeableQueue.at(i)); |
| 191 | } |
| 192 | } |
| 193 | |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 194 | void GrResourceCache::dumpStats(SkString* out) const { |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 195 | this->validate(); |
| 196 | |
bsalomon | f320e04 | 2015-02-17 15:09:34 -0800 | [diff] [blame] | 197 | Stats stats; |
| 198 | |
robertphillips | 60029a5 | 2015-11-09 13:51:06 -0800 | [diff] [blame] | 199 | this->getStats(&stats); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 200 | |
| 201 | float countUtilization = (100.f * fBudgetedCount) / fMaxCount; |
| 202 | float byteUtilization = (100.f * fBudgetedBytes) / fMaxBytes; |
| 203 | |
| 204 | out->appendf("Budget: %d items %d bytes\n", fMaxCount, (int)fMaxBytes); |
| 205 | out->appendf("\t\tEntry Count: current %d" |
kkinnunen | 2e6055b | 2016-04-22 01:48:29 -0700 | [diff] [blame] | 206 | " (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n", |
| 207 | stats.fTotal, fBudgetedCount, stats.fWrapped, stats.fNumNonPurgeable, |
| 208 | stats.fScratch, countUtilization, fHighWaterCount); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 209 | out->appendf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full, %d unbudgeted) high %d\n", |
bsalomon | f320e04 | 2015-02-17 15:09:34 -0800 | [diff] [blame] | 210 | SkToInt(fBytes), SkToInt(fBudgetedBytes), byteUtilization, |
| 211 | SkToInt(stats.fUnbudgetedSize), SkToInt(fHighWaterBytes)); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 212 | } |
| 213 | |
joshualitt | dc5685a | 2015-12-02 14:08:25 -0800 | [diff] [blame] | 214 | void GrResourceCache::dumpStatsKeyValuePairs(SkTArray<SkString>* keys, |
| 215 | SkTArray<double>* values) const { |
| 216 | this->validate(); |
| 217 | |
| 218 | Stats stats; |
| 219 | this->getStats(&stats); |
| 220 | |
joshualitt | dc5685a | 2015-12-02 14:08:25 -0800 | [diff] [blame] | 221 | keys->push_back(SkString("gpu_cache_purgable_entries")); values->push_back(stats.fNumPurgeable); |
joshualitt | dc5685a | 2015-12-02 14:08:25 -0800 | [diff] [blame] | 222 | } |
| 223 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 224 | #endif |
| 225 | |
bsalomon | ddf30e6 | 2015-02-19 11:38:44 -0800 | [diff] [blame] | 226 | /////////////////////////////////////////////////////////////////////////////// |
| 227 | |
| 228 | void GrResourceCache::changeTimestamp(uint32_t newTimestamp) { fTimestamp = newTimestamp; } |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 229 | |
Brian Salomon | 1090da6 | 2017-01-06 12:04:19 -0500 | [diff] [blame] | 230 | #ifdef SK_DEBUG |
| 231 | int GrResourceCache::countUniqueKeysWithTag(const char* tag) const { |
| 232 | int count = 0; |
| 233 | UniqueHash::ConstIter iter(&fUniqueHash); |
| 234 | while (!iter.done()) { |
| 235 | if (0 == strcmp(tag, (*iter).getUniqueKey().tag())) { |
| 236 | ++count; |
| 237 | } |
| 238 | ++iter; |
| 239 | } |
| 240 | return count; |
| 241 | } |
| 242 | #endif |
| 243 | |
bsalomon | 3343557 | 2014-11-05 14:47:41 -0800 | [diff] [blame] | 244 | /////////////////////////////////////////////////////////////////////////////// |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 245 | |
| 246 | #define ASSERT_SINGLE_OWNER \ |
Robert Phillips | a90aa2b | 2017-04-10 08:19:26 -0400 | [diff] [blame] | 247 | SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fRenderTargetContext->singleOwner());) |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 248 | |
Brian Salomon | d3ccb0a | 2017-04-03 10:38:00 -0400 | [diff] [blame] | 249 | uint32_t GrRenderTargetContextPriv::testingOnly_addLegacyMeshDrawOp( |
| 250 | GrPaint&& paint, |
| 251 | GrAAType aaType, |
| 252 | std::unique_ptr<GrLegacyMeshDrawOp> op, |
| 253 | const GrUserStencilSettings* uss, |
| 254 | bool snapToCenters) { |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 255 | ASSERT_SINGLE_OWNER |
Robert Phillips | c013892 | 2017-03-08 11:50:55 -0500 | [diff] [blame] | 256 | if (fRenderTargetContext->drawingManager()->wasAbandoned()) { |
| 257 | return SK_InvalidUniqueID; |
| 258 | } |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 259 | SkDEBUGCODE(fRenderTargetContext->validate()); |
| 260 | GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail, |
| 261 | "GrRenderTargetContext::testingOnly_addLegacyMeshDrawOp"); |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 262 | |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 263 | GrPipelineBuilder pipelineBuilder(std::move(paint), aaType); |
robertphillips | 28a838e | 2016-06-23 14:07:00 -0700 | [diff] [blame] | 264 | if (uss) { |
| 265 | pipelineBuilder.setUserStencil(uss); |
cdalton | 846c051 | 2016-05-13 10:25:00 -0700 | [diff] [blame] | 266 | } |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 267 | pipelineBuilder.setSnapVerticesToPixelCenters(snapToCenters); |
robertphillips | 28a838e | 2016-06-23 14:07:00 -0700 | [diff] [blame] | 268 | |
Brian Salomon | e14bd80 | 2017-04-04 15:13:25 -0400 | [diff] [blame] | 269 | return fRenderTargetContext->addLegacyMeshDrawOp(std::move(pipelineBuilder), GrNoClip(), |
| 270 | std::move(op)); |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 271 | } |
| 272 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 273 | uint32_t GrRenderTargetContextPriv::testingOnly_addDrawOp(std::unique_ptr<GrDrawOp> op) { |
| 274 | ASSERT_SINGLE_OWNER |
| 275 | if (fRenderTargetContext->drawingManager()->wasAbandoned()) { |
| 276 | return SK_InvalidUniqueID; |
| 277 | } |
| 278 | SkDEBUGCODE(fRenderTargetContext->validate()); |
| 279 | GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail, |
| 280 | "GrRenderTargetContext::testingOnly_addDrawOp"); |
| 281 | return fRenderTargetContext->addDrawOp(GrNoClip(), std::move(op)); |
| 282 | } |
| 283 | |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 284 | #undef ASSERT_SINGLE_OWNER |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 285 | |
| 286 | /////////////////////////////////////////////////////////////////////////////// |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 287 | |
Robert Phillips | c4f0a82 | 2017-06-13 08:11:36 -0400 | [diff] [blame] | 288 | GrRenderTargetFlags GrRenderTargetProxy::testingOnly_getFlags() const { |
Brian Salomon | dac5f6b | 2017-02-28 16:11:04 -0500 | [diff] [blame] | 289 | return fRenderTargetFlags; |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 290 | } |
| 291 | |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 292 | ////////////////////////////////////////////////////////////////////////////// |
| 293 | |
Chris Dalton | fe199b7 | 2017-05-05 11:26:15 -0400 | [diff] [blame] | 294 | void GrContextPriv::testingOnly_flushAndRemoveOnFlushCallbackObject(GrOnFlushCallbackObject* cb) { |
| 295 | fContext->flush(); |
| 296 | fContext->fDrawingManager->testingOnly_removeOnFlushCallbackObject(cb); |
| 297 | } |
| 298 | |
| 299 | void GrDrawingManager::testingOnly_removeOnFlushCallbackObject(GrOnFlushCallbackObject* cb) { |
| 300 | int n = std::find(fOnFlushCBObjects.begin(), fOnFlushCBObjects.end(), cb) - |
| 301 | fOnFlushCBObjects.begin(); |
| 302 | SkASSERT(n < fOnFlushCBObjects.count()); |
| 303 | fOnFlushCBObjects.removeShuffle(n); |
| 304 | } |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 305 | |
| 306 | ////////////////////////////////////////////////////////////////////////////// |
| 307 | |
| 308 | #define DRAW_OP_TEST_EXTERN(Op) \ |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 309 | extern std::unique_ptr<GrDrawOp> Op##__Test(GrPaint&&, SkRandom*, GrContext*, GrFSAAType) |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 310 | |
| 311 | #define LEGACY_MESH_DRAW_OP_TEST_EXTERN(Op) \ |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 312 | extern std::unique_ptr<GrLegacyMeshDrawOp> Op##__Test(SkRandom*, GrContext*) |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 313 | |
| 314 | #define DRAW_OP_TEST_ENTRY(Op) Op##__Test |
| 315 | |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 316 | LEGACY_MESH_DRAW_OP_TEST_EXTERN(AnalyticRectOp); |
Brian Salomon | e3e9628 | 2017-07-16 00:40:10 +0000 | [diff] [blame^] | 317 | LEGACY_MESH_DRAW_OP_TEST_EXTERN(TextBlobOp); |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 318 | |
Brian Salomon | 10978a6 | 2017-06-15 16:21:49 -0400 | [diff] [blame] | 319 | DRAW_OP_TEST_EXTERN(AAConvexPathOp); |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 320 | DRAW_OP_TEST_EXTERN(AAFillRectOp); |
Brian Salomon | b295573 | 2017-07-13 16:42:55 -0400 | [diff] [blame] | 321 | DRAW_OP_TEST_EXTERN(AAFlatteningConvexPathOp); |
Brian Salomon | a531f25 | 2017-07-07 13:29:28 -0400 | [diff] [blame] | 322 | DRAW_OP_TEST_EXTERN(AAHairlineOp); |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 323 | DRAW_OP_TEST_EXTERN(AAStrokeRectOp); |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 324 | DRAW_OP_TEST_EXTERN(CircleOp); |
Brian Salomon | 98222ac | 2017-07-12 15:27:54 -0400 | [diff] [blame] | 325 | DRAW_OP_TEST_EXTERN(DashOp); |
Brian Salomon | ee3e0ba | 2017-07-13 16:40:46 -0400 | [diff] [blame] | 326 | DRAW_OP_TEST_EXTERN(DefaultPathOp); |
Brian Salomon | 05441c4 | 2017-05-15 16:45:49 -0400 | [diff] [blame] | 327 | DRAW_OP_TEST_EXTERN(DIEllipseOp); |
| 328 | DRAW_OP_TEST_EXTERN(EllipseOp); |
Brian Salomon | 0088f94 | 2017-07-12 11:51:27 -0400 | [diff] [blame] | 329 | DRAW_OP_TEST_EXTERN(GrDrawAtlasOp); |
Brian Salomon | c2f4254 | 2017-07-12 14:11:22 -0400 | [diff] [blame] | 330 | DRAW_OP_TEST_EXTERN(GrDrawVerticesOp); |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 331 | DRAW_OP_TEST_EXTERN(NonAAFillRectOp); |
| 332 | DRAW_OP_TEST_EXTERN(NonAALatticeOp); |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 333 | DRAW_OP_TEST_EXTERN(NonAAStrokeRectOp); |
Brian Salomon | 0596909 | 2017-07-13 11:20:51 -0400 | [diff] [blame] | 334 | DRAW_OP_TEST_EXTERN(ShadowRRectOp); |
Brian Salomon | febbd23 | 2017-07-11 15:52:02 -0400 | [diff] [blame] | 335 | DRAW_OP_TEST_EXTERN(SmallPathOp); |
Brian Salomon | f036632 | 2017-07-11 15:53:05 -0400 | [diff] [blame] | 336 | DRAW_OP_TEST_EXTERN(RegionOp); |
Brian Salomon | 05441c4 | 2017-05-15 16:45:49 -0400 | [diff] [blame] | 337 | DRAW_OP_TEST_EXTERN(RRectOp); |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 338 | DRAW_OP_TEST_EXTERN(TesselatingPathOp); |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 339 | |
| 340 | void GrDrawRandomOp(SkRandom* random, GrRenderTargetContext* renderTargetContext, GrPaint&& paint) { |
| 341 | GrContext* context = renderTargetContext->surfPriv().getContext(); |
| 342 | using MakeTestLegacyMeshDrawOpFn = std::unique_ptr<GrLegacyMeshDrawOp>(SkRandom*, GrContext*); |
| 343 | static constexpr MakeTestLegacyMeshDrawOpFn* gLegacyFactories[] = { |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 344 | DRAW_OP_TEST_ENTRY(AnalyticRectOp), |
Brian Salomon | e3e9628 | 2017-07-16 00:40:10 +0000 | [diff] [blame^] | 345 | DRAW_OP_TEST_ENTRY(TextBlobOp), |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 346 | }; |
| 347 | |
| 348 | using MakeDrawOpFn = std::unique_ptr<GrDrawOp>(GrPaint&&, SkRandom*, GrContext*, GrFSAAType); |
| 349 | static constexpr MakeDrawOpFn* gFactories[] = { |
Brian Salomon | 10978a6 | 2017-06-15 16:21:49 -0400 | [diff] [blame] | 350 | DRAW_OP_TEST_ENTRY(AAConvexPathOp), |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 351 | DRAW_OP_TEST_ENTRY(AAFillRectOp), |
Brian Salomon | b295573 | 2017-07-13 16:42:55 -0400 | [diff] [blame] | 352 | DRAW_OP_TEST_ENTRY(AAFlatteningConvexPathOp), |
Brian Salomon | a531f25 | 2017-07-07 13:29:28 -0400 | [diff] [blame] | 353 | DRAW_OP_TEST_ENTRY(AAHairlineOp), |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 354 | DRAW_OP_TEST_ENTRY(AAStrokeRectOp), |
Brian Salomon | 05441c4 | 2017-05-15 16:45:49 -0400 | [diff] [blame] | 355 | DRAW_OP_TEST_ENTRY(CircleOp), |
Brian Salomon | 98222ac | 2017-07-12 15:27:54 -0400 | [diff] [blame] | 356 | DRAW_OP_TEST_ENTRY(DashOp), |
Brian Salomon | ee3e0ba | 2017-07-13 16:40:46 -0400 | [diff] [blame] | 357 | DRAW_OP_TEST_ENTRY(DefaultPathOp), |
Brian Salomon | 05441c4 | 2017-05-15 16:45:49 -0400 | [diff] [blame] | 358 | DRAW_OP_TEST_ENTRY(DIEllipseOp), |
| 359 | DRAW_OP_TEST_ENTRY(EllipseOp), |
Brian Salomon | 0088f94 | 2017-07-12 11:51:27 -0400 | [diff] [blame] | 360 | DRAW_OP_TEST_ENTRY(GrDrawAtlasOp), |
Brian Salomon | c2f4254 | 2017-07-12 14:11:22 -0400 | [diff] [blame] | 361 | DRAW_OP_TEST_ENTRY(GrDrawVerticesOp), |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 362 | DRAW_OP_TEST_ENTRY(NonAAFillRectOp), |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 363 | DRAW_OP_TEST_ENTRY(NonAALatticeOp), |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 364 | DRAW_OP_TEST_ENTRY(NonAAStrokeRectOp), |
Brian Salomon | 0596909 | 2017-07-13 11:20:51 -0400 | [diff] [blame] | 365 | DRAW_OP_TEST_ENTRY(ShadowRRectOp), |
Brian Salomon | febbd23 | 2017-07-11 15:52:02 -0400 | [diff] [blame] | 366 | DRAW_OP_TEST_ENTRY(SmallPathOp), |
Brian Salomon | f036632 | 2017-07-11 15:53:05 -0400 | [diff] [blame] | 367 | DRAW_OP_TEST_ENTRY(RegionOp), |
Brian Salomon | 05441c4 | 2017-05-15 16:45:49 -0400 | [diff] [blame] | 368 | DRAW_OP_TEST_ENTRY(RRectOp), |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 369 | DRAW_OP_TEST_ENTRY(TesselatingPathOp), |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 370 | }; |
| 371 | |
| 372 | static constexpr size_t kTotal = SK_ARRAY_COUNT(gLegacyFactories) + SK_ARRAY_COUNT(gFactories); |
| 373 | |
| 374 | uint32_t index = random->nextULessThan(static_cast<uint32_t>(kTotal)); |
| 375 | if (index < SK_ARRAY_COUNT(gLegacyFactories)) { |
| 376 | const GrUserStencilSettings* uss = GrGetRandomStencil(random, context); |
| 377 | // We don't use kHW because we will hit an assertion if the render target is not |
| 378 | // multisampled |
| 379 | static constexpr GrAAType kAATypes[] = {GrAAType::kNone, GrAAType::kCoverage}; |
| 380 | GrAAType aaType = kAATypes[random->nextULessThan(SK_ARRAY_COUNT(kAATypes))]; |
| 381 | bool snapToCenters = random->nextBool(); |
| 382 | auto op = gLegacyFactories[index](random, context); |
| 383 | SkASSERT(op); |
| 384 | renderTargetContext->priv().testingOnly_addLegacyMeshDrawOp( |
| 385 | std::move(paint), aaType, std::move(op), uss, snapToCenters); |
| 386 | } else { |
| 387 | auto op = gFactories[index - SK_ARRAY_COUNT(gLegacyFactories)]( |
| 388 | std::move(paint), random, context, renderTargetContext->fsaaType()); |
| 389 | SkASSERT(op); |
| 390 | renderTargetContext->priv().testingOnly_addDrawOp(std::move(op)); |
| 391 | } |
| 392 | } |