1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
|
/*
* Copyright 2010 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrContext_DEFINED
#define GrContext_DEFINED
#include "GrClip.h"
#include "GrPaint.h"
#include "GrAARectRenderer.h"
// not strictly needed but requires WK change in LayerTextureUpdaterCanvas to
// remove.
#include "GrRenderTarget.h"
class GrAutoScratchTexture;
class GrDrawState;
class GrDrawTarget;
class GrFontCache;
class GrGpu;
class GrIndexBuffer;
class GrIndexBufferAllocPool;
class GrInOrderDrawBuffer;
class GrPathRenderer;
class GrPathRendererChain;
class GrResourceEntry;
class GrResourceCache;
class GrStencilBuffer;
class GrVertexBuffer;
class GrVertexBufferAllocPool;
class GrSoftwarePathRenderer;
class GR_API GrContext : public GrRefCnt {
public:
/**
* Creates a GrContext from within a 3D context.
*/
static GrContext* Create(GrEngine engine,
GrPlatform3DContext context3D);
/**
* Returns the number of GrContext instances for the current thread.
*/
static int GetThreadInstanceCount();
virtual ~GrContext();
/**
* The GrContext normally assumes that no outsider is setting state
* within the underlying 3D API's context/device/whatever. This call informs
* the context that the state was modified and it should resend. Shouldn't
* be called frequently for good performance.
*/
void resetContext();
/**
* Abandons all gpu resources, assumes 3D API state is unknown. Call this
* if you have lost the associated GPU context, and thus internal texture,
* buffer, etc. references/IDs are now invalid. Should be called even when
* GrContext is no longer going to be used for two reasons:
* 1) ~GrContext will not try to free the objects in the 3D API.
* 2) If you've created GrResources that outlive the GrContext they will
* be marked as invalid (GrResource::isValid()) and won't attempt to
* free their underlying resource in the 3D API.
* Content drawn since the last GrContext::flush() may be lost.
*/
void contextLost();
/**
* Similar to contextLost, but makes no attempt to reset state.
* Use this method when GrContext destruction is pending, but
* the graphics context is destroyed first.
*/
void contextDestroyed();
/**
* Frees gpu created by the context. Can be called to reduce GPU memory
* pressure.
*/
void freeGpuResources();
///////////////////////////////////////////////////////////////////////////
// Textures
/**
* Token that refers to an entry in the texture cache. Returned by
* functions that lock textures. Passed to unlockTexture.
*/
class SK_API TextureCacheEntry {
public:
TextureCacheEntry() : fEntry(NULL) {}
TextureCacheEntry(const TextureCacheEntry& e) : fEntry(e.fEntry) {}
TextureCacheEntry& operator= (const TextureCacheEntry& e) {
fEntry = e.fEntry;
return *this;
}
GrTexture* texture() const;
void reset() { fEntry = NULL; }
GrResourceEntry* cacheEntry() { return fEntry; }
private:
explicit TextureCacheEntry(GrResourceEntry* entry) { fEntry = entry; }
void set(GrResourceEntry* entry) { fEntry = entry; }
GrResourceEntry* fEntry;
friend class GrContext;
};
/**
* Create a new entry, based on the specified key and texture, and return
* its "locked" entry. Must call be balanced with an unlockTexture() call.
*
* @param sampler The sampler state used to draw a texture may be used
* to determine how to store the pixel data in the texture
* cache. (e.g. different versions may exist for different
* wrap modes on GPUs with limited or no NPOT texture
* support). Only the wrap and filter fields are used. NULL
* implies clamp wrap modes and nearest filtering.
* @param desc Description of the texture properties.
* @param srcData Pointer to the pixel values.
* @param rowBytes The number of bytes between rows of the texture. Zero
* implies tightly packed rows.
*/
TextureCacheEntry createAndLockTexture(const GrSamplerState* sampler,
const GrTextureDesc& desc,
void* srcData, size_t rowBytes);
/**
* Search for an entry based on key and dimensions. If found, "lock" it and
* return it. The entry's texture() function will return NULL if not found.
* Must be balanced with an unlockTexture() call.
*
* @param desc Description of the texture properties.
* @param sampler The sampler state used to draw a texture may be used
* to determine the cache entry used. (e.g. different
* versions may exist for different wrap modes on GPUs with
* limited or no NPOT texture support). Only the wrap and
* filter fields are used. NULL implies clamp wrap modes
* and nearest filtering.
*/
TextureCacheEntry findAndLockTexture(const GrTextureDesc& desc,
const GrSamplerState* sampler);
/**
* Determines whether a texture is in the cache. If the texture is found it
* will not be locked or returned. This call does not affect the priority of
* the texture for deletion.
*/
bool isTextureInCache(const GrTextureDesc& desc,
const GrSamplerState* sampler) const;
/**
* Enum that determines how closely a returned scratch texture must match
* a provided GrTextureDesc.
*/
enum ScratchTexMatch {
/**
* Finds a texture that exactly matches the descriptor.
*/
kExact_ScratchTexMatch,
/**
* Finds a texture that approximately matches the descriptor. Will be
* at least as large in width and height as desc specifies. If desc
* specifies that texture is a render target then result will be a
* render target. If desc specifies a render target and doesn't set the
* no stencil flag then result will have a stencil. Format and aa level
* will always match.
*/
kApprox_ScratchTexMatch
};
/**
* Returns a texture matching the desc. It's contents are unknown. Subsequent
* requests with the same descriptor are not guaranteed to return the same
* texture. The same texture is guaranteed not be returned again until it is
* unlocked. Call must be balanced with an unlockTexture() call.
*
* Textures created by createAndLockTexture() hide the complications of
* tiling non-power-of-two textures on APIs that don't support this (e.g.
* unextended GLES2). Tiling a npot texture created by lockScratchTexture on
* such an API will create gaps in the tiling pattern. This includes clamp
* mode. (This may be addressed in a future update.)
*/
TextureCacheEntry lockScratchTexture(const GrTextureDesc& desc,
ScratchTexMatch match);
/**
* When done with an entry, call unlockTexture(entry) on it, which returns
* it to the cache, where it may be purged.
*/
void unlockTexture(TextureCacheEntry entry);
/**
* Free any data associated with the provided entry in the texture cache
*/
void freeEntry(TextureCacheEntry entry);
/**
* Creates a texture that is outside the cache. Does not count against
* cache's budget.
*/
GrTexture* createUncachedTexture(const GrTextureDesc& desc,
void* srcData,
size_t rowBytes);
/**
* Returns true if the specified use of an indexed texture is supported.
*/
bool supportsIndex8PixelConfig(const GrSamplerState* sampler,
int width,
int height) const;
/**
* Return the current texture cache budget in bytes.
*/
size_t getTextureCacheBudget() const;
/**
* Specify the texture cache budget. If the current cache size exceeds the
* budget it will immediately be purged to be within the budget.
*
* @param maxTextureBytes The maximum number of bytes of texture memory
* that can be held in the cache.
*/
void setTextureCacheBudget(size_t maxTextureBytes);
// DEPRECATED, this will be deleted soon.
void setTextureCacheLimits(int ignored, size_t maxTextureBytes) {
this->setTextureCacheBudget(maxTextureBytes);
}
/**
* Returns the current number of bytes of GPU memory hosted by the texture
* cache.
*/
size_t getGpuTextureCacheBytes() const;
/**
* Return the max width or height of a texture supported by the current gpu
*/
int getMaxTextureSize() const;
/**
* Return the max width or height of a render target supported by the
* current gpu
*/
int getMaxRenderTargetSize() const;
///////////////////////////////////////////////////////////////////////////
// Render targets
/**
* Sets the render target.
* @param target the render target to set. (should not be NULL.)
*/
void setRenderTarget(GrRenderTarget* target);
/**
* Gets the current render target.
* @return the currently bound render target. Should never be NULL.
*/
const GrRenderTarget* getRenderTarget() const;
GrRenderTarget* getRenderTarget();
GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
/**
* Can the provided configuration act as a color render target?
*/
bool isConfigRenderable(GrPixelConfig config) const;
///////////////////////////////////////////////////////////////////////////
// Platform Surfaces
/**
* Wraps an existing texture with a GrTexture object.
*
* OpenGL: if the object is a texture Gr may change its GL texture params
* when it is drawn.
*
* @param desc description of the object to create.
*
* @return GrTexture object or NULL on failure.
*/
GrTexture* createPlatformTexture(const GrPlatformTextureDesc& desc);
/**
* Wraps an existing render target with a GrRenderTarget object. It is
* similar to createPlatformTexture but can be used to draw into surfaces
* that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
* the client will resolve to a texture).
*
* @param desc description of the object to create.
*
* @return GrTexture object or NULL on failure.
*/
GrRenderTarget* createPlatformRenderTarget(
const GrPlatformRenderTargetDesc& desc);
///////////////////////////////////////////////////////////////////////////
// Matrix state
/**
* Gets the current transformation matrix.
* @return the current matrix.
*/
const GrMatrix& getMatrix() const;
/**
* Sets the transformation matrix.
* @param m the matrix to set.
*/
void setMatrix(const GrMatrix& m);
/**
* Concats the current matrix. The passed matrix is applied before the
* current matrix.
* @param m the matrix to concat.
*/
void concatMatrix(const GrMatrix& m) const;
///////////////////////////////////////////////////////////////////////////
// Clip state
/**
* Gets the current clip.
* @return the current clip.
*/
const GrClip& getClip() const;
/**
* Sets the clip.
* @param clip the clip to set.
*/
void setClip(const GrClip& clip);
/**
* Convenience method for setting the clip to a rect.
* @param rect the rect to set as the new clip.
*/
void setClip(const GrIRect& rect);
///////////////////////////////////////////////////////////////////////////
// Draws
/**
* Clear the entire or rect of the render target, ignoring any clips.
* @param rect the rect to clear or the whole thing if rect is NULL.
* @param color the color to clear to.
* @param target if non-NULL, the render target to clear otherwise clear
* the current render target
*/
void clear(const GrIRect* rect, GrColor color,
GrRenderTarget* target = NULL);
/**
* Draw everywhere (respecting the clip) with the paint.
*/
void drawPaint(const GrPaint& paint);
/**
* Draw the rect using a paint.
* @param paint describes how to color pixels.
* @param strokeWidth If strokeWidth < 0, then the rect is filled, else
* the rect is mitered stroked based on strokeWidth. If
* strokeWidth == 0, then the stroke is always a single
* pixel thick.
* @param matrix Optional matrix applied to the rect. Applied before
* context's matrix or the paint's matrix.
* The rects coords are used to access the paint (through texture matrix)
*/
void drawRect(const GrPaint& paint,
const GrRect&,
GrScalar strokeWidth = -1,
const GrMatrix* matrix = NULL);
/**
* Maps a rect of paint coordinates onto the a rect of destination
* coordinates. Each rect can optionally be transformed. The srcRect
* is stretched over the dstRect. The dstRect is transformed by the
* context's matrix and the srcRect is transformed by the paint's matrix.
* Additional optional matrices can be provided by parameters.
*
* @param paint describes how to color pixels.
* @param dstRect the destination rect to draw.
* @param srcRect rect of paint coordinates to be mapped onto dstRect
* @param dstMatrix Optional matrix to transform dstRect. Applied before
* context's matrix.
* @param srcMatrix Optional matrix to transform srcRect Applied before
* paint's matrix.
*/
void drawRectToRect(const GrPaint& paint,
const GrRect& dstRect,
const GrRect& srcRect,
const GrMatrix* dstMatrix = NULL,
const GrMatrix* srcMatrix = NULL);
/**
* Draws a path.
*
* @param paint describes how to color pixels.
* @param path the path to draw
* @param fill the path filling rule to use.
* @param translate optional additional translation applied to the
* path.
*/
void drawPath(const GrPaint& paint, const SkPath& path, GrPathFill fill,
const GrPoint* translate = NULL);
/**
* Draws vertices with a paint.
*
* @param paint describes how to color pixels.
* @param primitiveType primitives type to draw.
* @param vertexCount number of vertices.
* @param positions array of vertex positions, required.
* @param texCoords optional array of texture coordinates used
* to access the paint.
* @param colors optional array of per-vertex colors, supercedes
* the paint's color field.
* @param indices optional array of indices. If NULL vertices
* are drawn non-indexed.
* @param indexCount if indices is non-null then this is the
* number of indices.
*/
void drawVertices(const GrPaint& paint,
GrPrimitiveType primitiveType,
int vertexCount,
const GrPoint positions[],
const GrPoint texs[],
const GrColor colors[],
const uint16_t indices[],
int indexCount);
/**
* Draws an oval.
*
* @param paint describes how to color pixels.
* @param rect the bounding rect of the oval.
* @param strokeWidth if strokeWidth < 0, then the oval is filled, else
* the rect is stroked based on strokeWidth. If
* strokeWidth == 0, then the stroke is always a single
* pixel thick.
*/
void drawOval(const GrPaint& paint,
const GrRect& rect,
SkScalar strokeWidth);
///////////////////////////////////////////////////////////////////////////
// Misc.
/**
* Flags that affect flush() behavior.
*/
enum FlushBits {
/**
* A client may want Gr to bind a GrRenderTarget in the 3D API so that
* it can be rendered to directly. However, Gr lazily sets state. Simply
* calling setRenderTarget() followed by flush() without flags may not
* bind the render target. This flag forces the context to bind the last
* set render target in the 3D API.
*/
kForceCurrentRenderTarget_FlushBit = 0x1,
/**
* A client may reach a point where it has partially rendered a frame
* through a GrContext that it knows the user will never see. This flag
* causes the flush to skip submission of deferred content to the 3D API
* during the flush.
*/
kDiscard_FlushBit = 0x2,
};
/**
* Call to ensure all drawing to the context has been issued to the
* underlying 3D API.
* @param flagsBitfield flags that control the flushing behavior. See
* FlushBits.
*/
void flush(int flagsBitfield = 0);
/**
* Reads a rectangle of pixels from a render target.
* @param target the render target to read from. NULL means the
* current render target.
* @param left left edge of the rectangle to read (inclusive)
* @param top top edge of the rectangle to read (inclusive)
* @param width width of rectangle to read in pixels.
* @param height height of rectangle to read in pixels.
* @param config the pixel config of the destination buffer
* @param buffer memory to read the rectangle into.
* @param rowBytes number of bytes bewtween consecutive rows. Zero
* means rows are tightly packed.
*
* @return true if the read succeeded, false if not. The read can fail
* because of an unsupported pixel config or because no render
* target is currently set.
*/
bool readRenderTargetPixels(GrRenderTarget* target,
int left, int top, int width, int height,
GrPixelConfig config, void* buffer,
size_t rowBytes) {
return this->internalReadRenderTargetPixels(target, left, top,
width, height,
config, buffer,
rowBytes, 0);
}
/**
* Copy the src pixels [buffer, rowbytes, pixelconfig] into a render target
* at the specified rectangle.
* @param target the render target to write into. NULL means the
* current render target.
* @param left left edge of the rectangle to write (inclusive)
* @param top top edge of the rectangle to write (inclusive)
* @param width width of rectangle to write in pixels.
* @param height height of rectangle to write in pixels.
* @param config the pixel config of the source buffer
* @param buffer memory to read the rectangle from.
* @param rowBytes number of bytes bewtween consecutive rows. Zero
* means rows are tightly packed.
*/
void writeRenderTargetPixels(GrRenderTarget* target,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes) {
this->internalWriteRenderTargetPixels(target, left, top, width, height,
config, buffer, rowBytes, 0);
}
/**
* Reads a rectangle of pixels from a texture.
* @param texture the texture to read from.
* @param left left edge of the rectangle to read (inclusive)
* @param top top edge of the rectangle to read (inclusive)
* @param width width of rectangle to read in pixels.
* @param height height of rectangle to read in pixels.
* @param config the pixel config of the destination buffer
* @param buffer memory to read the rectangle into.
* @param rowBytes number of bytes bewtween consecutive rows. Zero
* means rows are tightly packed.
*
* @return true if the read succeeded, false if not. The read can fail
* because of an unsupported pixel config.
*/
bool readTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, void* buffer,
size_t rowBytes) {
return this->internalReadTexturePixels(texture, left, top,
width, height,
config, buffer, rowBytes, 0);
}
/**
* Writes a rectangle of pixels to a texture.
* @param texture the render target to read from.
* @param left left edge of the rectangle to write (inclusive)
* @param top top edge of the rectangle to write (inclusive)
* @param width width of rectangle to write in pixels.
* @param height height of rectangle to write in pixels.
* @param config the pixel config of the source buffer
* @param buffer memory to read pixels from
* @param rowBytes number of bytes bewtween consecutive rows. Zero
* means rows are tightly packed.
*/
void writeTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes) {
this->internalWriteTexturePixels(texture, left, top, width, height,
config, buffer, rowBytes, 0);
}
/**
* Copies all texels from one texture to another.
* @param src the texture to copy from.
* @param dst the render target to copy to.
*/
void copyTexture(GrTexture* src, GrRenderTarget* dst);
/**
* Resolves a render target that has MSAA. The intermediate MSAA buffer is
* downsampled to the associated GrTexture (accessible via
* GrRenderTarget::asTexture()). Any pending draws to the render target will
* be executed before the resolve.
*
* This is only necessary when a client wants to access the object directly
* using the underlying graphics API. GrContext will detect when it must
* perform a resolve to a GrTexture used as the source of a draw or before
* reading pixels back from a GrTexture or GrRenderTarget.
*/
void resolveRenderTarget(GrRenderTarget* target);
/**
* Applies a 2D Gaussian blur to a given texture.
* @param srcTexture The source texture to be blurred.
* @param temp1 A scratch texture. Must not be NULL.
* @param temp2 A scratch texture. May be NULL, in which case
* srcTexture is overwritten with intermediate
* results.
* @param rect The destination rectangle.
* @param sigmaX The blur's standard deviation in X.
* @param sigmaY The blur's standard deviation in Y.
* @return the blurred texture, which may be temp1, temp2 or srcTexture.
*/
GrTexture* gaussianBlur(GrTexture* srcTexture,
GrAutoScratchTexture* temp1,
GrAutoScratchTexture* temp2,
const SkRect& rect,
float sigmaX, float sigmaY);
/**
* This enum is used with the function below, applyMorphology.
*/
enum MorphologyType {
kErode_MorphologyType,
kDilate_MorphologyType,
};
/**
* Applies a 2D morphology to a given texture.
* @param srcTexture The source texture to be blurred.
* @param rect The destination rectangle.
* @param temp1 A scratch texture. Must not be NULL.
* @param temp2 A scratch texture. Must not be NULL.
* @param filter The morphology filter. Must be kDilate_Filter or
* kErode_Filter.
* @param radius The morphology radius in X and Y. The filter is
* applied to a fWidth by fHeight rectangle of
* pixels.
* @return the morphed texture, which may be temp1, temp2 or srcTexture.
*/
GrTexture* applyMorphology(GrTexture* srcTexture,
const GrRect& rect,
GrTexture* temp1, GrTexture* temp2,
MorphologyType type,
SkISize radius);
///////////////////////////////////////////////////////////////////////////
// Helpers
class AutoRenderTarget : ::GrNoncopyable {
public:
AutoRenderTarget(GrContext* context, GrRenderTarget* target) {
fContext = NULL;
fPrevTarget = context->getRenderTarget();
if (fPrevTarget != target) {
context->setRenderTarget(target);
fContext = context;
}
}
~AutoRenderTarget() {
if (fContext) {
fContext->setRenderTarget(fPrevTarget);
}
}
private:
GrContext* fContext;
GrRenderTarget* fPrevTarget;
};
///////////////////////////////////////////////////////////////////////////
// Functions intended for internal use only.
GrGpu* getGpu() { return fGpu; }
const GrGpu* getGpu() const { return fGpu; }
GrFontCache* getFontCache() { return fFontCache; }
GrDrawTarget* getTextTarget(const GrPaint& paint);
const GrIndexBuffer* getQuadIndexBuffer() const;
/**
* Stencil buffers add themselves to the cache using
* addAndLockStencilBuffer. When a SB's RT-attachment count
* reaches zero the SB unlocks itself using unlockStencilBuffer and is
* eligible for purging. findStencilBuffer is called to check the cache for
* a SB that matching an RT's criteria. If a match is found that has been
* unlocked (its attachment count has reached 0) then it will be relocked.
*/
GrResourceEntry* addAndLockStencilBuffer(GrStencilBuffer* sb);
void unlockStencilBuffer(GrResourceEntry* sbEntry);
GrStencilBuffer* findStencilBuffer(int width, int height, int sampleCnt);
/*
* postClipPush acts as a hint to this and lower-level classes (e.g.,
* GrGpu) that the clip stack has changed.
*/
virtual void postClipPush();
/*
* preClipPop acts as a hint that the clip stack has been restored to an
* earlier state.
*/
virtual void preClipPop();
GrPathRenderer* getPathRenderer(const SkPath& path,
GrPathFill fill,
const GrDrawTarget* target,
bool antiAlias,
bool allowSW);
private:
// used to keep track of when we need to flush the draw buffer
enum DrawCategory {
kBuffered_DrawCategory, // last draw was inserted in draw buffer
kUnbuffered_DrawCategory, // last draw was not inserted in the draw buffer
};
DrawCategory fLastDrawCategory;
GrGpu* fGpu;
GrDrawState* fDrawState;
GrResourceCache* fTextureCache;
GrFontCache* fFontCache;
GrPathRendererChain* fPathRendererChain;
GrSoftwarePathRenderer* fSoftwarePathRenderer;
GrVertexBufferAllocPool* fDrawBufferVBAllocPool;
GrIndexBufferAllocPool* fDrawBufferIBAllocPool;
GrInOrderDrawBuffer* fDrawBuffer;
GrAARectRenderer* fAARectRenderer;
GrContext(GrGpu* gpu);
void setupDrawBuffer();
void flushDrawBuffer();
void setPaint(const GrPaint& paint);
GrDrawTarget* prepareToDraw(const GrPaint& paint, DrawCategory drawType);
void internalDrawPath(const GrPaint& paint, const SkPath& path,
GrPathFill fill, const GrPoint* translate);
/**
* Flags to the internal read/write pixels funcs
*/
enum PixelOpsFlags {
kDontFlush_PixelOpsFlag = 0x1,
};
bool internalReadRenderTargetPixels(GrRenderTarget* target,
int left, int top,
int width, int height,
GrPixelConfig config, void* buffer,
size_t rowBytes, uint32_t flags);
void internalWriteRenderTargetPixels(GrRenderTarget* target,
int left, int top,
int width, int height,
GrPixelConfig, const void* buffer,
size_t rowBytes, uint32_t flags);
bool internalReadTexturePixels(GrTexture* texture,
int left, int top,
int width, int height,
GrPixelConfig config, void* buffer,
size_t rowBytes, uint32_t flags);
void internalWriteTexturePixels(GrTexture* texture,
int left, int top,
int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes, uint32_t flags);
// needed for access to internalWriteTexturePixels. TODO: make GrContext
// be a facade for an internal class. Then functions that are public on the
// internal class would have only be callable in src/gpu. The facade would
// only have to functions necessary for clients.
friend class GrAtlas;
// computes vertex layout bits based on the paint. If paint expresses
// a texture for a stage, the stage coords will be bound to postitions
// unless hasTexCoords[s]==true in which case stage s's input coords
// are bound to tex coord index s. hasTexCoords == NULL is a shortcut
// for an array where all the values are false.
static int PaintStageVertexLayoutBits(
const GrPaint& paint,
const bool hasTexCoords[GrPaint::kTotalStages]);
// Needed so GrTexture's returnToCache helper function can call
// addExistingTextureToCache
friend class GrTexture;
// Add an existing texture to the texture cache. This is intended solely
// for use with textures released from an GrAutoScratchTexture.
void addExistingTextureToCache(GrTexture* texture);
};
/**
* Save/restore the view-matrix in the context.
*/
class GrAutoMatrix : GrNoncopyable {
public:
GrAutoMatrix() : fContext(NULL) {}
GrAutoMatrix(GrContext* ctx) : fContext(ctx) {
fMatrix = ctx->getMatrix();
}
GrAutoMatrix(GrContext* ctx, const GrMatrix& matrix) : fContext(ctx) {
fMatrix = ctx->getMatrix();
ctx->setMatrix(matrix);
}
void set(GrContext* ctx) {
if (NULL != fContext) {
fContext->setMatrix(fMatrix);
}
fMatrix = ctx->getMatrix();
fContext = ctx;
}
void set(GrContext* ctx, const GrMatrix& matrix) {
if (NULL != fContext) {
fContext->setMatrix(fMatrix);
}
fMatrix = ctx->getMatrix();
ctx->setMatrix(matrix);
fContext = ctx;
}
~GrAutoMatrix() {
if (NULL != fContext) {
fContext->setMatrix(fMatrix);
}
}
private:
GrContext* fContext;
GrMatrix fMatrix;
};
/**
* Gets and locks a scratch texture from a descriptor using
* either exact or approximate criteria. Unlocks texture in
* the destructor.
*/
class GrAutoScratchTexture : ::GrNoncopyable {
public:
GrAutoScratchTexture()
: fContext(NULL) {
}
GrAutoScratchTexture(GrContext* context,
const GrTextureDesc& desc,
GrContext::ScratchTexMatch match =
GrContext::kApprox_ScratchTexMatch)
: fContext(NULL) {
this->set(context, desc, match);
}
~GrAutoScratchTexture() {
this->reset();
}
void reset() {
if (NULL != fContext && NULL != fEntry.cacheEntry()) {
fContext->unlockTexture(fEntry);
fEntry.reset();
}
}
/*
* When detaching a texture we do not unlock it in the texture cache but
* we do set the returnToCache flag. In this way the texture remains
* "locked" in the texture cache until it is freed and recycled in
* GrTexture::internal_dispose. In reality, the texture has been removed
* from the cache (because this is in AutoScratchTexture) and by not
* calling unlockTexture we simply don't re-add it. It will be reattached
* in GrTexture::internal_dispose.
*
* Note that the caller is assumed to accept and manage the ref to the
* returned texture.
*/
GrTexture* detach() {
GrTexture* temp = this->texture();
GrAssert(1 == temp->getRefCnt());
// freeEntry will remove the texture cache's ref
temp->ref();
fContext->freeEntry(fEntry);
fEntry.reset();
temp->setFlag((GrTextureFlags) GrTexture::kReturnToCache_FlagBit);
GrAssert(1 == temp->getRefCnt());
return temp;
}
GrTexture* set(GrContext* context,
const GrTextureDesc& desc,
GrContext::ScratchTexMatch match =
GrContext::kApprox_ScratchTexMatch) {
this->reset();
fContext = context;
if (NULL != fContext) {
fEntry = fContext->lockScratchTexture(desc, match);
GrTexture* ret = fEntry.texture();
if (NULL == ret) {
fContext = NULL;
}
return ret;
} else {
return NULL;
}
}
GrTexture* texture() { return fEntry.texture(); }
private:
GrContext* fContext;
GrContext::TextureCacheEntry fEntry;
};
#endif
|