blob: bc91c755a1f909716208f1e5a921bb38653a5136 [file] [log] [blame]
Brian Salomoncfe910d2017-07-06 16:40:18 -04001/*
2 * Copyright 2017 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 Kleinc0bd9f92019-04-23 12:05:21 -05008#include "src/gpu/mock/GrMockBuffer.h"
9#include "src/gpu/mock/GrMockCaps.h"
10#include "src/gpu/mock/GrMockGpu.h"
Greg Daniel2d41d0d2019-08-26 11:08:51 -040011#include "src/gpu/mock/GrMockOpsRenderPass.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050012#include "src/gpu/mock/GrMockStencilAttachment.h"
13#include "src/gpu/mock/GrMockTexture.h"
Mike Kleinde2244c2018-12-04 11:16:08 -050014#include <atomic>
Brian Salomoncfe910d2017-07-06 16:40:18 -040015
Brian Salomon8fe24272017-07-07 12:56:11 -040016int GrMockGpu::NextInternalTextureID() {
Mike Kleinde2244c2018-12-04 11:16:08 -050017 static std::atomic<int> nextID{1};
Chris Dalton351e80c2019-01-06 22:51:00 -070018 int id;
19 do {
20 id = nextID.fetch_add(1);
21 } while (0 == id); // Reserve 0 for an invalid ID.
22 return id;
Brian Salomon8fe24272017-07-07 12:56:11 -040023}
24
25int GrMockGpu::NextExternalTextureID() {
26 // We use negative ints for the "testing only external textures" so they can easily be
27 // identified when debugging.
Mike Kleinde2244c2018-12-04 11:16:08 -050028 static std::atomic<int> nextID{-1};
29 return nextID--;
Brian Salomon8fe24272017-07-07 12:56:11 -040030}
31
Brian Salomon0c51eea2018-03-09 17:02:09 -050032int GrMockGpu::NextInternalRenderTargetID() {
Mike Kleinde2244c2018-12-04 11:16:08 -050033 // We start off with large numbers to differentiate from texture IDs, even though they're
Brian Salomon0c51eea2018-03-09 17:02:09 -050034 // technically in a different space.
Mike Kleinde2244c2018-12-04 11:16:08 -050035 static std::atomic<int> nextID{SK_MaxS32};
36 return nextID--;
Brian Salomon0c51eea2018-03-09 17:02:09 -050037}
38
39int GrMockGpu::NextExternalRenderTargetID() {
40 // We use large negative ints for the "testing only external render targets" so they can easily
41 // be identified when debugging.
Mike Kleinde2244c2018-12-04 11:16:08 -050042 static std::atomic<int> nextID{SK_MinS32};
43 return nextID++;
Brian Salomon0c51eea2018-03-09 17:02:09 -050044}
45
Brian Salomon384fab42017-12-07 12:33:05 -050046sk_sp<GrGpu> GrMockGpu::Make(const GrMockOptions* mockOptions,
47 const GrContextOptions& contextOptions, GrContext* context) {
Greg Daniel02611d92017-07-25 10:05:01 -040048 static const GrMockOptions kDefaultOptions = GrMockOptions();
49 if (!mockOptions) {
50 mockOptions = &kDefaultOptions;
51 }
Brian Salomon384fab42017-12-07 12:33:05 -050052 return sk_sp<GrGpu>(new GrMockGpu(context, *mockOptions, contextOptions));
Greg Daniel02611d92017-07-25 10:05:01 -040053}
54
Greg Daniel2d41d0d2019-08-26 11:08:51 -040055GrOpsRenderPass* GrMockGpu::getOpsRenderPass(
Ethan Nicholas56d19a52018-10-15 11:26:20 -040056 GrRenderTarget* rt, GrSurfaceOrigin origin, const SkRect& bounds,
Greg Daniel2d41d0d2019-08-26 11:08:51 -040057 const GrOpsRenderPass::LoadAndStoreInfo& colorInfo,
Greg Danielb20d7e52019-09-03 13:54:39 -040058 const GrOpsRenderPass::StencilLoadAndStoreInfo&,
59 const SkTArray<GrTextureProxy*, true>& sampledProxies) {
Greg Daniel2d41d0d2019-08-26 11:08:51 -040060 return new GrMockOpsRenderPass(this, rt, origin, colorInfo);
Brian Salomoncfe910d2017-07-06 16:40:18 -040061}
62
Greg Daniel2d41d0d2019-08-26 11:08:51 -040063void GrMockGpu::submit(GrOpsRenderPass* renderPass) {
64 for (int i = 0; i < static_cast<GrMockOpsRenderPass*>(renderPass)->numDraws(); ++i) {
Brian Salomoncfe910d2017-07-06 16:40:18 -040065 fStats.incNumDraws();
66 }
Greg Daniel2d41d0d2019-08-26 11:08:51 -040067 delete renderPass;
Brian Salomoncfe910d2017-07-06 16:40:18 -040068}
69
70GrMockGpu::GrMockGpu(GrContext* context, const GrMockOptions& options,
71 const GrContextOptions& contextOptions)
Chris Dalton91ab1552018-04-18 13:24:25 -060072 : INHERITED(context)
73 , fMockOptions(options) {
Brian Salomoncfe910d2017-07-06 16:40:18 -040074 fCaps.reset(new GrMockCaps(contextOptions, options));
75}
76
Chris Daltonc3318f02019-07-19 14:20:53 -060077void GrMockGpu::querySampleLocations(GrRenderTarget* rt, SkTArray<SkPoint>* sampleLocations) {
78 sampleLocations->reset();
79 int numRemainingSamples = rt->numSamples();
80 while (numRemainingSamples > 0) {
81 // Use standard D3D sample locations.
82 switch (numRemainingSamples) {
83 case 0:
84 case 1:
85 sampleLocations->push_back().set(.5, .5);
86 break;
87 case 2:
88 sampleLocations->push_back().set(.75, .75);
89 sampleLocations->push_back().set(.25, .25);
90 break;
91 case 3:
92 case 4:
93 sampleLocations->push_back().set(.375, .125);
94 sampleLocations->push_back().set(.875, .375);
95 sampleLocations->push_back().set(.125, .625);
96 sampleLocations->push_back().set(.625, .875);
97 break;
98 case 5:
99 case 6:
100 case 7:
101 case 8:
102 sampleLocations->push_back().set(.5625, .3125);
103 sampleLocations->push_back().set(.4375, .6875);
104 sampleLocations->push_back().set(.8125, .5625);
105 sampleLocations->push_back().set(.3125, .1875);
106 sampleLocations->push_back().set(.1875, .8125);
107 sampleLocations->push_back().set(.0625, .4375);
108 sampleLocations->push_back().set(.6875, .4375);
109 sampleLocations->push_back().set(.4375, .0625);
110 break;
111 default:
112 sampleLocations->push_back().set(.5625, .5625);
113 sampleLocations->push_back().set(.4375, .3125);
114 sampleLocations->push_back().set(.3125, .6250);
115 sampleLocations->push_back().set(.2500, .4375);
116 sampleLocations->push_back().set(.1875, .3750);
117 sampleLocations->push_back().set(.6250, .8125);
118 sampleLocations->push_back().set(.8125, .6875);
119 sampleLocations->push_back().set(.6875, .1875);
120 sampleLocations->push_back().set(.3750, .8750);
121 sampleLocations->push_back().set(.5000, .0625);
122 sampleLocations->push_back().set(.2500, .1250);
123 sampleLocations->push_back().set(.1250, .2500);
124 sampleLocations->push_back().set(.0000, .5000);
125 sampleLocations->push_back().set(.4375, .2500);
126 sampleLocations->push_back().set(.8750, .4375);
127 sampleLocations->push_back().set(.0625, .0000);
128 break;
129 }
130 numRemainingSamples = rt->numSamples() - sampleLocations->count();
131 }
132}
133
Brian Salomon81536f22019-08-08 16:30:49 -0400134sk_sp<GrTexture> GrMockGpu::onCreateTexture(const GrSurfaceDesc& desc,
135 const GrBackendFormat& format,
136 GrRenderable renderable,
137 int renderTargetSampleCnt,
138 SkBudgeted budgeted,
139 GrProtected isProtected,
Brian Salomond2a8ae22019-09-10 16:03:59 -0400140 int mipLevelCount,
141 uint32_t levelClearMask) {
Chris Dalton91ab1552018-04-18 13:24:25 -0600142 if (fMockOptions.fFailTextureAllocations) {
143 return nullptr;
144 }
145
Brian Salomon81536f22019-08-08 16:30:49 -0400146 GrColorType ct = format.asMockColorType();
147 SkASSERT(ct != GrColorType::kUnknown);
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400148
Brian Salomond2a8ae22019-09-10 16:03:59 -0400149 GrMipMapsStatus mipMapsStatus =
150 mipLevelCount > 1 ? GrMipMapsStatus::kDirty : GrMipMapsStatus::kNotAllocated;
Greg Daniele877dce2019-07-11 10:52:43 -0400151 GrMockTextureInfo texInfo(ct, NextInternalTextureID());
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400152 if (renderable == GrRenderable::kYes) {
Greg Daniele877dce2019-07-11 10:52:43 -0400153 GrMockRenderTargetInfo rtInfo(ct, NextInternalRenderTargetID());
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400154 return sk_sp<GrTexture>(new GrMockTextureRenderTarget(this, budgeted, desc,
155 renderTargetSampleCnt, isProtected,
Brian Salomone8a766b2019-07-19 14:24:36 -0400156 mipMapsStatus, texInfo, rtInfo));
Brian Salomoncfe910d2017-07-06 16:40:18 -0400157 }
Brian Salomone8a766b2019-07-19 14:24:36 -0400158 return sk_sp<GrTexture>(
159 new GrMockTexture(this, budgeted, desc, isProtected, mipMapsStatus, texInfo));
Brian Salomoncfe910d2017-07-06 16:40:18 -0400160}
161
Greg Daniel7bfc9132019-08-14 14:23:53 -0400162sk_sp<GrTexture> GrMockGpu::onCreateCompressedTexture(int width, int height, const GrBackendFormat&,
Brian Salomonbb8dde82019-06-27 10:52:13 -0400163 SkImage::CompressionType compressionType,
164 SkBudgeted budgeted, const void* data) {
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400165 return nullptr;
Brian Salomonbb8dde82019-06-27 10:52:13 -0400166}
167
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400168sk_sp<GrTexture> GrMockGpu::onWrapBackendTexture(const GrBackendTexture& tex, GrColorType colorType,
Brian Salomonfa2ebea2019-01-24 15:58:58 -0500169 GrWrapOwnership ownership,
170 GrWrapCacheable wrapType, GrIOType ioType) {
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400171 GrMockTextureInfo texInfo;
172 SkAssertResult(tex.getMockTextureInfo(&texInfo));
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400173
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400174 SkASSERT(colorType == texInfo.fColorType);
Greg Daniel4684f822018-03-08 15:27:36 -0500175 GrSurfaceDesc desc;
176 desc.fWidth = tex.width();
177 desc.fHeight = tex.height();
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400178 desc.fConfig = texInfo.pixelConfig();
Greg Daniel4684f822018-03-08 15:27:36 -0500179
180 GrMipMapsStatus mipMapsStatus = tex.hasMipMaps() ? GrMipMapsStatus::kValid
181 : GrMipMapsStatus::kNotAllocated;
Brian Salomone8a766b2019-07-19 14:24:36 -0400182 auto isProtected = GrProtected(tex.isProtected());
183 return sk_sp<GrTexture>(
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400184 new GrMockTexture(this, desc, isProtected, mipMapsStatus, texInfo, wrapType, ioType));
Greg Daniel4684f822018-03-08 15:27:36 -0500185}
186
Brian Salomon0c51eea2018-03-09 17:02:09 -0500187sk_sp<GrTexture> GrMockGpu::onWrapRenderableBackendTexture(const GrBackendTexture& tex,
188 int sampleCnt,
Robert Phillips0902c982019-07-16 07:47:56 -0400189 GrColorType colorType,
Brian Salomonaa6ca0a2019-01-24 16:03:07 -0500190 GrWrapOwnership ownership,
191 GrWrapCacheable cacheable) {
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400192 GrMockTextureInfo texInfo;
193 SkAssertResult(tex.getMockTextureInfo(&texInfo));
194
Robert Phillips0902c982019-07-16 07:47:56 -0400195 SkASSERT(colorType == texInfo.fColorType);
Brian Salomon0c51eea2018-03-09 17:02:09 -0500196 GrSurfaceDesc desc;
Brian Salomon0c51eea2018-03-09 17:02:09 -0500197 desc.fWidth = tex.width();
198 desc.fHeight = tex.height();
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400199 desc.fConfig = texInfo.pixelConfig();
Brian Salomon0c51eea2018-03-09 17:02:09 -0500200
201 GrMipMapsStatus mipMapsStatus =
202 tex.hasMipMaps() ? GrMipMapsStatus::kValid : GrMipMapsStatus::kNotAllocated;
203
Brian Salomon0c51eea2018-03-09 17:02:09 -0500204 // The client gave us the texture ID but we supply the render target ID.
Greg Daniele877dce2019-07-11 10:52:43 -0400205 GrMockRenderTargetInfo rtInfo(texInfo.fColorType, NextInternalRenderTargetID());
Brian Salomon0c51eea2018-03-09 17:02:09 -0500206
Brian Salomone8a766b2019-07-19 14:24:36 -0400207 auto isProtected = GrProtected(tex.isProtected());
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400208 return sk_sp<GrTexture>(new GrMockTextureRenderTarget(
209 this, desc, sampleCnt, isProtected, mipMapsStatus, texInfo, rtInfo, cacheable));
Brian Salomon0c51eea2018-03-09 17:02:09 -0500210}
211
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400212sk_sp<GrRenderTarget> GrMockGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt,
213 GrColorType colorType) {
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400214 GrMockRenderTargetInfo info;
215 SkAssertResult(rt.getMockRenderTargetInfo(&info));
216
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400217 SkASSERT(colorType == info.colorType());
Brian Salomon0c51eea2018-03-09 17:02:09 -0500218 GrSurfaceDesc desc;
Brian Salomon0c51eea2018-03-09 17:02:09 -0500219 desc.fWidth = rt.width();
220 desc.fHeight = rt.height();
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400221 desc.fConfig = info.pixelConfig();
Brian Salomon0c51eea2018-03-09 17:02:09 -0500222
Brian Salomone8a766b2019-07-19 14:24:36 -0400223 auto isProtected = GrProtected(rt.isProtected());
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400224 return sk_sp<GrRenderTarget>(new GrMockRenderTarget(this, GrMockRenderTarget::kWrapped, desc,
225 rt.sampleCnt(), isProtected, info));
Brian Salomon0c51eea2018-03-09 17:02:09 -0500226}
227
228sk_sp<GrRenderTarget> GrMockGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400229 int sampleCnt,
230 GrColorType colorType) {
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400231 GrMockTextureInfo texInfo;
232 SkAssertResult(tex.getMockTextureInfo(&texInfo));
233
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400234 SkASSERT(colorType == texInfo.fColorType);
Brian Salomon0c51eea2018-03-09 17:02:09 -0500235 GrSurfaceDesc desc;
Brian Salomon0c51eea2018-03-09 17:02:09 -0500236 desc.fWidth = tex.width();
237 desc.fHeight = tex.height();
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400238 desc.fConfig = texInfo.pixelConfig();
Brian Salomon0c51eea2018-03-09 17:02:09 -0500239
Brian Salomon0c51eea2018-03-09 17:02:09 -0500240 // The client gave us the texture ID but we supply the render target ID.
Greg Daniele877dce2019-07-11 10:52:43 -0400241 GrMockRenderTargetInfo rtInfo(texInfo.fColorType, NextInternalRenderTargetID());
Brian Salomon0c51eea2018-03-09 17:02:09 -0500242
Brian Salomone8a766b2019-07-19 14:24:36 -0400243 auto isProtected = GrProtected(tex.isProtected());
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400244 return sk_sp<GrRenderTarget>(new GrMockRenderTarget(this, GrMockRenderTarget::kWrapped, desc,
245 sampleCnt, isProtected, rtInfo));
Brian Salomon0c51eea2018-03-09 17:02:09 -0500246}
247
Brian Salomondbf70722019-02-07 11:31:24 -0500248sk_sp<GrGpuBuffer> GrMockGpu::onCreateBuffer(size_t sizeInBytes, GrGpuBufferType type,
249 GrAccessPattern accessPattern, const void*) {
250 return sk_sp<GrGpuBuffer>(new GrMockBuffer(this, sizeInBytes, type, accessPattern));
Brian Salomoncfe910d2017-07-06 16:40:18 -0400251}
252
Chris Daltoneffee202019-07-01 22:28:03 -0600253GrStencilAttachment* GrMockGpu::createStencilAttachmentForRenderTarget(
254 const GrRenderTarget* rt, int width, int height, int numStencilSamples) {
255 SkASSERT(numStencilSamples == rt->numSamples());
Brian Salomoncfe910d2017-07-06 16:40:18 -0400256 static constexpr int kBits = 8;
257 fStats.incStencilAttachmentCreates();
Chris Dalton6ce447a2019-06-23 18:07:38 -0600258 return new GrMockStencilAttachment(this, width, height, kBits, rt->numSamples());
Brian Salomoncfe910d2017-07-06 16:40:18 -0400259}
Brian Salomon8fe24272017-07-07 12:56:11 -0400260
Robert Phillipsf0313ee2019-05-21 13:51:11 -0400261GrBackendTexture GrMockGpu::createBackendTexture(int w, int h,
262 const GrBackendFormat& format,
263 GrMipMapped mipMapped,
264 GrRenderable /* renderable */,
265 const void* /* pixels */,
Robert Phillips459b2952019-05-23 09:38:27 -0400266 size_t /* rowBytes */,
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400267 const SkColor4f* /* color */,
268 GrProtected /* isProtected */) {
Brian Salomond4764a12019-08-08 12:08:24 -0400269 auto colorType = format.asMockColorType();
Greg Daniel7bfc9132019-08-14 14:23:53 -0400270 if (!this->caps()->isFormatTexturable(format)) {
Robert Phillips9dbcdcc2019-05-13 10:40:06 -0400271 return GrBackendTexture(); // invalid
272 }
273
Brian Salomond4764a12019-08-08 12:08:24 -0400274 GrMockTextureInfo info(colorType, NextExternalTextureID());
Robert Phillips646f6372018-09-25 09:31:10 -0400275
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500276 fOutstandingTestingOnlyTextureIDs.add(info.fID);
Brian Salomon0c51eea2018-03-09 17:02:09 -0500277 return GrBackendTexture(w, h, mipMapped, info);
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500278}
279
Robert Phillipsf0313ee2019-05-21 13:51:11 -0400280void GrMockGpu::deleteBackendTexture(const GrBackendTexture& tex) {
Robert Phillipsf0ced622019-05-16 09:06:25 -0400281 SkASSERT(GrBackendApi::kMock == tex.backend());
282
283 GrMockTextureInfo info;
284 if (tex.getMockTextureInfo(&info)) {
285 fOutstandingTestingOnlyTextureIDs.remove(info.fID);
286 }
287}
288
289#if GR_TEST_UTILS
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500290bool GrMockGpu::isTestingOnlyBackendTexture(const GrBackendTexture& tex) const {
Greg Danielbdf12ad2018-10-12 09:31:11 -0400291 SkASSERT(GrBackendApi::kMock == tex.backend());
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500292
Greg Daniel52e16d92018-04-10 09:34:07 -0400293 GrMockTextureInfo info;
294 if (!tex.getMockTextureInfo(&info)) {
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500295 return false;
296 }
297
Greg Daniel52e16d92018-04-10 09:34:07 -0400298 return fOutstandingTestingOnlyTextureIDs.contains(info.fID);
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500299}
300
Brian Salomon0c51eea2018-03-09 17:02:09 -0500301GrBackendRenderTarget GrMockGpu::createTestingOnlyBackendRenderTarget(int w, int h,
Brian Osman2d010b62018-08-09 10:55:09 -0400302 GrColorType colorType) {
Greg Daniele877dce2019-07-11 10:52:43 -0400303 GrMockRenderTargetInfo info(colorType, NextExternalRenderTargetID());
Brian Salomon0c51eea2018-03-09 17:02:09 -0500304 static constexpr int kSampleCnt = 1;
305 static constexpr int kStencilBits = 8;
Robert Phillipsa5e78be2019-07-09 12:34:38 -0400306 return GrBackendRenderTarget(w, h, kSampleCnt, kStencilBits, info);
Brian Salomonf865b052018-03-09 09:01:53 -0500307}
308
309void GrMockGpu::deleteTestingOnlyBackendRenderTarget(const GrBackendRenderTarget&) {}
310#endif