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
|
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkGLDevice_DEFINED
#define SkGLDevice_DEFINED
#include "SkDevice.h"
#include "SkGL.h"
#include "SkRegion.h"
#ifdef SK_BUILD_FOR_MAC
#include <OpenGL/gl.h>
#elif defined(ANDROID)
#include <GLES/gl.h>
#endif
class SkGLDeviceFactory : public SkDeviceFactory {
public:
virtual SkDevice* newDevice(SkBitmap::Config config, int width, int height,
bool isOpaque, bool isForLayer);
};
struct SkGLDrawProcs;
class SkGLDevice : public SkDevice {
public:
SkGLDevice(const SkBitmap& bitmap, bool offscreen);
virtual ~SkGLDevice();
virtual SkDeviceFactory* getDeviceFactory() {
return SkNEW(SkGLDeviceFactory);
}
virtual uint32_t getDeviceCapabilities() { return kGL_Capability; }
// used to identify GLTextCache data in the glyphcache
static void GlyphCacheAuxProc(void* data);
enum TexOrientation {
kNo_TexOrientation,
kTopToBottom_TexOrientation,
kBottomToTop_TexOrientation
};
/** Called when this device is no longer a candidate for a render target,
but will instead be used as a texture to be drawn. Be sure to call
the base impl if you override, as it will compute size and max.
*/
virtual TexOrientation bindDeviceAsTexture();
// returns true if complex
SkGLClipIter* updateMatrixClip();
// call to set the clip to the specified rect
void scissor(const SkIRect&);
// overrides from SkDevice
virtual void gainFocus(SkCanvas*);
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);
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
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&);
// settings for the global texture cache
static size_t GetTextureCacheMaxCount();
static void SetTextureCacheMaxCount(size_t count);
static size_t GetTextureCacheMaxSize();
static void SetTextureCacheMaxSize(size_t size);
/** Call glDeleteTextures for all textures (including those for text)
This should be called while the gl-context is still valid. Its purpose
is to free up gl resources. Note that if a bitmap or text is drawn after
this call, new caches will be created.
*/
static void DeleteAllTextures();
/** Forget all textures without calling delete (including those for text).
This should be called if the gl-context has changed, and the texture
IDs that have been cached are no longer valid.
*/
static void AbandonAllTextures();
protected:
/** Return the current glmatrix, from a previous call to setMatrixClip */
const SkMatrix& matrix() const { return fMatrix; }
/** Return the current clip, from a previous call to setMatrixClip */
const SkRegion& clip() const { return fClip; }
private:
SkGLMatrix fGLMatrix;
SkMatrix fMatrix;
SkRegion fClip;
bool fDirty;
SkGLClipIter fClipIter;
SkGLDrawProcs* fDrawProcs;
void setupForText(SkDraw* draw, const SkPaint& paint);
// global texture cache methods
class TexCache;
static TexCache* LockTexCache(const SkBitmap&, GLuint* name,
SkPoint* size);
static void UnlockTexCache(TexCache*);
class SkAutoLockTexCache {
public:
SkAutoLockTexCache(const SkBitmap& bitmap, GLuint* name,
SkPoint* size) {
fTex = SkGLDevice::LockTexCache(bitmap, name, size);
}
~SkAutoLockTexCache() {
if (fTex) {
SkGLDevice::UnlockTexCache(fTex);
}
}
TexCache* get() const { return fTex; }
private:
TexCache* fTex;
};
friend class SkAutoTexCache;
// returns cache if the texture is bound for the shader
TexCache* setupGLPaintShader(const SkPaint& paint);
class AutoPaintShader {
public:
AutoPaintShader(SkGLDevice*, const SkPaint& paint);
~AutoPaintShader();
bool useTex() const { return fTexCache != 0; }
private:
SkGLDevice* fDevice;
TexCache* fTexCache;
};
friend class AutoPaintShader;
typedef SkDevice INHERITED;
};
#endif
|
