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
|
/*
Copyright 2010 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#ifndef SkGpuDevice_DEFINED
#define SkGpuDevice_DEFINED
#include "SkGr.h"
#include "SkDevice.h"
#include "SkRegion.h"
struct SkDrawProcs;
struct GrSkDrawProcs;
class GrTextContext;
/**
* Subclass of SkDevice, which directs all drawing to the GrGpu owned by the
* canvas.
*/
class SkGpuDevice : public SkDevice {
public:
SkGpuDevice(GrContext*, const SkBitmap& bitmap, bool isLayer);
virtual ~SkGpuDevice();
GrContext* context() const { return fContext; }
/**
* If this device was built for rendering as a layer (i.e. offscreen),
* then this will return the platform-specific handle to that GPU resource.
* For example, in OpenGL, this will return the FBO's texture ID.
* If this device was not built for rendering as a layer, then 0
* is returned.
*/
intptr_t getLayerTextureHandle() const;
/**
* Attaches the device to a rendering surface. This device will then render
* to the surface.
* For example, in OpenGL, the device will interpret handle as an FBO ID
* and drawing to the device would direct GL to the FBO.
*/
void bindDeviceToTargetHandle(intptr_t handle);
// call to set the clip to the specified rect
void scissor(const SkIRect&);
/**
* Override from SkGpuDevice, so we can set our FBO to be the render target
* The canvas parameter must be a SkGpuCanvas
*/
virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&);
virtual SkGpuTexture* accessTexture() { return (SkGpuTexture*)fTexture; }
// overrides from SkDevice
virtual bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap);
virtual void writePixels(const SkBitmap& bitmap, int x, int y);
virtual void setMatrixClip(const SkMatrix& matrix, const SkRegion& clip);
virtual void drawPaint(const SkDraw&, const SkPaint& paint);
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
const SkPoint[], const SkPaint& paint);
virtual void drawRect(const SkDraw&, const SkRect& r,
const SkPaint& paint);
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint, const SkMatrix* prePathMatrix,
bool pathIsMutable);
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
const SkIRect* srcRectOrNull,
const SkMatrix& matrix, const SkPaint& paint);
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& paint);
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], SkScalar constY,
int scalarsPerPos, const SkPaint& paint);
virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
const SkPath& path, const SkMatrix* matrix,
const SkPaint& paint);
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& paint);
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
const SkPaint&);
virtual void flush() { fContext->flush(false); }
/**
* Make's this device's rendertarget current in the underlying 3D API.
* Also implicitly flushes.
*/
virtual void makeRenderTargetCurrent();
protected:
class TexCache;
TexCache* lockCachedTexture(const SkBitmap& bitmap,
const GrSamplerState& sampler,
GrTexture** texture,
bool forDeviceRenderTarget = false);
void unlockCachedTexture(TexCache*);
class SkAutoCachedTexture {
public:
SkAutoCachedTexture();
SkAutoCachedTexture(SkGpuDevice* device,
const SkBitmap& bitmap,
const GrSamplerState& sampler,
GrTexture** texture);
~SkAutoCachedTexture();
GrTexture* set(SkGpuDevice*, const SkBitmap&, const GrSamplerState&);
private:
SkGpuDevice* fDevice;
TexCache* fTex;
};
friend class SkAutoTexCache;
private:
GrContext* fContext;
GrSkDrawProcs* fDrawProcs;
// state for our offscreen render-target
TexCache* fCache;
GrTexture* fTexture;
GrRenderTarget* fRenderTarget;
bool fNeedClear;
bool fNeedPrepareRenderTarget;
SkDrawProcs* initDrawForText(const SkPaint&, GrTextContext*);
bool bindDeviceAsTexture(SkPoint* max);
void prepareRenderTarget(const SkDraw&);
void internalDrawBitmap(const SkDraw&, const SkBitmap&,
const SkIRect&, const SkMatrix&, const SkPaint&);
class AutoPaintShader {
public:
AutoPaintShader();
AutoPaintShader(SkGpuDevice*, const SkPaint& paint, const SkMatrix&);
void init(SkGpuDevice*, const SkPaint& paint, const SkMatrix&);
bool failed() const { return !fSuccess; }
bool useTex() const { return fTexture != 0; }
private:
GrTexture* fTexture;
SkAutoCachedTexture fCachedTexture;
bool fSuccess;
};
friend class AutoPaintShader;
typedef SkDevice INHERITED;
};
#endif
|
