blob: 9f9aebe7b08bbc6b3351b072c292e97088e9435b [file] [log] [blame]
bsalomond309e7a2015-04-30 14:18:54 -07001/*
2 * Copyright 2015 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#ifndef GrResourceProvider_DEFINED
9#define GrResourceProvider_DEFINED
10
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "include/gpu/GrContextOptions.h"
12#include "include/private/SkImageInfoPriv.h"
13#include "src/core/SkScalerContext.h"
14#include "src/gpu/GrGpuBuffer.h"
15#include "src/gpu/GrResourceCache.h"
bsalomond309e7a2015-04-30 14:18:54 -070016
Greg Danielbcf612b2017-05-01 13:50:58 +000017class GrBackendRenderTarget;
Greg Daniela5cb7812017-06-16 09:45:32 -040018class GrBackendSemaphore;
19class GrBackendTexture;
Robert Phillips009e9af2017-06-15 14:01:04 -040020class GrGpu;
bsalomon706f08f2015-05-22 07:35:58 -070021class GrPath;
egdanielec00d942015-09-14 12:56:10 -070022class GrRenderTarget;
Greg Daniel8982dc12018-01-05 12:56:15 -050023class GrResourceProviderPriv;
Robert Phillips646e4292017-06-13 12:44:56 -040024class GrSemaphore;
joshualitt6d0872d2016-01-11 08:27:48 -080025class GrSingleOwner;
egdanielec00d942015-09-14 12:56:10 -070026class GrStencilAttachment;
Robert Phillips646e4292017-06-13 12:44:56 -040027class GrTexture;
Greg Danielb46add82019-01-02 14:51:29 -050028struct GrVkDrawableInfo;
Robert Phillips646e4292017-06-13 12:44:56 -040029
bsalomon6663acf2016-05-10 09:14:17 -070030class GrStyle;
bsalomon706f08f2015-05-22 07:35:58 -070031class SkDescriptor;
32class SkPath;
33class SkTypeface;
bsalomoned0bcad2015-05-04 10:36:42 -070034
bsalomond309e7a2015-04-30 14:18:54 -070035/**
Robert Phillipsaee18c92019-09-06 11:48:27 -040036 * A factory for arbitrary resource types.
bsalomond309e7a2015-04-30 14:18:54 -070037 */
Brian Osman32342f02017-03-04 08:12:46 -050038class GrResourceProvider {
bsalomond309e7a2015-04-30 14:18:54 -070039public:
Robert Phillips12c46292019-04-23 07:36:17 -040040 GrResourceProvider(GrGpu*, GrResourceCache*, GrSingleOwner*);
bsalomoned0bcad2015-05-04 10:36:42 -070041
Brian Salomond28a79d2017-10-16 13:01:07 -040042 /**
43 * Finds a resource in the cache, based on the specified key. Prior to calling this, the caller
44 * must be sure that if a resource of exists in the cache with the given unique key then it is
45 * of type T.
46 */
Brian Salomondbf70722019-02-07 11:31:24 -050047 template <typename T = GrGpuResource>
48 typename std::enable_if<std::is_base_of<GrGpuResource, T>::value, sk_sp<T>>::type
49 findByUniqueKey(const GrUniqueKey& key) {
Brian Salomond28a79d2017-10-16 13:01:07 -040050 return sk_sp<T>(static_cast<T*>(this->findResourceByUniqueKey(key).release()));
bsalomoned0bcad2015-05-04 10:36:42 -070051 }
52
Brian Osman32342f02017-03-04 08:12:46 -050053 ///////////////////////////////////////////////////////////////////////////
54 // Textures
55
Brian Osman32342f02017-03-04 08:12:46 -050056 /**
57 * Finds a texture that approximately matches the descriptor. Will be at least as large in width
Brian Salomonf2c2ba92019-07-17 09:59:59 -040058 * and height as desc specifies. If renderable is kYes then the GrTexture will also be a
59 * GrRenderTarget. The texture's format and sample count will always match the request.
Robert Phillips67d52cf2017-06-05 13:38:13 -040060 * The contents of the texture are undefined.
Brian Osman32342f02017-03-04 08:12:46 -050061 */
Brian Salomon4eb38b72019-08-05 12:58:39 -040062 sk_sp<GrTexture> createApproxTexture(const GrSurfaceDesc& desc,
63 const GrBackendFormat& format,
64 GrRenderable renderable,
65 int renderTargetSampleCnt,
Robert Phillipsaee18c92019-09-06 11:48:27 -040066 GrProtected isProtected);
Brian Osman32342f02017-03-04 08:12:46 -050067
Brian Salomonf2c2ba92019-07-17 09:59:59 -040068 /** Create an exact fit texture with no initial data to upload. */
Brian Salomon4eb38b72019-08-05 12:58:39 -040069 sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc,
70 const GrBackendFormat& format,
71 GrRenderable renderable,
72 int renderTargetSampleCnt,
Brian Salomona90382f2019-09-17 09:01:56 -040073 GrMipMapped mipMapped,
Brian Salomon4eb38b72019-08-05 12:58:39 -040074 SkBudgeted budgeted,
Robert Phillipsaee18c92019-09-06 11:48:27 -040075 GrProtected isProtected);
Brian Salomonf2c2ba92019-07-17 09:59:59 -040076
Brian Salomona90382f2019-09-17 09:01:56 -040077 /**
78 * Create an exact fit texture with initial data to upload. The color type must be valid
79 * for the format and also describe the texel data. This will ensure any conversions that
80 * need to get applied to the data before upload are applied.
81 */
Brian Salomon4eb38b72019-08-05 12:58:39 -040082 sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc,
83 const GrBackendFormat& format,
Brian Salomona90382f2019-09-17 09:01:56 -040084 GrColorType colorType,
Brian Salomon4eb38b72019-08-05 12:58:39 -040085 GrRenderable renderable,
86 int renderTargetSampleCnt,
87 SkBudgeted budgeted,
88 GrProtected isProtected,
89 const GrMipLevel texels[],
Brian Salomon27b4d8d2019-07-22 14:23:45 -040090 int mipLevelCount);
Brian Salomonf2c2ba92019-07-17 09:59:59 -040091
Brian Salomona90382f2019-09-17 09:01:56 -040092 /**
93 * Create a potentially loose fit texture with the provided data. The color type must be valid
94 * for the format and also describe the texel data. This will ensure any conversions that
95 * need to get applied to the data before upload are applied.
96 */
Brian Salomon4eb38b72019-08-05 12:58:39 -040097 sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc,
98 const GrBackendFormat& format,
Brian Salomona90382f2019-09-17 09:01:56 -040099 GrColorType srcColorType,
Brian Salomon4eb38b72019-08-05 12:58:39 -0400100 GrRenderable renderable,
101 int renderTargetSampleCnt,
102 SkBudgeted budgeted,
103 SkBackingFit fit,
104 GrProtected isProtected,
Robert Phillipsaee18c92019-09-06 11:48:27 -0400105 const GrMipLevel& mipLevel);
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400106
107 /**
108 * Creates a compressed texture. The GrGpu must support the SkImageImage::Compression type.
109 * This does not currently support MIP maps. It will not be renderable.
Robert Phillipse78b7252017-04-06 07:59:41 -0400110 */
Greg Daniel7bfc9132019-08-14 14:23:53 -0400111 sk_sp<GrTexture> createCompressedTexture(int width, int height, const GrBackendFormat&,
112 SkImage::CompressionType, SkBudgeted, SkData* data);
Brian Salomonbb8dde82019-06-27 10:52:13 -0400113
Brian Osman32342f02017-03-04 08:12:46 -0500114 ///////////////////////////////////////////////////////////////////////////
115 // Wrapped Backend Surfaces
116
117 /**
118 * Wraps an existing texture with a GrTexture object.
119 *
Brian Salomonc67c31c2018-12-06 10:00:03 -0500120 * GrIOType must either be kRead or kRW. kRead blocks any operations that would modify the
121 * pixels (e.g. dst for a copy, regenerating MIP levels, write pixels).
122 *
Brian Osman32342f02017-03-04 08:12:46 -0500123 * OpenGL: if the object is a texture Gr may change its GL texture params
124 * when it is drawn.
125 *
126 * @return GrTexture object or NULL on failure.
127 */
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400128 sk_sp<GrTexture> wrapBackendTexture(const GrBackendTexture& tex, GrColorType, GrWrapOwnership,
Brian Salomonaa6ca0a2019-01-24 16:03:07 -0500129 GrWrapCacheable, GrIOType);
Brian Osman32342f02017-03-04 08:12:46 -0500130
131 /**
Brian Salomonbdecacf2018-02-02 20:32:49 -0500132 * This makes the backend texture be renderable. If sampleCnt is > 1 and the underlying API
Brian Salomond17f6582017-07-19 18:28:58 -0400133 * uses separate MSAA render buffers then a MSAA render buffer is created that resolves
134 * to the texture.
135 */
136 sk_sp<GrTexture> wrapRenderableBackendTexture(const GrBackendTexture& tex,
Brian Salomond17f6582017-07-19 18:28:58 -0400137 int sampleCnt,
Robert Phillips0902c982019-07-16 07:47:56 -0400138 GrColorType,
Brian Salomonaa6ca0a2019-01-24 16:03:07 -0500139 GrWrapOwnership,
140 GrWrapCacheable);
Brian Salomond17f6582017-07-19 18:28:58 -0400141
142 /**
Brian Osman32342f02017-03-04 08:12:46 -0500143 * Wraps an existing render target with a GrRenderTarget object. It is
144 * similar to wrapBackendTexture but can be used to draw into surfaces
145 * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
146 * the client will resolve to a texture). Currently wrapped render targets
Brian Salomonaa6ca0a2019-01-24 16:03:07 -0500147 * always use the kBorrow_GrWrapOwnership and GrWrapCacheable::kNo semantics.
Brian Osman32342f02017-03-04 08:12:46 -0500148 *
149 * @return GrRenderTarget object or NULL on failure.
150 */
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400151 sk_sp<GrRenderTarget> wrapBackendRenderTarget(const GrBackendRenderTarget&,
152 GrColorType colorType);
Brian Osman32342f02017-03-04 08:12:46 -0500153
Greg Danielb46add82019-01-02 14:51:29 -0500154 sk_sp<GrRenderTarget> wrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo&,
155 const GrVkDrawableInfo&);
156
Robert Phillips1bfece82017-06-01 13:56:52 -0400157 static const uint32_t kMinScratchTextureSize;
Brian Osman32342f02017-03-04 08:12:46 -0500158
bsalomoned0bcad2015-05-04 10:36:42 -0700159 /**
Chris Dalton5d2de082017-12-19 10:40:23 -0700160 * Either finds and refs, or creates a static buffer with the given parameters and contents.
161 *
162 * @param intendedType hint to the graphics subsystem about what the buffer will be used for.
163 * @param size minimum size of buffer to return.
164 * @param data optional data with which to initialize the buffer.
165 * @param key Key to be assigned to the buffer.
166 *
167 * @return The buffer if successful, otherwise nullptr.
168 */
Brian Salomondbf70722019-02-07 11:31:24 -0500169 sk_sp<const GrGpuBuffer> findOrMakeStaticBuffer(GrGpuBufferType intendedType, size_t size,
170 const void* data, const GrUniqueKey& key);
Chris Dalton5d2de082017-12-19 10:40:23 -0700171
172 /**
Chris Daltonff926502017-05-03 14:36:54 -0400173 * Either finds and refs, or creates an index buffer with a repeating pattern for drawing
174 * contiguous vertices of a repeated mesh. If the return is non-null, the caller owns a ref on
175 * the returned GrBuffer.
bsalomoned0bcad2015-05-04 10:36:42 -0700176 *
177 * @param pattern the pattern of indices to repeat
178 * @param patternSize size in bytes of the pattern
179 * @param reps number of times to repeat the pattern
180 * @param vertCount number of vertices the pattern references
181 * @param key Key to be assigned to the index buffer.
182 *
halcanary96fcdcc2015-08-27 07:41:13 -0700183 * @return The index buffer if successful, otherwise nullptr.
bsalomoned0bcad2015-05-04 10:36:42 -0700184 */
Brian Salomondbf70722019-02-07 11:31:24 -0500185 sk_sp<const GrGpuBuffer> findOrCreatePatternedIndexBuffer(const uint16_t* pattern,
186 int patternSize,
187 int reps,
188 int vertCount,
189 const GrUniqueKey& key) {
Brian Salomona29dd9d2019-02-07 13:27:18 -0500190 if (auto buffer = this->findByUniqueKey<const GrGpuBuffer>(key)) {
191 return buffer;
bsalomoned0bcad2015-05-04 10:36:42 -0700192 }
Brian Salomona29dd9d2019-02-07 13:27:18 -0500193 return this->createPatternedIndexBuffer(pattern, patternSize, reps, vertCount, &key);
bsalomoned0bcad2015-05-04 10:36:42 -0700194 }
195
196 /**
197 * Returns an index buffer that can be used to render quads.
Brian Salomon57caa662017-10-18 12:21:05 +0000198 * Six indices per quad: 0, 1, 2, 2, 1, 3, etc.
Brian Salomon763abf02018-05-01 18:49:38 +0000199 * The max number of quads is the buffer's index capacity divided by 6.
Chris Dalton3809bab2017-06-13 10:55:06 -0600200 * Draw with GrPrimitiveType::kTriangles
Brian Salomon763abf02018-05-01 18:49:38 +0000201 * @ return the quad index buffer
bsalomoned0bcad2015-05-04 10:36:42 -0700202 */
Brian Salomondbf70722019-02-07 11:31:24 -0500203 sk_sp<const GrGpuBuffer> refQuadIndexBuffer() {
Brian Salomona29dd9d2019-02-07 13:27:18 -0500204 if (!fQuadIndexBuffer) {
205 fQuadIndexBuffer = this->createQuadIndexBuffer();
bsalomoned0bcad2015-05-04 10:36:42 -0700206 }
Brian Salomona29dd9d2019-02-07 13:27:18 -0500207 return fQuadIndexBuffer;
bsalomoned0bcad2015-05-04 10:36:42 -0700208 }
209
Brian Salomon34169692017-08-28 15:32:01 -0400210 static int QuadCountOfQuadBuffer();
211
bsalomon706f08f2015-05-22 07:35:58 -0700212 /**
Ben Wagner3746ac22018-03-29 11:46:24 -0400213 * Factories for GrPath objects. It's an error to call these if path rendering
bsalomon706f08f2015-05-22 07:35:58 -0700214 * is not supported.
215 */
Robert Phillips67d52cf2017-06-05 13:38:13 -0400216 sk_sp<GrPath> createPath(const SkPath&, const GrStyle&);
bsalomon706f08f2015-05-22 07:35:58 -0700217
cdaltone2e71c22016-04-07 18:13:29 -0700218 /**
219 * Returns a buffer.
220 *
221 * @param size minimum size of buffer to return.
222 * @param intendedType hint to the graphics subsystem about what the buffer will be used for.
223 * @param GrAccessPattern hint to the graphics subsystem about how the data will be accessed.
224 * @param flags see Flags enum.
cdalton1bf3e712016-04-19 10:00:02 -0700225 * @param data optional data with which to initialize the buffer.
cdaltone2e71c22016-04-07 18:13:29 -0700226 *
227 * @return the buffer if successful, otherwise nullptr.
228 */
Brian Salomondbf70722019-02-07 11:31:24 -0500229 sk_sp<GrGpuBuffer> createBuffer(size_t size, GrGpuBufferType intendedType, GrAccessPattern,
230 const void* data = nullptr);
robertphillips1b8e1b52015-06-24 06:54:10 -0700231
Brian Salomon2ee084e2016-12-16 18:59:19 -0500232 /**
Chris Daltoneffee202019-07-01 22:28:03 -0600233 * If passed in render target already has a stencil buffer with at least "numSamples" samples,
234 * return true. Otherwise attempt to attach one and return true on success.
egdanielec00d942015-09-14 12:56:10 -0700235 */
Chris Daltoneffee202019-07-01 22:28:03 -0600236 bool attachStencilAttachment(GrRenderTarget* rt, int numStencilSamples);
egdanielec00d942015-09-14 12:56:10 -0700237
ericrkf7b8b8a2016-02-24 14:49:51 -0800238 /**
239 * Wraps an existing texture with a GrRenderTarget object. This is useful when the provided
240 * texture has a format that cannot be textured from by Skia, but we want to raster to it.
241 *
kkinnunen49c4c222016-04-01 04:50:37 -0700242 * The texture is wrapped as borrowed. The texture object will not be freed once the
243 * render target is destroyed.
244 *
ericrkf7b8b8a2016-02-24 14:49:51 -0800245 * @return GrRenderTarget object or NULL on failure.
246 */
Greg Daniel7ef28f32017-04-20 16:41:55 +0000247 sk_sp<GrRenderTarget> wrapBackendTextureAsRenderTarget(const GrBackendTexture&,
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400248 int sampleCnt,
249 GrColorType);
ericrkf7b8b8a2016-02-24 14:49:51 -0800250
Brian Osman32342f02017-03-04 08:12:46 -0500251 /**
252 * Assigns a unique key to a resource. If the key is associated with another resource that
253 * association is removed and replaced by this resource.
254 */
255 void assignUniqueKeyToResource(const GrUniqueKey&, GrGpuResource*);
256
Greg Daniela5cb7812017-06-16 09:45:32 -0400257 sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT makeSemaphore(bool isOwned = true);
258
Greg Daniel17b7c052018-01-09 13:55:33 -0500259 enum class SemaphoreWrapType {
260 kWillSignal,
261 kWillWait,
262 };
263
Greg Daniela5cb7812017-06-16 09:45:32 -0400264 sk_sp<GrSemaphore> wrapBackendSemaphore(const GrBackendSemaphore&,
Greg Daniel17b7c052018-01-09 13:55:33 -0500265 SemaphoreWrapType wrapType,
Greg Daniela5cb7812017-06-16 09:45:32 -0400266 GrWrapOwnership = kBorrow_GrWrapOwnership);
Greg Danield85f97d2017-03-07 13:37:21 -0500267
Brian Osman32342f02017-03-04 08:12:46 -0500268 void abandon() {
Robert Phillips26c90e02017-03-14 14:39:29 -0400269 fCache = nullptr;
270 fGpu = nullptr;
Brian Osman32342f02017-03-04 08:12:46 -0500271 }
272
Brian Salomon238069b2018-07-11 15:58:57 -0400273 uint32_t contextUniqueID() const { return fCache->contextUniqueID(); }
Robert Phillips26c90e02017-03-14 14:39:29 -0400274 const GrCaps* caps() const { return fCaps.get(); }
Robert Phillipseafd48a2017-11-16 07:52:08 -0500275 bool overBudget() const { return fCache->overBudget(); }
Robert Phillips26c90e02017-03-14 14:39:29 -0400276
Robert Phillipsf9fcf7f2019-07-11 09:03:27 -0400277 static uint32_t MakeApprox(uint32_t value);
278
Greg Daniel8982dc12018-01-05 12:56:15 -0500279 inline GrResourceProviderPriv priv();
280 inline const GrResourceProviderPriv priv() const;
281
bsalomoned0bcad2015-05-04 10:36:42 -0700282private:
Brian Salomond28a79d2017-10-16 13:01:07 -0400283 sk_sp<GrGpuResource> findResourceByUniqueKey(const GrUniqueKey&);
Robert Phillips3798c862017-03-27 11:08:16 -0400284
Greg Daniel29bf84f2017-09-25 12:25:12 -0400285 // Attempts to find a resource in the cache that exactly matches the GrSurfaceDesc. Failing that
286 // it returns null. If non-null, the resulting texture is always budgeted.
Brian Salomon14cb4132019-09-16 13:14:47 -0400287 sk_sp<GrTexture> refScratchTexture(const GrSurfaceDesc&,
288 const GrBackendFormat&,
289 GrRenderable,
Brian Salomon4eb38b72019-08-05 12:58:39 -0400290 int renderTargetSampleCnt,
Brian Salomon14cb4132019-09-16 13:14:47 -0400291 GrMipMapped,
292 GrProtected);
Brian Osman32342f02017-03-04 08:12:46 -0500293
Robert Phillips45fdae12017-04-17 12:57:27 -0400294 /*
295 * Try to find an existing scratch texture that exactly matches 'desc'. If successful
296 * update the budgeting accordingly.
297 */
Brian Salomon14cb4132019-09-16 13:14:47 -0400298 sk_sp<GrTexture> getExactScratch(const GrSurfaceDesc&,
299 const GrBackendFormat&,
300 GrRenderable,
Brian Salomon4eb38b72019-08-05 12:58:39 -0400301 int renderTargetSampleCnt,
Brian Salomon14cb4132019-09-16 13:14:47 -0400302 SkBudgeted,
303 GrMipMapped,
304 GrProtected);
Robert Phillips45fdae12017-04-17 12:57:27 -0400305
Brian Osman32342f02017-03-04 08:12:46 -0500306 GrResourceCache* cache() { return fCache; }
307 const GrResourceCache* cache() const { return fCache; }
308
Greg Daniel8982dc12018-01-05 12:56:15 -0500309 friend class GrResourceProviderPriv;
310
311 // Method made available via GrResourceProviderPriv
Brian Osman32342f02017-03-04 08:12:46 -0500312 GrGpu* gpu() { return fGpu; }
313 const GrGpu* gpu() const { return fGpu; }
314
315 bool isAbandoned() const {
316 SkASSERT(SkToBool(fGpu) == SkToBool(fCache));
317 return !SkToBool(fCache);
318 }
319
Brian Salomondbf70722019-02-07 11:31:24 -0500320 sk_sp<const GrGpuBuffer> createPatternedIndexBuffer(const uint16_t* pattern,
321 int patternSize,
322 int reps,
323 int vertCount,
Brian Salomona29dd9d2019-02-07 13:27:18 -0500324 const GrUniqueKey* key);
bsalomoned0bcad2015-05-04 10:36:42 -0700325
Brian Salomondbf70722019-02-07 11:31:24 -0500326 sk_sp<const GrGpuBuffer> createQuadIndexBuffer();
bsalomoned0bcad2015-05-04 10:36:42 -0700327
Brian Salomona29dd9d2019-02-07 13:27:18 -0500328 GrResourceCache* fCache;
329 GrGpu* fGpu;
Robert Phillips26c90e02017-03-14 14:39:29 -0400330 sk_sp<const GrCaps> fCaps;
Brian Salomona29dd9d2019-02-07 13:27:18 -0500331 sk_sp<const GrGpuBuffer> fQuadIndexBuffer;
bsalomoned0bcad2015-05-04 10:36:42 -0700332
Brian Osman32342f02017-03-04 08:12:46 -0500333 // In debug builds we guard against improper thread handling
334 SkDEBUGCODE(mutable GrSingleOwner* fSingleOwner;)
bsalomond309e7a2015-04-30 14:18:54 -0700335};
336
bsalomond309e7a2015-04-30 14:18:54 -0700337#endif