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
|
/*
* 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 SkGpuDevice_DEFINED
#define SkGpuDevice_DEFINED
#include "SkGr.h"
#include "SkBitmap.h"
#include "SkDevice.h"
#include "SkPicture.h"
#include "SkRegion.h"
#include "SkSurface.h"
#include "GrContext.h"
#include "GrSurfacePriv.h"
struct SkDrawProcs;
struct GrSkDrawProcs;
class GrAccelData;
struct GrCachedLayer;
/**
* Subclass of SkBaseDevice, which directs all drawing to the GrGpu owned by the
* canvas.
*/
class SK_API SkGpuDevice : public SkBaseDevice {
public:
enum InitContents {
kClear_InitContents,
kUninit_InitContents
};
/**
* Creates an SkGpuDevice from a GrRenderTarget.
*/
static SkGpuDevice* Create(GrRenderTarget* target, const SkSurfaceProps*, InitContents);
/**
* Creates an SkGpuDevice from a GrRenderTarget whose texture width/height is
* different than its actual width/height (e.g., approx-match scratch texture).
*/
static SkGpuDevice* Create(GrRenderTarget* target, int width, int height,
const SkSurfaceProps*, InitContents);
/**
* New device that will create an offscreen renderTarget based on the ImageInfo and
* sampleCount. The Budgeted param controls whether the device's backing store counts against
* the resource cache budget. On failure, returns nullptr.
*/
static SkGpuDevice* Create(GrContext*, SkSurface::Budgeted, const SkImageInfo&,
int sampleCount, const SkSurfaceProps*, InitContents);
virtual ~SkGpuDevice();
SkGpuDevice* cloneDevice(const SkSurfaceProps& props) {
SkBaseDevice* dev = this->onCreateDevice(CreateInfo(this->imageInfo(), kPossible_TileUsage,
props.pixelGeometry()),
nullptr);
return static_cast<SkGpuDevice*>(dev);
}
GrContext* context() const { return fContext; }
// set all pixels to 0
void clearAll();
void replaceRenderTarget(bool shouldRetainContent);
GrRenderTarget* accessRenderTarget() override;
SkImageInfo imageInfo() const override {
return fLegacyBitmap.info();
}
void drawPaint(const SkDraw&, const SkPaint& paint) override;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
const SkPoint[], const SkPaint& paint) override;
virtual void drawRect(const SkDraw&, const SkRect& r,
const SkPaint& paint) override;
virtual void drawRRect(const SkDraw&, const SkRRect& r,
const SkPaint& paint) override;
virtual void drawDRRect(const SkDraw& draw, const SkRRect& outer,
const SkRRect& inner, const SkPaint& paint) override;
virtual void drawOval(const SkDraw&, const SkRect& oval,
const SkPaint& paint) override;
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint, const SkMatrix* prePathMatrix,
bool pathIsMutable) override;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
const SkMatrix&, const SkPaint&) override;
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint, SkCanvas::SrcRectConstraint) override;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
int x, int y, const SkPaint& paint) override;
virtual void drawText(const SkDraw&, const void* text, size_t len,
SkScalar x, SkScalar y, const SkPaint&) override;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
const SkPoint& offset, const SkPaint&) override;
virtual void drawTextBlob(const SkDraw&, const SkTextBlob*, SkScalar x, SkScalar y,
const SkPaint& paint, SkDrawFilter* drawFilter) override;
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) override;
void drawAtlas(const SkDraw&, const SkImage* atlas, const SkRSXform[], const SkRect[],
const SkColor[], int count, SkXfermode::Mode, const SkPaint&) override;
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
const SkPaint&) override;
void drawImage(const SkDraw&, const SkImage*, SkScalar x, SkScalar y, const SkPaint&) override;
void drawImageRect(const SkDraw&, const SkImage*, const SkRect* src, const SkRect& dst,
const SkPaint&, SkCanvas::SrcRectConstraint) override;
void flush() override;
void onAttachToCanvas(SkCanvas* canvas) override;
void onDetachFromCanvas() override;
const SkBitmap& onAccessBitmap() override;
bool onAccessPixels(SkPixmap*) override;
bool canHandleImageFilter(const SkImageFilter*) override;
virtual bool filterImage(const SkImageFilter*, const SkBitmap&,
const SkImageFilter::Context&,
SkBitmap*, SkIPoint*) override;
bool filterTexture(GrContext*, GrTexture*, int width, int height, const SkImageFilter*,
const SkImageFilter::Context&,
SkBitmap* result, SkIPoint* offset);
protected:
bool onReadPixels(const SkImageInfo&, void*, size_t, int, int) override;
bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) override;
bool onShouldDisableLCD(const SkPaint&) const final;
/** PRIVATE / EXPERIMENTAL -- do not call */
virtual bool EXPERIMENTAL_drawPicture(SkCanvas* canvas, const SkPicture* picture,
const SkMatrix*, const SkPaint*) override;
private:
GrContext* fContext;
GrSkDrawProcs* fDrawProcs;
SkAutoTUnref<const SkClipStack> fClipStack;
SkIPoint fClipOrigin;
GrClip fClip;
SkAutoTUnref<GrDrawContext> fDrawContext;
GrRenderTarget* fRenderTarget;
// remove when our clients don't rely on accessBitmap()
SkBitmap fLegacyBitmap;
bool fNeedClear;
bool fOpaque;
enum Flags {
kNeedClear_Flag = 1 << 0, //!< Surface requires an initial clear
kIsOpaque_Flag = 1 << 1, //!< Hint from client that rendering to this device will be
// opaque even if the config supports alpha.
};
static bool CheckAlphaTypeAndGetFlags(const SkImageInfo* info, InitContents init,
unsigned* flags);
SkGpuDevice(GrRenderTarget*, int width, int height, const SkSurfaceProps*, unsigned flags);
SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) override;
SkImageFilter::Cache* getImageFilterCache() override;
bool forceConservativeRasterClip() const override { return true; }
// sets the render target and clip on context
void prepareDraw(const SkDraw&);
/**
* Implementation for both drawBitmap and drawBitmapRect.
*/
void drawBitmapCommon(const SkDraw&,
const SkBitmap& bitmap,
const SkRect* srcRectPtr,
const SkSize* dstSizePtr, // ignored iff srcRectPtr == nullptr
const SkPaint&,
SkCanvas::SrcRectConstraint);
/**
* Helper functions called by drawBitmapCommon. By the time these are called the SkDraw's
* matrix, clip, and the device's render target has already been set on GrContext.
*/
// The tileSize and clippedSrcRect will be valid only if true is returned.
bool shouldTileImageID(uint32_t imageID, const SkIRect& imageRect,
const SkMatrix& viewMatrix,
const GrTextureParams& params,
const SkRect* srcRectPtr,
int maxTileSize,
int* tileSize,
SkIRect* clippedSubset) const;
bool shouldTileBitmap(const SkBitmap& bitmap,
const SkMatrix& viewMatrix,
const GrTextureParams& sampler,
const SkRect* srcRectPtr,
int maxTileSize,
int* tileSize,
SkIRect* clippedSrcRect) const;
// Just returns the predicate, not the out-tileSize or out-clippedSubset, as they are not
// needed at the moment.
bool shouldTileImage(const SkImage* image, const SkRect* srcRectPtr,
SkCanvas::SrcRectConstraint constraint, SkFilterQuality quality,
const SkMatrix& viewMatrix) const;
void internalDrawBitmap(const SkBitmap&,
const SkMatrix& viewMatrix,
const SkRect&,
const GrTextureParams& params,
const SkPaint& paint,
SkCanvas::SrcRectConstraint,
bool bicubic,
bool needsTextureDomain);
void drawTiledBitmap(const SkBitmap& bitmap,
const SkMatrix& viewMatrix,
const SkRect& srcRect,
const SkIRect& clippedSrcRect,
const GrTextureParams& params,
const SkPaint& paint,
SkCanvas::SrcRectConstraint,
int tileSize,
bool bicubic);
bool drawDashLine(const SkPoint pts[2], const SkPaint& paint);
static GrRenderTarget* CreateRenderTarget(GrContext*, SkSurface::Budgeted, const SkImageInfo&,
int sampleCount);
friend class GrAtlasTextContext;
friend class SkSurface_Gpu; // for access to surfaceProps
typedef SkBaseDevice INHERITED;
};
#endif
|
