blob: 414d2fac911a3c36e897264fe44d8f547f507856 [file] [log] [blame]
bsalomon@google.com27847de2011-02-22 20:59:41 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2010 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.
bsalomon@google.com27847de2011-02-22 20:59:41 +00006 */
7
8#ifndef GrContext_DEFINED
9#define GrContext_DEFINED
10
bsalomon@google.com288d9542012-10-17 12:53:54 +000011#include "GrColor.h"
robertphillips@google.comf6747b02012-06-12 00:32:28 +000012#include "GrAARectRenderer.h"
robertphillips@google.coma2d71482012-08-01 20:08:47 +000013#include "GrClipData.h"
bsalomon@google.comb9086a02012-11-01 18:02:54 +000014#include "SkMatrix.h"
bsalomon@google.com288d9542012-10-17 12:53:54 +000015#include "GrPaint.h"
bsalomon@google.com45a15f52012-12-10 19:10:17 +000016#include "GrPathRendererChain.h"
commit-bot@chromium.orgfd03d4a2013-07-17 21:39:42 +000017#include "GrPoint.h"
rmistry@google.comfbfcd562012-08-23 18:09:54 +000018#include "GrRenderTarget.h"
bsalomon@google.com288d9542012-10-17 12:53:54 +000019#include "GrRefCnt.h"
20#include "GrTexture.h"
bsalomon@google.com27847de2011-02-22 20:59:41 +000021
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +000022class GrAutoScratchTexture;
bsalomon@google.com10e04bf2012-03-30 14:35:04 +000023class GrDrawState;
bsalomon@google.com583a1e32011-08-17 13:42:46 +000024class GrDrawTarget;
bsalomon@google.coma469c282012-10-24 18:28:34 +000025class GrEffect;
bsalomon@google.com27847de2011-02-22 20:59:41 +000026class GrFontCache;
bsalomon@google.com05ef5102011-05-02 21:14:59 +000027class GrGpu;
bsalomon@google.com583a1e32011-08-17 13:42:46 +000028class GrIndexBuffer;
bsalomon@google.com27847de2011-02-22 20:59:41 +000029class GrIndexBufferAllocPool;
30class GrInOrderDrawBuffer;
commit-bot@chromium.org81312832013-03-22 18:34:09 +000031class GrOvalRenderer;
bsalomon@google.com583a1e32011-08-17 13:42:46 +000032class GrPathRenderer;
bsalomon@google.com50398bf2011-07-26 20:45:30 +000033class GrResourceEntry;
34class GrResourceCache;
bsalomon@google.com558a75b2011-08-08 17:01:14 +000035class GrStencilBuffer;
bsalomon@google.com288d9542012-10-17 12:53:54 +000036class GrTextureParams;
bsalomon@google.com583a1e32011-08-17 13:42:46 +000037class GrVertexBuffer;
bsalomon@google.com50398bf2011-07-26 20:45:30 +000038class GrVertexBufferAllocPool;
robertphillips@google.com72176b22012-05-23 13:19:12 +000039class GrSoftwarePathRenderer;
sugoi@google.com5f74cf82012-12-17 21:16:45 +000040class SkStrokeRec;
bsalomon@google.com50398bf2011-07-26 20:45:30 +000041
bsalomon@google.com91826102011-03-21 19:51:57 +000042class GR_API GrContext : public GrRefCnt {
bsalomon@google.com27847de2011-02-22 20:59:41 +000043public:
reed@google.comfa35e3d2012-06-26 20:16:17 +000044 SK_DECLARE_INST_COUNT(GrContext)
45
bsalomon@google.com27847de2011-02-22 20:59:41 +000046 /**
bsalomon@google.com16e3dde2012-10-25 18:43:28 +000047 * Creates a GrContext for a backend context.
bsalomon@google.com27847de2011-02-22 20:59:41 +000048 */
bsalomon@google.com16e3dde2012-10-25 18:43:28 +000049 static GrContext* Create(GrBackend, GrBackendContext);
bsalomon@google.com27847de2011-02-22 20:59:41 +000050
bsalomon@google.comc0af3172012-06-15 14:10:09 +000051 /**
52 * Returns the number of GrContext instances for the current thread.
53 */
54 static int GetThreadInstanceCount();
55
bsalomon@google.com27847de2011-02-22 20:59:41 +000056 virtual ~GrContext();
57
58 /**
59 * The GrContext normally assumes that no outsider is setting state
60 * within the underlying 3D API's context/device/whatever. This call informs
61 * the context that the state was modified and it should resend. Shouldn't
62 * be called frequently for good performance.
bsalomon@google.com0a208a12013-06-28 18:57:35 +000063 * The flag bits, state, is dpendent on which backend is used by the
64 * context, either GL or D3D (possible in future).
bsalomon@google.com27847de2011-02-22 20:59:41 +000065 */
bsalomon@google.com0a208a12013-06-28 18:57:35 +000066 void resetContext(uint32_t state = kAll_GrBackendState);
bsalomon@google.com27847de2011-02-22 20:59:41 +000067
bsalomon@google.com8fe72472011-03-30 21:26:44 +000068 /**
robertphillips@google.comcdb426d2012-09-24 19:33:59 +000069 * Callback function to allow classes to cleanup on GrContext destruction.
70 * The 'info' field is filled in with the 'info' passed to addCleanUp.
71 */
72 typedef void (*PFCleanUpFunc)(const GrContext* context, void* info);
73
74 /**
75 * Add a function to be called from within GrContext's destructor.
76 * This gives classes a chance to free resources held on a per context basis.
77 * The 'info' parameter will be stored and passed to the callback function.
78 */
79 void addCleanUp(PFCleanUpFunc cleanUp, void* info) {
80 CleanUpData* entry = fCleanUpData.push();
81
82 entry->fFunc = cleanUp;
83 entry->fInfo = info;
84 }
85
86 /**
bsalomon@google.com1e269b52012-10-15 14:25:31 +000087 * Abandons all GPU resources, assumes 3D API state is unknown. Call this
bsalomon@google.com8fe72472011-03-30 21:26:44 +000088 * if you have lost the associated GPU context, and thus internal texture,
89 * buffer, etc. references/IDs are now invalid. Should be called even when
90 * GrContext is no longer going to be used for two reasons:
91 * 1) ~GrContext will not try to free the objects in the 3D API.
92 * 2) If you've created GrResources that outlive the GrContext they will
93 * be marked as invalid (GrResource::isValid()) and won't attempt to
94 * free their underlying resource in the 3D API.
95 * Content drawn since the last GrContext::flush() may be lost.
96 */
97 void contextLost();
bsalomon@google.com27847de2011-02-22 20:59:41 +000098
99 /**
junov@google.com53a55842011-06-08 22:55:10 +0000100 * Similar to contextLost, but makes no attempt to reset state.
101 * Use this method when GrContext destruction is pending, but
102 * the graphics context is destroyed first.
103 */
104 void contextDestroyed();
105
106 /**
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000107 * Frees GPU created by the context. Can be called to reduce GPU memory
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000108 * pressure.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000109 */
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000110 void freeGpuResources();
111
bsalomon@google.com07fc0d12012-06-22 15:15:59 +0000112 /**
113 * Returns the number of bytes of GPU memory hosted by the texture cache.
114 */
115 size_t getGpuTextureCacheBytes() const;
116
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000117 ///////////////////////////////////////////////////////////////////////////
118 // Textures
bsalomon@google.com27847de2011-02-22 20:59:41 +0000119
120 /**
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000121 * Creates a new entry, based on the specified key and texture and returns it. The caller owns a
122 * ref on the returned texture which must be balanced by a call to unref.
bsalomon@google.com1fadb202011-12-12 16:10:08 +0000123 *
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000124 * @param params The texture params used to draw a texture may help determine
bsalomon@google.comb8670992012-07-25 21:27:09 +0000125 * the cache entry used. (e.g. different versions may exist
126 * for different wrap modes on GPUs with limited NPOT
127 * texture support). NULL implies clamp wrap modes.
bsalomon@google.com1fadb202011-12-12 16:10:08 +0000128 * @param desc Description of the texture properties.
bsalomon@google.com0797c2c2012-12-20 15:13:01 +0000129 * @param cacheID Cache-specific properties (e.g., texture gen ID)
bsalomon@google.com1fadb202011-12-12 16:10:08 +0000130 * @param srcData Pointer to the pixel values.
131 * @param rowBytes The number of bytes between rows of the texture. Zero
132 * implies tightly packed rows.
133 */
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000134 GrTexture* createTexture(const GrTextureParams* params,
135 const GrTextureDesc& desc,
bsalomon@google.com0797c2c2012-12-20 15:13:01 +0000136 const GrCacheID& cacheID,
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000137 void* srcData, size_t rowBytes);
bsalomon@google.com1fadb202011-12-12 16:10:08 +0000138
139 /**
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000140 * Search for an entry based on key and dimensions. If found, ref it and return it. The return
141 * value will be NULL if not found. The caller must balance with a call to unref.
bsalomon@google.com1fadb202011-12-12 16:10:08 +0000142 *
bsalomon@google.comb8670992012-07-25 21:27:09 +0000143 * @param desc Description of the texture properties.
bsalomon@google.com0797c2c2012-12-20 15:13:01 +0000144 * @param cacheID Cache-specific properties (e.g., texture gen ID)
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000145 * @param params The texture params used to draw a texture may help determine
bsalomon@google.comb8670992012-07-25 21:27:09 +0000146 * the cache entry used. (e.g. different versions may exist
147 * for different wrap modes on GPUs with limited NPOT
148 * texture support). NULL implies clamp wrap modes.
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000149 */
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000150 GrTexture* findAndRefTexture(const GrTextureDesc& desc,
151 const GrCacheID& cacheID,
152 const GrTextureParams* params);
bsalomon@google.comfb309512011-11-30 14:13:48 +0000153 /**
154 * Determines whether a texture is in the cache. If the texture is found it
155 * will not be locked or returned. This call does not affect the priority of
156 * the texture for deletion.
157 */
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000158 bool isTextureInCache(const GrTextureDesc& desc,
bsalomon@google.com0797c2c2012-12-20 15:13:01 +0000159 const GrCacheID& cacheID,
bsalomon@google.comb8670992012-07-25 21:27:09 +0000160 const GrTextureParams* params) const;
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000161
162 /**
163 * Enum that determines how closely a returned scratch texture must match
164 * a provided GrTextureDesc.
165 */
166 enum ScratchTexMatch {
167 /**
168 * Finds a texture that exactly matches the descriptor.
169 */
170 kExact_ScratchTexMatch,
171 /**
172 * Finds a texture that approximately matches the descriptor. Will be
173 * at least as large in width and height as desc specifies. If desc
174 * specifies that texture is a render target then result will be a
175 * render target. If desc specifies a render target and doesn't set the
176 * no stencil flag then result will have a stencil. Format and aa level
177 * will always match.
178 */
179 kApprox_ScratchTexMatch
180 };
bsalomon@google.com27847de2011-02-22 20:59:41 +0000181
182 /**
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000183 * Returns a texture matching the desc. It's contents are unknown. Subsequent
184 * requests with the same descriptor are not guaranteed to return the same
185 * texture. The same texture is guaranteed not be returned again until it is
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000186 * unlocked. Call must be balanced with an unlockTexture() call. The caller
187 * owns a ref on the returned texture and must balance with a call to unref.
bsalomon@google.coma39f4042011-04-26 13:18:16 +0000188 *
189 * Textures created by createAndLockTexture() hide the complications of
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000190 * tiling non-power-of-two textures on APIs that don't support this (e.g.
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000191 * unextended GLES2). Tiling a NPOT texture created by lockScratchTexture on
bsalomon@google.coma39f4042011-04-26 13:18:16 +0000192 * such an API will create gaps in the tiling pattern. This includes clamp
193 * mode. (This may be addressed in a future update.)
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000194 */
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000195 GrTexture* lockAndRefScratchTexture(const GrTextureDesc&, ScratchTexMatch match);
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000196
197 /**
bsalomon@google.com0797c2c2012-12-20 15:13:01 +0000198 * When done with an entry, call unlockScratchTexture(entry) on it, which returns
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000199 * it to the cache, where it may be purged. This does not unref the texture.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000200 */
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000201 void unlockScratchTexture(GrTexture* texture);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000202
203 /**
robertphillips@google.com50a035d2012-09-07 19:44:33 +0000204 * This method should be called whenever a GrTexture is unreffed or
205 * switched from exclusive to non-exclusive. This
206 * gives the resource cache a chance to discard unneeded textures.
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000207 * Note: this entry point will be removed once totally ref-driven
208 * cache maintenance is implemented
robertphillips@google.com50a035d2012-09-07 19:44:33 +0000209 */
210 void purgeCache();
211
212 /**
bsalomon@google.com27847de2011-02-22 20:59:41 +0000213 * Creates a texture that is outside the cache. Does not count against
214 * cache's budget.
215 */
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000216 GrTexture* createUncachedTexture(const GrTextureDesc& desc,
bsalomon@google.com27847de2011-02-22 20:59:41 +0000217 void* srcData,
218 size_t rowBytes);
219
220 /**
bsalomon@google.comb8670992012-07-25 21:27:09 +0000221 * Returns true if the specified use of an indexed texture is supported.
222 * Support may depend upon whether the texture params indicate that the
223 * texture will be tiled. Passing NULL for the texture params indicates
224 * clamp mode.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000225 */
bsalomon@google.comb8670992012-07-25 21:27:09 +0000226 bool supportsIndex8PixelConfig(const GrTextureParams*,
bsalomon@google.com1f221a72011-08-23 20:54:07 +0000227 int width,
228 int height) const;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000229
230 /**
bsalomon@google.com07fc0d12012-06-22 15:15:59 +0000231 * Return the current texture cache limits.
232 *
233 * @param maxTextures If non-null, returns maximum number of textures that
234 * can be held in the cache.
235 * @param maxTextureBytes If non-null, returns maximum number of bytes of
236 * texture memory that can be held in the cache.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000237 */
bsalomon@google.com07fc0d12012-06-22 15:15:59 +0000238 void getTextureCacheLimits(int* maxTextures, size_t* maxTextureBytes) const;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000239
240 /**
bsalomon@google.com07fc0d12012-06-22 15:15:59 +0000241 * Specify the texture cache limits. If the current cache exceeds either
242 * of these, it will be purged (LRU) to keep the cache within these limits.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000243 *
bsalomon@google.com07fc0d12012-06-22 15:15:59 +0000244 * @param maxTextures The maximum number of textures that can be held in
245 * the cache.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000246 * @param maxTextureBytes The maximum number of bytes of texture memory
247 * that can be held in the cache.
248 */
bsalomon@google.com07fc0d12012-06-22 15:15:59 +0000249 void setTextureCacheLimits(int maxTextures, size_t maxTextureBytes);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000250
251 /**
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000252 * Return the max width or height of a texture supported by the current GPU.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000253 */
bsalomon@google.com91958362011-06-13 17:58:13 +0000254 int getMaxTextureSize() const;
255
robertphillips@google.com44a91dc2013-07-25 15:32:06 +0000256 /**
skia.committer@gmail.com956b3102013-07-26 07:00:58 +0000257 * Temporarily override the true max texture size. Note: an override
robertphillips@google.com44a91dc2013-07-25 15:32:06 +0000258 * larger then the true max texture size will have no effect.
259 * This entry point is mainly meant for testing texture size dependent
260 * features and is only available if defined outside of Skia (see
261 * bleed GM.
262 */
263 void setMaxTextureSizeOverride(int maxTextureSizeOverride);
264
bsalomon@google.com27847de2011-02-22 20:59:41 +0000265 ///////////////////////////////////////////////////////////////////////////
266 // Render targets
267
268 /**
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000269 * Sets the render target.
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000270 * @param target the render target to set.
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000271 */
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000272 void setRenderTarget(GrRenderTarget* target) {
273 fRenderTarget.reset(SkSafeRef(target));
274 }
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000275
276 /**
277 * Gets the current render target.
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000278 * @return the currently bound render target.
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000279 */
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000280 const GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
281 GrRenderTarget* getRenderTarget() { return fRenderTarget.get(); }
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000282
robertphillips@google.comf69a11b2012-06-15 13:58:07 +0000283 GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
284
robertphillips@google.com99a5ac02012-04-10 19:26:38 +0000285 /**
286 * Can the provided configuration act as a color render target?
287 */
288 bool isConfigRenderable(GrPixelConfig config) const;
289
bsalomon@google.com8a70eef2013-03-19 13:58:55 +0000290 /**
291 * Return the max width or height of a render target supported by the
292 * current GPU.
293 */
294 int getMaxRenderTargetSize() const;
295
296 /**
297 * Returns the max sample count for a render target. It will be 0 if MSAA
298 * is not supported.
299 */
300 int getMaxSampleCount() const;
301
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000302 ///////////////////////////////////////////////////////////////////////////
bsalomon@google.com16e3dde2012-10-25 18:43:28 +0000303 // Backend Surfaces
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000304
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000305 /**
bsalomon@google.come269f212011-11-07 13:29:52 +0000306 * Wraps an existing texture with a GrTexture object.
307 *
308 * OpenGL: if the object is a texture Gr may change its GL texture params
309 * when it is drawn.
310 *
311 * @param desc description of the object to create.
312 *
313 * @return GrTexture object or NULL on failure.
314 */
bsalomon@google.com16e3dde2012-10-25 18:43:28 +0000315 GrTexture* wrapBackendTexture(const GrBackendTextureDesc& desc);
bsalomon@google.come269f212011-11-07 13:29:52 +0000316
317 /**
318 * Wraps an existing render target with a GrRenderTarget object. It is
bsalomon@google.com16e3dde2012-10-25 18:43:28 +0000319 * similar to wrapBackendTexture but can be used to draw into surfaces
bsalomon@google.come269f212011-11-07 13:29:52 +0000320 * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
321 * the client will resolve to a texture).
322 *
323 * @param desc description of the object to create.
324 *
325 * @return GrTexture object or NULL on failure.
326 */
bsalomon@google.com16e3dde2012-10-25 18:43:28 +0000327 GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
bsalomon@google.come269f212011-11-07 13:29:52 +0000328
bsalomon@google.com27847de2011-02-22 20:59:41 +0000329 ///////////////////////////////////////////////////////////////////////////
330 // Matrix state
331
332 /**
333 * Gets the current transformation matrix.
334 * @return the current matrix.
335 */
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000336 const SkMatrix& getMatrix() const { return fViewMatrix; }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000337
338 /**
339 * Sets the transformation matrix.
340 * @param m the matrix to set.
341 */
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000342 void setMatrix(const SkMatrix& m) { fViewMatrix = m; }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000343
344 /**
bsalomon@google.com0f11e1a2012-10-08 14:48:36 +0000345 * Sets the current transformation matrix to identity.
346 */
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000347 void setIdentityMatrix() { fViewMatrix.reset(); }
bsalomon@google.com0f11e1a2012-10-08 14:48:36 +0000348
349 /**
bsalomon@google.com27847de2011-02-22 20:59:41 +0000350 * Concats the current matrix. The passed matrix is applied before the
351 * current matrix.
352 * @param m the matrix to concat.
353 */
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000354 void concatMatrix(const SkMatrix& m) { fViewMatrix.preConcat(m); }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000355
356
357 ///////////////////////////////////////////////////////////////////////////
358 // Clip state
359 /**
360 * Gets the current clip.
361 * @return the current clip.
362 */
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000363 const GrClipData* getClip() const { return fClip; }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000364
365 /**
366 * Sets the clip.
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000367 * @param clipData the clip to set.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000368 */
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000369 void setClip(const GrClipData* clipData) { fClip = clipData; }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000370
bsalomon@google.com27847de2011-02-22 20:59:41 +0000371 ///////////////////////////////////////////////////////////////////////////
372 // Draws
373
374 /**
bsalomon@google.com6aa25c32011-04-27 19:55:29 +0000375 * Clear the entire or rect of the render target, ignoring any clips.
376 * @param rect the rect to clear or the whole thing if rect is NULL.
377 * @param color the color to clear to.
robertphillips@google.comc82a8b72012-06-21 20:15:48 +0000378 * @param target if non-NULL, the render target to clear otherwise clear
379 * the current render target
bsalomon@google.com27847de2011-02-22 20:59:41 +0000380 */
commit-bot@chromium.orgfd03d4a2013-07-17 21:39:42 +0000381 void clear(const SkIRect* rect, GrColor color,
robertphillips@google.comc82a8b72012-06-21 20:15:48 +0000382 GrRenderTarget* target = NULL);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000383
384 /**
385 * Draw everywhere (respecting the clip) with the paint.
386 */
387 void drawPaint(const GrPaint& paint);
388
389 /**
390 * Draw the rect using a paint.
391 * @param paint describes how to color pixels.
392 * @param strokeWidth If strokeWidth < 0, then the rect is filled, else
393 * the rect is mitered stroked based on strokeWidth. If
394 * strokeWidth == 0, then the stroke is always a single
395 * pixel thick.
396 * @param matrix Optional matrix applied to the rect. Applied before
397 * context's matrix or the paint's matrix.
398 * The rects coords are used to access the paint (through texture matrix)
399 */
400 void drawRect(const GrPaint& paint,
commit-bot@chromium.orgfd03d4a2013-07-17 21:39:42 +0000401 const SkRect&,
bsalomon@google.com81712882012-11-01 17:12:34 +0000402 SkScalar strokeWidth = -1,
bsalomon@google.comb9086a02012-11-01 18:02:54 +0000403 const SkMatrix* matrix = NULL);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000404
405 /**
bsalomon@google.comc7818882013-03-20 19:19:53 +0000406 * Maps a rect of local coordinates onto the a rect of destination
407 * coordinates. Each rect can optionally be transformed. The localRect
bsalomon@google.com27847de2011-02-22 20:59:41 +0000408 * is stretched over the dstRect. The dstRect is transformed by the
bsalomon@google.comc7818882013-03-20 19:19:53 +0000409 * context's matrix. Additional optional matrices for both rects can be
410 * provided by parameters.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000411 *
bsalomon@google.comc7818882013-03-20 19:19:53 +0000412 * @param paint describes how to color pixels.
413 * @param dstRect the destination rect to draw.
414 * @param localRect rect of local coordinates to be mapped onto dstRect
415 * @param dstMatrix Optional matrix to transform dstRect. Applied before context's matrix.
416 * @param localMatrix Optional matrix to transform localRect.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000417 */
418 void drawRectToRect(const GrPaint& paint,
commit-bot@chromium.orgfd03d4a2013-07-17 21:39:42 +0000419 const SkRect& dstRect,
420 const SkRect& localRect,
bsalomon@google.comb9086a02012-11-01 18:02:54 +0000421 const SkMatrix* dstMatrix = NULL,
bsalomon@google.comc7818882013-03-20 19:19:53 +0000422 const SkMatrix* localMatrix = NULL);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000423
424 /**
commit-bot@chromium.orgf2bfd542013-04-25 15:27:00 +0000425 * Draw a roundrect using a paint.
426 *
427 * @param paint describes how to color pixels.
428 * @param rrect the roundrect to draw
429 * @param stroke the stroke information (width, join, cap)
430 */
431 void drawRRect(const GrPaint& paint,
432 const SkRRect& rrect,
433 const SkStrokeRec& stroke);
434
435 /**
bsalomon@google.comd302f142011-03-03 13:54:13 +0000436 * Draws a path.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000437 *
438 * @param paint describes how to color pixels.
reed@google.com07f3ee12011-05-16 17:21:57 +0000439 * @param path the path to draw
sugoi@google.com5f74cf82012-12-17 21:16:45 +0000440 * @param stroke the stroke information (width, join, cap)
bsalomon@google.com27847de2011-02-22 20:59:41 +0000441 */
sugoi@google.com5f74cf82012-12-17 21:16:45 +0000442 void drawPath(const GrPaint& paint, const SkPath& path, const SkStrokeRec& stroke);
reed@google.com07f3ee12011-05-16 17:21:57 +0000443
bsalomon@google.com27847de2011-02-22 20:59:41 +0000444 /**
445 * Draws vertices with a paint.
446 *
447 * @param paint describes how to color pixels.
448 * @param primitiveType primitives type to draw.
449 * @param vertexCount number of vertices.
450 * @param positions array of vertex positions, required.
451 * @param texCoords optional array of texture coordinates used
452 * to access the paint.
453 * @param colors optional array of per-vertex colors, supercedes
454 * the paint's color field.
455 * @param indices optional array of indices. If NULL vertices
456 * are drawn non-indexed.
457 * @param indexCount if indices is non-null then this is the
458 * number of indices.
459 */
460 void drawVertices(const GrPaint& paint,
461 GrPrimitiveType primitiveType,
462 int vertexCount,
463 const GrPoint positions[],
464 const GrPoint texs[],
465 const GrColor colors[],
466 const uint16_t indices[],
467 int indexCount);
468
bsalomon@google.com93c96602012-04-27 13:05:21 +0000469 /**
470 * Draws an oval.
471 *
472 * @param paint describes how to color pixels.
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000473 * @param oval the bounding rect of the oval.
474 * @param stroke the stroke information (width, style)
bsalomon@google.com93c96602012-04-27 13:05:21 +0000475 */
476 void drawOval(const GrPaint& paint,
commit-bot@chromium.orgfd03d4a2013-07-17 21:39:42 +0000477 const SkRect& oval,
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000478 const SkStrokeRec& stroke);
bsalomon@google.com93c96602012-04-27 13:05:21 +0000479
bsalomon@google.com27847de2011-02-22 20:59:41 +0000480 ///////////////////////////////////////////////////////////////////////////
481 // Misc.
482
483 /**
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000484 * Flags that affect flush() behavior.
485 */
486 enum FlushBits {
487 /**
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000488 * A client may reach a point where it has partially rendered a frame
489 * through a GrContext that it knows the user will never see. This flag
490 * causes the flush to skip submission of deferred content to the 3D API
491 * during the flush.
492 */
493 kDiscard_FlushBit = 0x2,
494 };
495
496 /**
bsalomon@google.com27847de2011-02-22 20:59:41 +0000497 * Call to ensure all drawing to the context has been issued to the
498 * underlying 3D API.
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000499 * @param flagsBitfield flags that control the flushing behavior. See
500 * FlushBits.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000501 */
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000502 void flush(int flagsBitfield = 0);
bsalomon@google.com6f379512011-11-16 20:36:03 +0000503
bsalomon@google.com0342a852012-08-20 19:22:38 +0000504 /**
505 * These flags can be used with the read/write pixels functions below.
506 */
507 enum PixelOpsFlags {
508 /** The GrContext will not be flushed. This means that the read or write may occur before
509 previous draws have executed. */
510 kDontFlush_PixelOpsFlag = 0x1,
511 /** The src for write or dst read is unpremultiplied. This is only respected if both the
512 config src and dst configs are an RGBA/BGRA 8888 format. */
513 kUnpremul_PixelOpsFlag = 0x2,
514 };
515
bsalomon@google.com27847de2011-02-22 20:59:41 +0000516 /**
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000517 * Reads a rectangle of pixels from a render target.
bsalomon@google.com0342a852012-08-20 19:22:38 +0000518 * @param target the render target to read from. NULL means the current render target.
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000519 * @param left left edge of the rectangle to read (inclusive)
520 * @param top top edge of the rectangle to read (inclusive)
521 * @param width width of rectangle to read in pixels.
522 * @param height height of rectangle to read in pixels.
523 * @param config the pixel config of the destination buffer
524 * @param buffer memory to read the rectangle into.
bsalomon@google.com0342a852012-08-20 19:22:38 +0000525 * @param rowBytes number of bytes bewtween consecutive rows. Zero means rows are tightly
526 * packed.
527 * @param pixelOpsFlags see PixelOpsFlags enum above.
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000528 *
bsalomon@google.com0342a852012-08-20 19:22:38 +0000529 * @return true if the read succeeded, false if not. The read can fail because of an unsupported
530 * pixel config or because no render target is currently set and NULL was passed for
531 * target.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000532 */
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000533 bool readRenderTargetPixels(GrRenderTarget* target,
534 int left, int top, int width, int height,
bsalomon@google.com0342a852012-08-20 19:22:38 +0000535 GrPixelConfig config, void* buffer,
536 size_t rowBytes = 0,
537 uint32_t pixelOpsFlags = 0);
bsalomon@google.com6f379512011-11-16 20:36:03 +0000538
539 /**
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000540 * Copy the src pixels [buffer, row bytes, pixel config] into a render target at the specified
bsalomon@google.com0342a852012-08-20 19:22:38 +0000541 * rectangle.
542 * @param target the render target to write into. NULL means the current render target.
bsalomon@google.com6f379512011-11-16 20:36:03 +0000543 * @param left left edge of the rectangle to write (inclusive)
544 * @param top top edge of the rectangle to write (inclusive)
545 * @param width width of rectangle to write in pixels.
546 * @param height height of rectangle to write in pixels.
547 * @param config the pixel config of the source buffer
548 * @param buffer memory to read the rectangle from.
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000549 * @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly
bsalomon@google.com0342a852012-08-20 19:22:38 +0000550 * packed.
551 * @param pixelOpsFlags see PixelOpsFlags enum above.
bsalomon@google.com9c680582013-02-06 18:17:50 +0000552 *
553 * @return true if the write succeeded, false if not. The write can fail because of an
554 * unsupported combination of target and pixel configs.
bsalomon@google.com6f379512011-11-16 20:36:03 +0000555 */
bsalomon@google.com9c680582013-02-06 18:17:50 +0000556 bool writeRenderTargetPixels(GrRenderTarget* target,
bsalomon@google.com6f379512011-11-16 20:36:03 +0000557 int left, int top, int width, int height,
558 GrPixelConfig config, const void* buffer,
bsalomon@google.com0342a852012-08-20 19:22:38 +0000559 size_t rowBytes = 0,
560 uint32_t pixelOpsFlags = 0);
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000561
562 /**
563 * Reads a rectangle of pixels from a texture.
bsalomon@google.com6f379512011-11-16 20:36:03 +0000564 * @param texture the texture to read from.
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000565 * @param left left edge of the rectangle to read (inclusive)
566 * @param top top edge of the rectangle to read (inclusive)
567 * @param width width of rectangle to read in pixels.
568 * @param height height of rectangle to read in pixels.
569 * @param config the pixel config of the destination buffer
570 * @param buffer memory to read the rectangle into.
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000571 * @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly
bsalomon@google.com0342a852012-08-20 19:22:38 +0000572 * packed.
573 * @param pixelOpsFlags see PixelOpsFlags enum above.
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000574 *
bsalomon@google.com0342a852012-08-20 19:22:38 +0000575 * @return true if the read succeeded, false if not. The read can fail because of an unsupported
576 * pixel config.
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000577 */
bsalomon@google.com6f379512011-11-16 20:36:03 +0000578 bool readTexturePixels(GrTexture* texture,
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000579 int left, int top, int width, int height,
bsalomon@google.com6f379512011-11-16 20:36:03 +0000580 GrPixelConfig config, void* buffer,
bsalomon@google.com0342a852012-08-20 19:22:38 +0000581 size_t rowBytes = 0,
582 uint32_t pixelOpsFlags = 0);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000583
584 /**
bsalomon@google.com6f379512011-11-16 20:36:03 +0000585 * Writes a rectangle of pixels to a texture.
586 * @param texture the render target to read from.
587 * @param left left edge of the rectangle to write (inclusive)
588 * @param top top edge of the rectangle to write (inclusive)
589 * @param width width of rectangle to write in pixels.
590 * @param height height of rectangle to write in pixels.
591 * @param config the pixel config of the source buffer
592 * @param buffer memory to read pixels from
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000593 * @param rowBytes number of bytes between consecutive rows. Zero
bsalomon@google.com6f379512011-11-16 20:36:03 +0000594 * means rows are tightly packed.
bsalomon@google.com0342a852012-08-20 19:22:38 +0000595 * @param pixelOpsFlags see PixelOpsFlags enum above.
bsalomon@google.com9c680582013-02-06 18:17:50 +0000596 * @return true if the write succeeded, false if not. The write can fail because of an
597 * unsupported combination of texture and pixel configs.
bsalomon@google.com27847de2011-02-22 20:59:41 +0000598 */
bsalomon@google.com9c680582013-02-06 18:17:50 +0000599 bool writeTexturePixels(GrTexture* texture,
bsalomon@google.com6f379512011-11-16 20:36:03 +0000600 int left, int top, int width, int height,
601 GrPixelConfig config, const void* buffer,
bsalomon@google.com0342a852012-08-20 19:22:38 +0000602 size_t rowBytes,
603 uint32_t pixelOpsFlags = 0);
604
605
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000606 /**
scroggo@google.coma2a31922012-12-07 19:14:45 +0000607 * Copies a rectangle of texels from src to dst. The size of dst is the size of the rectangle
608 * copied and topLeft is the position of the rect in src. The rectangle is clipped to src's
609 * bounds.
senorblanco@chromium.orgef843cd2011-12-02 19:11:17 +0000610 * @param src the texture to copy from.
611 * @param dst the render target to copy to.
scroggo@google.coma2a31922012-12-07 19:14:45 +0000612 * @param topLeft the point in src that will be copied to the top-left of dst. If NULL,
613 * (0, 0) will be used.
senorblanco@chromium.orgef843cd2011-12-02 19:11:17 +0000614 */
scroggo@google.coma2a31922012-12-07 19:14:45 +0000615 void copyTexture(GrTexture* src, GrRenderTarget* dst, const SkIPoint* topLeft = NULL);
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000616
617 /**
618 * Resolves a render target that has MSAA. The intermediate MSAA buffer is
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000619 * down-sampled to the associated GrTexture (accessible via
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000620 * GrRenderTarget::asTexture()). Any pending draws to the render target will
621 * be executed before the resolve.
622 *
623 * This is only necessary when a client wants to access the object directly
bsalomon@google.com16e3dde2012-10-25 18:43:28 +0000624 * using the backend API directly. GrContext will detect when it must
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000625 * perform a resolve to a GrTexture used as the source of a draw or before
626 * reading pixels back from a GrTexture or GrRenderTarget.
627 */
628 void resolveRenderTarget(GrRenderTarget* target);
629
bsalomon@google.com27847de2011-02-22 20:59:41 +0000630 ///////////////////////////////////////////////////////////////////////////
631 // Helpers
632
robertphillips@google.comccb39502012-10-01 18:25:13 +0000633 class AutoRenderTarget : public ::GrNoncopyable {
bsalomon@google.com27847de2011-02-22 20:59:41 +0000634 public:
635 AutoRenderTarget(GrContext* context, GrRenderTarget* target) {
bsalomon@google.com27847de2011-02-22 20:59:41 +0000636 fPrevTarget = context->getRenderTarget();
robertphillips@google.comccb39502012-10-01 18:25:13 +0000637 GrSafeRef(fPrevTarget);
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000638 context->setRenderTarget(target);
639 fContext = context;
640 }
641 AutoRenderTarget(GrContext* context) {
642 fPrevTarget = context->getRenderTarget();
robertphillips@google.comccb39502012-10-01 18:25:13 +0000643 GrSafeRef(fPrevTarget);
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000644 fContext = context;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000645 }
646 ~AutoRenderTarget() {
robertphillips@google.comccb39502012-10-01 18:25:13 +0000647 if (NULL != fContext) {
bsalomon@google.com27847de2011-02-22 20:59:41 +0000648 fContext->setRenderTarget(fPrevTarget);
649 }
robertphillips@google.comccb39502012-10-01 18:25:13 +0000650 GrSafeUnref(fPrevTarget);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000651 }
652 private:
653 GrContext* fContext;
654 GrRenderTarget* fPrevTarget;
655 };
656
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000657 /**
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000658 * Save/restore the view-matrix in the context. It can optionally adjust a paint to account
659 * for a coordinate system change. Here is an example of how the paint param can be used:
660 *
bsalomon@google.com6f261be2012-10-24 19:07:10 +0000661 * A GrPaint is setup with GrEffects. The stages will have access to the pre-matrix source
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000662 * geometry positions when the draw is executed. Later on a decision is made to transform the
bsalomon@google.com6f261be2012-10-24 19:07:10 +0000663 * geometry to device space on the CPU. The effects now need to know that the space in which
664 * the geometry will be specified has changed.
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000665 *
666 * Note that when restore is called (or in the destructor) the context's matrix will be
667 * restored. However, the paint will not be restored. The caller must make a copy of the
668 * paint if necessary. Hint: use SkTCopyOnFirstWrite if the AutoMatrix is conditionally
669 * initialized.
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000670 */
671 class AutoMatrix : GrNoncopyable {
672 public:
673 AutoMatrix() : fContext(NULL) {}
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000674
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000675 ~AutoMatrix() { this->restore(); }
676
677 /**
678 * Initializes by pre-concat'ing the context's current matrix with the preConcat param.
679 */
bsalomon@google.comb9086a02012-11-01 18:02:54 +0000680 void setPreConcat(GrContext* context, const SkMatrix& preConcat, GrPaint* paint = NULL) {
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000681 SkASSERT(NULL != context);
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000682
683 this->restore();
skia.committer@gmail.comf57c01b2012-10-13 02:01:56 +0000684
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000685 fContext = context;
686 fMatrix = context->getMatrix();
687 this->preConcat(preConcat, paint);
688 }
689
690 /**
691 * Sets the context's matrix to identity. Returns false if the inverse matrix is required to
692 * update a paint but the matrix cannot be inverted.
693 */
694 bool setIdentity(GrContext* context, GrPaint* paint = NULL) {
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000695 SkASSERT(NULL != context);
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000696
697 this->restore();
skia.committer@gmail.comf57c01b2012-10-13 02:01:56 +0000698
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000699 if (NULL != paint) {
bsalomon@google.comc7818882013-03-20 19:19:53 +0000700 if (!paint->localCoordChangeInverse(context->getMatrix())) {
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000701 return false;
702 }
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000703 }
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000704 fMatrix = context->getMatrix();
705 fContext = context;
706 context->setIdentityMatrix();
707 return true;
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000708 }
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000709
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000710 /**
711 * Replaces the context's matrix with a new matrix. Returns false if the inverse matrix is
712 * required to update a paint but the matrix cannot be inverted.
713 */
bsalomon@google.comb9086a02012-11-01 18:02:54 +0000714 bool set(GrContext* context, const SkMatrix& newMatrix, GrPaint* paint = NULL) {
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000715 if (NULL != paint) {
716 if (!this->setIdentity(context, paint)) {
717 return false;
718 }
719 this->preConcat(newMatrix, paint);
720 } else {
721 this->restore();
722 fContext = context;
723 fMatrix = context->getMatrix();
724 context->setMatrix(newMatrix);
725 }
726 return true;
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000727 }
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000728
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000729 /**
730 * If this has been initialized then the context's matrix will be further updated by
731 * pre-concat'ing the preConcat param. The matrix that will be restored remains unchanged.
732 * The paint is assumed to be relative to the context's matrix at the time this call is
733 * made, not the matrix at the time AutoMatrix was first initialized. In other words, this
734 * performs an incremental update of the paint.
735 */
bsalomon@google.comb9086a02012-11-01 18:02:54 +0000736 void preConcat(const SkMatrix& preConcat, GrPaint* paint = NULL) {
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000737 if (NULL != paint) {
bsalomon@google.comc7818882013-03-20 19:19:53 +0000738 paint->localCoordChange(preConcat);
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000739 }
740 fContext->concatMatrix(preConcat);
741 }
742
743 /**
744 * Returns false if never initialized or the inverse matrix was required to update a paint
745 * but the matrix could not be inverted.
746 */
747 bool succeeded() const { return NULL != fContext; }
748
749 /**
750 * If this has been initialized then the context's original matrix is restored.
751 */
752 void restore() {
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000753 if (NULL != fContext) {
754 fContext->setMatrix(fMatrix);
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000755 fContext = NULL;
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000756 }
757 }
758
759 private:
760 GrContext* fContext;
bsalomon@google.comb9086a02012-11-01 18:02:54 +0000761 SkMatrix fMatrix;
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000762 };
bsalomon@google.com27847de2011-02-22 20:59:41 +0000763
robertphillips@google.com56c79b12012-07-11 20:57:46 +0000764 class AutoClip : GrNoncopyable {
765 public:
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000766 // This enum exists to require a caller of the constructor to acknowledge that the clip will
767 // initially be wide open. It also could be extended if there are other desirable initial
768 // clip states.
769 enum InitialClip {
770 kWideOpen_InitialClip,
771 };
772
skia.committer@gmail.comdc3a4e52012-10-02 02:01:24 +0000773 AutoClip(GrContext* context, InitialClip initialState)
robertphillips@google.comccb39502012-10-01 18:25:13 +0000774 : fContext(context) {
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000775 SkASSERT(kWideOpen_InitialClip == initialState);
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000776 fNewClipData.fClipStack = &fNewClipStack;
robertphillips@google.comccb39502012-10-01 18:25:13 +0000777
778 fOldClip = context->getClip();
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000779 context->setClip(&fNewClipData);
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000780 }
781
commit-bot@chromium.orgfd03d4a2013-07-17 21:39:42 +0000782 AutoClip(GrContext* context, const SkRect& newClipRect)
robertphillips@google.com56c79b12012-07-11 20:57:46 +0000783 : fContext(context)
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000784 , fNewClipStack(newClipRect) {
785 fNewClipData.fClipStack = &fNewClipStack;
786
robertphillips@google.com56c79b12012-07-11 20:57:46 +0000787 fOldClip = fContext->getClip();
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000788 fContext->setClip(&fNewClipData);
robertphillips@google.com56c79b12012-07-11 20:57:46 +0000789 }
790
791 ~AutoClip() {
792 if (NULL != fContext) {
793 fContext->setClip(fOldClip);
794 }
795 }
796 private:
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000797 GrContext* fContext;
798 const GrClipData* fOldClip;
799
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000800 SkClipStack fNewClipStack;
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000801 GrClipData fNewClipData;
robertphillips@google.com56c79b12012-07-11 20:57:46 +0000802 };
803
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000804 class AutoWideOpenIdentityDraw {
805 public:
806 AutoWideOpenIdentityDraw(GrContext* ctx, GrRenderTarget* rt)
807 : fAutoClip(ctx, AutoClip::kWideOpen_InitialClip)
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000808 , fAutoRT(ctx, rt) {
809 fAutoMatrix.setIdentity(ctx);
810 // should never fail with no paint param.
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000811 SkASSERT(fAutoMatrix.succeeded());
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000812 }
bsalomon@google.com3cbaa2d2012-10-12 14:51:52 +0000813
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000814 private:
815 AutoClip fAutoClip;
816 AutoRenderTarget fAutoRT;
817 AutoMatrix fAutoMatrix;
818 };
819
bsalomon@google.com27847de2011-02-22 20:59:41 +0000820 ///////////////////////////////////////////////////////////////////////////
821 // Functions intended for internal use only.
822 GrGpu* getGpu() { return fGpu; }
bsalomon@google.com1f221a72011-08-23 20:54:07 +0000823 const GrGpu* getGpu() const { return fGpu; }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000824 GrFontCache* getFontCache() { return fFontCache; }
bsalomon@google.com21c10c52013-06-13 17:44:07 +0000825 GrDrawTarget* getTextTarget();
bsalomon@google.com27847de2011-02-22 20:59:41 +0000826 const GrIndexBuffer* getQuadIndexBuffer() const;
bsalomon@google.com9923c2b2012-06-06 18:21:18 +0000827
bsalomon@google.com558a75b2011-08-08 17:01:14 +0000828 /**
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000829 * Stencil buffers add themselves to the cache using addStencilBuffer. findStencilBuffer is
830 * called to check the cache for a SB that matches an RT's criteria.
bsalomon@google.com558a75b2011-08-08 17:01:14 +0000831 */
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000832 void addStencilBuffer(GrStencilBuffer* sb);
833 GrStencilBuffer* findStencilBuffer(int width, int height, int sampleCnt);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000834
bsalomon@google.com45a15f52012-12-10 19:10:17 +0000835 GrPathRenderer* getPathRenderer(
836 const SkPath& path,
sugoi@google.com5f74cf82012-12-17 21:16:45 +0000837 const SkStrokeRec& stroke,
bsalomon@google.com45a15f52012-12-10 19:10:17 +0000838 const GrDrawTarget* target,
839 bool allowSW,
840 GrPathRendererChain::DrawType drawType = GrPathRendererChain::kColor_DrawType,
841 GrPathRendererChain::StencilSupport* stencilSupport = NULL);
robertphillips@google.com2c756812012-05-22 20:28:23 +0000842
skia.committer@gmail.com74758112013-08-17 07:01:54 +0000843
robertphillips@google.com59552022012-08-31 13:07:37 +0000844#if GR_CACHE_STATS
robertphillips@google.com5f9f2f52012-08-22 10:57:05 +0000845 void printCacheStats() const;
846#endif
847
bsalomon@google.com27847de2011-02-22 20:59:41 +0000848private:
bsalomon@google.com1d4edd32012-08-16 18:36:06 +0000849 // Used to indicate whether a draw should be performed immediately or queued in fDrawBuffer.
850 enum BufferedDraw {
851 kYes_BufferedDraw,
852 kNo_BufferedDraw,
bsalomon@google.com27847de2011-02-22 20:59:41 +0000853 };
bsalomon@google.com1d4edd32012-08-16 18:36:06 +0000854 BufferedDraw fLastDrawWasBuffered;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000855
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000856 GrGpu* fGpu;
857 SkMatrix fViewMatrix;
858 SkAutoTUnref<GrRenderTarget> fRenderTarget;
859 const GrClipData* fClip; // TODO: make this ref counted
860 GrDrawState* fDrawState;
bsalomon@google.com10e04bf2012-03-30 14:35:04 +0000861
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000862 GrResourceCache* fTextureCache;
863 GrFontCache* fFontCache;
bsalomon@google.comdfe75bc2011-03-25 12:31:16 +0000864
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000865 GrPathRendererChain* fPathRendererChain;
866 GrSoftwarePathRenderer* fSoftwarePathRenderer;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000867
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000868 GrVertexBufferAllocPool* fDrawBufferVBAllocPool;
869 GrIndexBufferAllocPool* fDrawBufferIBAllocPool;
870 GrInOrderDrawBuffer* fDrawBuffer;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000871
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000872 GrAARectRenderer* fAARectRenderer;
873 GrOvalRenderer* fOvalRenderer;
bsalomon@google.comdfe75bc2011-03-25 12:31:16 +0000874
commit-bot@chromium.orgbb6a3172013-05-28 17:25:49 +0000875 bool fDidTestPMConversions;
876 int fPMToUPMConversion;
877 int fUPMToPMConversion;
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000878
robertphillips@google.comcdb426d2012-09-24 19:33:59 +0000879 struct CleanUpData {
880 PFCleanUpFunc fFunc;
881 void* fInfo;
882 };
883
robertphillips@google.com44a91dc2013-07-25 15:32:06 +0000884 SkTDArray<CleanUpData> fCleanUpData;
885
skia.committer@gmail.com956b3102013-07-26 07:00:58 +0000886 int fMaxTextureSizeOverride;
robertphillips@google.comcdb426d2012-09-24 19:33:59 +0000887
bsalomon@google.com6e4e6502013-02-25 20:12:45 +0000888 GrContext(); // init must be called after the constructor.
889 bool init(GrBackend, GrBackendContext);
bsalomon@google.com205d4602011-04-25 12:43:45 +0000890
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000891 void setupDrawBuffer();
892
bsalomon@google.comeb6879f2013-06-13 19:34:18 +0000893 class AutoRestoreEffects;
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000894 /// Sets the paint and returns the target to draw into. The paint can be NULL in which case the
895 /// draw state is left unmodified.
bsalomon@google.comeb6879f2013-06-13 19:34:18 +0000896 GrDrawTarget* prepareToDraw(const GrPaint*, BufferedDraw, AutoRestoreEffects*);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000897
commit-bot@chromium.org37d883d2013-05-02 13:11:22 +0000898 void internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path,
commit-bot@chromium.org81312832013-03-22 18:34:09 +0000899 const SkStrokeRec& stroke);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000900
robertphillips@google.com3319f332012-08-13 18:00:36 +0000901 GrTexture* createResizedTexture(const GrTextureDesc& desc,
bsalomon@google.com0797c2c2012-12-20 15:13:01 +0000902 const GrCacheID& cacheID,
robertphillips@google.com3319f332012-08-13 18:00:36 +0000903 void* srcData,
904 size_t rowBytes,
humper@google.comb86add12013-07-25 18:49:07 +0000905 bool filter);
robertphillips@google.com3319f332012-08-13 18:00:36 +0000906
robertphillips@google.com15c0fea2012-06-22 12:41:43 +0000907 // Needed so GrTexture's returnToCache helper function can call
908 // addExistingTextureToCache
909 friend class GrTexture;
910
911 // Add an existing texture to the texture cache. This is intended solely
912 // for use with textures released from an GrAutoScratchTexture.
913 void addExistingTextureToCache(GrTexture* texture);
reed@google.comfa35e3d2012-06-26 20:16:17 +0000914
skia.committer@gmail.comcdcb2ce2013-01-29 07:05:52 +0000915 /**
bsalomon@google.comadc65362013-01-28 14:26:09 +0000916 * These functions create premul <-> unpremul effects if it is possible to generate a pair
917 * of effects that make a readToUPM->writeToPM->readToUPM cycle invariant. Otherwise, they
918 * return NULL.
919 */
920 const GrEffectRef* createPMToUPMEffect(GrTexture* texture,
921 bool swapRAndB,
922 const SkMatrix& matrix);
923 const GrEffectRef* createUPMToPMEffect(GrTexture* texture,
924 bool swapRAndB,
925 const SkMatrix& matrix);
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000926
commit-bot@chromium.orgcae27fe2013-07-10 10:14:35 +0000927 /**
928 * This callback allows the resource cache to callback into the GrContext
929 * when the cache is still overbudget after a purge.
930 */
931 static bool OverbudgetCB(void* data);
932
reed@google.comfa35e3d2012-06-26 20:16:17 +0000933 typedef GrRefCnt INHERITED;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000934};
935
936/**
bsalomon@google.com1e269b52012-10-15 14:25:31 +0000937 * Gets and locks a scratch texture from a descriptor using either exact or approximate criteria.
938 * Unlocks texture in the destructor.
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +0000939 */
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000940class GrAutoScratchTexture : ::GrNoncopyable {
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +0000941public:
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000942 GrAutoScratchTexture()
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000943 : fContext(NULL)
944 , fTexture(NULL) {
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +0000945 }
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000946
947 GrAutoScratchTexture(GrContext* context,
948 const GrTextureDesc& desc,
bsalomon@google.com0797c2c2012-12-20 15:13:01 +0000949 GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch)
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000950 : fContext(NULL)
951 , fTexture(NULL) {
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000952 this->set(context, desc, match);
953 }
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000954
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000955 ~GrAutoScratchTexture() {
robertphillips@google.com9ec07532012-06-22 12:01:30 +0000956 this->reset();
957 }
958
959 void reset() {
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000960 if (NULL != fContext && NULL != fTexture) {
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000961 fContext->unlockScratchTexture(fTexture);
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000962 fTexture->unref();
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000963 fTexture = NULL;
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +0000964 }
965 }
bsalomon@google.com84223112011-07-14 14:45:44 +0000966
robertphillips@google.com15c0fea2012-06-22 12:41:43 +0000967 /*
968 * When detaching a texture we do not unlock it in the texture cache but
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000969 * we do set the returnToCache flag. In this way the texture remains
970 * "locked" in the texture cache until it is freed and recycled in
971 * GrTexture::internal_dispose. In reality, the texture has been removed
972 * from the cache (because this is in AutoScratchTexture) and by not
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000973 * calling unlockScratchTexture we simply don't re-add it. It will be
974 * reattached in GrTexture::internal_dispose.
robertphillips@google.com15c0fea2012-06-22 12:41:43 +0000975 *
976 * Note that the caller is assumed to accept and manage the ref to the
977 * returned texture.
978 */
979 GrTexture* detach() {
commit-bot@chromium.org3f4ea262013-05-11 13:21:43 +0000980 if (NULL == fTexture) {
981 return NULL;
982 }
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000983 GrTexture* texture = fTexture;
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000984 fTexture = NULL;
robertphillips@google.com15c0fea2012-06-22 12:41:43 +0000985
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000986 // This GrAutoScratchTexture has a ref from lockAndRefScratchTexture, which we give up now.
987 // The cache also has a ref which we are lending to the caller of detach(). When the caller
988 // lets go of the ref and the ref count goes to 0 internal_dispose will see this flag is
989 // set and re-ref the texture, thereby restoring the cache's ref.
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000990 SkASSERT(texture->getRefCnt() > 1);
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000991 texture->setFlag((GrTextureFlags) GrTexture::kReturnToCache_FlagBit);
992 texture->unref();
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000993 SkASSERT(NULL != texture->getCacheEntry());
bsalomon@google.com95ed55a2013-01-24 14:46:47 +0000994
995 return texture;
robertphillips@google.com15c0fea2012-06-22 12:41:43 +0000996 }
997
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000998 GrTexture* set(GrContext* context,
999 const GrTextureDesc& desc,
bsalomon@google.com0797c2c2012-12-20 15:13:01 +00001000 GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch) {
robertphillips@google.com9ec07532012-06-22 12:01:30 +00001001 this->reset();
1002
bsalomon@google.com50398bf2011-07-26 20:45:30 +00001003 fContext = context;
1004 if (NULL != fContext) {
bsalomon@google.com95ed55a2013-01-24 14:46:47 +00001005 fTexture = fContext->lockAndRefScratchTexture(desc, match);
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +00001006 if (NULL == fTexture) {
bsalomon@google.com50398bf2011-07-26 20:45:30 +00001007 fContext = NULL;
1008 }
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +00001009 return fTexture;
bsalomon@google.com50398bf2011-07-26 20:45:30 +00001010 } else {
1011 return NULL;
1012 }
1013 }
1014
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +00001015 GrTexture* texture() { return fTexture; }
1016
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +00001017private:
bsalomon@google.com50398bf2011-07-26 20:45:30 +00001018 GrContext* fContext;
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +00001019 GrTexture* fTexture;
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +00001020};
1021
bsalomon@google.com27847de2011-02-22 20:59:41 +00001022#endif