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
|
/*
* 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 "SkRegion.h"
#include "GrContext.h"
struct SkDrawProcs;
struct GrSkDrawProcs;
class GrTextContext;
/**
* Subclass of SkDevice, which directs all drawing to the GrGpu owned by the
* canvas.
*/
class SK_API SkGpuDevice : public SkDevice {
public:
/**
* New device that will create an offscreen renderTarget based on the
* config, width, height. The device's storage will not count against
* the GrContext's texture cache budget. The device's pixels will be
* uninitialized.
*/
SkGpuDevice(GrContext*, SkBitmap::Config, int width, int height);
/**
* New device that will render to the specified renderTarget.
*/
SkGpuDevice(GrContext*, GrRenderTarget*);
/**
* New device that will render to the texture (as a rendertarget).
* The GrTexture's asRenderTarget() must be non-NULL or device will not
* function.
*/
SkGpuDevice(GrContext*, GrTexture*);
virtual ~SkGpuDevice();
GrContext* context() const { return fContext; }
/**
* Override from SkGpuDevice, so we can set our FBO to be the render target
* The canvas parameter must be a SkGpuCanvas
*/
virtual void gainFocus(const SkMatrix&, const SkRegion&) SK_OVERRIDE;
virtual SkGpuRenderTarget* accessRenderTarget() SK_OVERRIDE;
// overrides from SkDevice
virtual void clear(SkColor color) SK_OVERRIDE;
virtual void writePixels(const SkBitmap& bitmap, int x, int y,
SkCanvas::Config8888 config8888) SK_OVERRIDE;
virtual void setMatrixClip(const SkMatrix& matrix, const SkRegion& clip,
const SkClipStack&) SK_OVERRIDE;
virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
const SkPoint[], const SkPaint& paint) SK_OVERRIDE;
virtual void drawRect(const SkDraw&, const SkRect& r,
const SkPaint& paint) SK_OVERRIDE;
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint, const SkMatrix* prePathMatrix,
bool pathIsMutable) SK_OVERRIDE;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
const SkIRect* srcRectOrNull,
const SkMatrix&, const SkPaint&) SK_OVERRIDE;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
int x, int y, const SkPaint& paint);
virtual void drawText(const SkDraw&, const void* text, size_t len,
SkScalar x, SkScalar y, const SkPaint&) SK_OVERRIDE;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], SkScalar constY,
int scalarsPerPos, const SkPaint&) SK_OVERRIDE;
virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
const SkPath& path, const SkMatrix* matrix,
const SkPaint&) SK_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&) SK_OVERRIDE;
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
const SkPaint&) SK_OVERRIDE;
virtual bool filterTextFlags(const SkPaint&, TextFlags*) SK_OVERRIDE;
virtual void flush();
virtual void onAttachToCanvas(SkCanvas* canvas) SK_OVERRIDE;
virtual void onDetachFromCanvas() SK_OVERRIDE;
/**
* Make's this device's rendertarget current in the underlying 3D API.
* Also implicitly flushes.
*/
virtual void makeRenderTargetCurrent();
virtual bool canHandleImageFilter(SkImageFilter*) SK_OVERRIDE;
virtual bool filterImage(SkImageFilter*, const SkBitmap&, const SkMatrix&,
SkBitmap*, SkIPoint*) SK_OVERRIDE;
class SkAutoCachedTexture; // used internally
protected:
bool isBitmapInTextureCache(const SkBitmap& bitmap,
const GrTextureParams& params) const;
// overrides from SkDevice
virtual bool onReadPixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888) SK_OVERRIDE;
private:
GrContext* fContext;
GrSkDrawProcs* fDrawProcs;
GrClipData fClipData;
// state for our offscreen render-target
GrRenderTarget* fRenderTarget;
bool fNeedClear;
bool fNeedPrepareRenderTarget;
// called from rt and tex cons
void initFromRenderTarget(GrContext*, GrRenderTarget*, bool cached);
// used by createCompatibleDevice
SkGpuDevice(GrContext*, GrTexture* texture, bool needClear);
// override from SkDevice
virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
SkDrawProcs* initDrawForText(GrTextContext*);
bool bindDeviceAsTexture(GrPaint* paint);
void prepareRenderTarget(const SkDraw&);
bool shouldTileBitmap(const SkBitmap& bitmap,
const GrTextureParams& sampler,
const SkIRect* srcRectPtr,
int* tileSize) const;
void internalDrawBitmap(const SkDraw&, const SkBitmap&,
const SkIRect&, const SkMatrix&, GrPaint* grPaint);
/**
* Returns non-initialized instance.
*/
GrTextContext* getTextContext();
typedef SkDevice INHERITED;
};
#endif
|
