1 #ifndef SkGL_DEFINED
2 #define SkGL_DEFINED
3
4 #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_SDL)
5 #include <OpenGL/gl.h>
6 #include <OpenGL/glext.h>
7 #include <AGL/agl.h>
8 // use FBOs for devices
9 #define SK_GL_DEVICE_FBO
10 #elif defined(ANDROID)
11 #include <GLES/gl.h>
12 #include <EGL/egl.h>
13 #include <GLES/glext.h>
14 #endif
15
16 #include "SkColor.h"
17 #include "SkMatrix.h"
18 #include "SkShader.h"
19
20 class SkPaint;
21 class SkPath;
22
23 class SkGLClipIter;
24
25 //#define TRACE_TEXTURE_CREATE
26
SkGL_unimpl(const char str[])27 static void SkGL_unimpl(const char str[]) {
28 SkDebugf("SkGL unimplemented: %s\n", str);
29 }
30 ///////////////////////////////////////////////////////////////////////////////
31
32 #if GL_OES_compressed_paletted_texture
33 #define SK_GL_SUPPORT_COMPRESSEDTEXIMAGE2D
34 #endif
35
36 #if GL_OES_fixed_point && defined(SK_SCALAR_IS_FIXED)
37 #define SK_GLType GL_FIXED
38 #else
39 #define SK_GLType GL_FLOAT
40 #endif
41
42 #if SK_GLType == GL_FIXED
43 typedef SkFixed SkGLScalar;
44
45 #define SkIntToGL(n) SkIntToFixed(n)
46 #define SkScalarToGL(x) SkScalarToFixed(x)
47 #define SK_GLScalar1 SK_Fixed1
48 #define SkGLScalarMul(a, b) SkFixedMul(a, b)
49 #define MAKE_GL(name) name ## x
50
51 #ifdef SK_SCALAR_IS_FIXED
52 #define GLSCALAR_IS_SCALAR 1
53 #define SkPerspToGL(x) SkFractToFixed(x)
54 #else
55 #define GLSCALAR_IS_SCALAR 0
56 #define SkPerspToGL(x) SkFractToFloat(x)
57 #endif
58 #else
59 typedef float SkGLScalar;
60
61 #define SkIntToGL(n) (n)
62 #define SkScalarToGL(x) SkScalarToFloat(x)
63 #define SK_GLScalar1 (1.f)
64 #define SkGLScalarMul(a, b) ((a) * (b))
65 #define MAKE_GL(name) name ## f
66
67 #ifdef SK_SCALAR_IS_FLOAT
68 #define GLSCALAR_IS_SCALAR 1
69 #define SkPerspToGL(x) (x)
70 #else
71 #define GLSCALAR_IS_SCALAR 0
72 #define SkPerspToGL(x) SkFractToFloat(x)
73 #endif
74 #endif
75
76 #if GL_OES_fixed_point
77 typedef SkFixed SkGLTextScalar;
78 #define SK_TextGLType GL_FIXED
79
80 #define SkIntToTextGL(n) SkIntToFixed(n)
81 #define SkFixedToTextGL(x) (x)
82
83 #define SK_glTexParameteri(target, pname, param) \
84 glTexParameterx(target, pname, param)
85 #else
86 typedef float SkGLTextScalar;
87 #define SK_TextGLType SK_GLType
88 #define SK_GL_HAS_COLOR4UB
89
90 #define SkIntToTextGL(n) SkIntToGL(n)
91 #define SkFixedToTextGL(x) SkFixedToFloat(x)
92
93
94 #define SK_glTexParameteri(target, pname, param) \
95 glTexParameteri(target, pname, param)
96 #endif
97
98 ///////////////////////////////////////////////////////////////////////////////
99
100 // text has its own vertex class, since it may want to be in fixed point (given)
101 // that it starts with all integers) even when the default vertices are floats
102 struct SkGLTextVertex {
103 SkGLTextScalar fX;
104 SkGLTextScalar fY;
105
setISkGLTextVertex106 void setI(int x, int y) {
107 fX = SkIntToTextGL(x);
108 fY = SkIntToTextGL(y);
109 }
110
setXSkGLTextVertex111 void setX(SkFixed x, SkFixed y) {
112 fX = SkFixedToTextGL(x);
113 fY = SkFixedToTextGL(y);
114 }
115
116 // counter-clockwise fan
setIRectFanSkGLTextVertex117 void setIRectFan(int l, int t, int r, int b) {
118 SkGLTextVertex* SK_RESTRICT v = this;
119 v[0].setI(l, t);
120 v[1].setI(l, b);
121 v[2].setI(r, b);
122 v[3].setI(r, t);
123 }
124
125 // counter-clockwise fan
setXRectFanSkGLTextVertex126 void setXRectFan(SkFixed l, SkFixed t, SkFixed r, SkFixed b) {
127 SkGLTextVertex* SK_RESTRICT v = this;
128 v[0].setX(l, t);
129 v[1].setX(l, b);
130 v[2].setX(r, b);
131 v[3].setX(r, t);
132 }
133 };
134
135 struct SkGLVertex {
136 SkGLScalar fX;
137 SkGLScalar fY;
138
setGLSkGLVertex139 void setGL(SkGLScalar x, SkGLScalar y) {
140 fX = x;
141 fY = y;
142 }
143
setScalarsSkGLVertex144 void setScalars(SkScalar x, SkScalar y) {
145 fX = SkScalarToGL(x);
146 fY = SkScalarToGL(y);
147 }
148
setPointSkGLVertex149 void setPoint(const SkPoint& pt) {
150 fX = SkScalarToGL(pt.fX);
151 fY = SkScalarToGL(pt.fY);
152 }
153
setPointsSkGLVertex154 void setPoints(const SkPoint* SK_RESTRICT pts, int count) {
155 const SkScalar* SK_RESTRICT src = (const SkScalar*)pts;
156 SkGLScalar* SK_RESTRICT dst = (SkGLScalar*)this;
157 for (int i = 0; i < count; i++) {
158 *dst++ = SkScalarToGL(*src++);
159 *dst++ = SkScalarToGL(*src++);
160 }
161 }
162
163 // counter-clockwise fan
setRectFanSkGLVertex164 void setRectFan(SkScalar l, SkScalar t, SkScalar r, SkScalar b) {
165 SkGLVertex* v = this;
166 v[0].setScalars(l, t);
167 v[1].setScalars(l, b);
168 v[2].setScalars(r, b);
169 v[3].setScalars(r, t);
170 }
171
172 // counter-clockwise fan
setIRectFanSkGLVertex173 void setIRectFan(int l, int t, int r, int b) {
174 SkGLVertex* v = this;
175 v[0].setGL(SkIntToGL(l), SkIntToGL(t));
176 v[1].setGL(SkIntToGL(l), SkIntToGL(b));
177 v[2].setGL(SkIntToGL(r), SkIntToGL(b));
178 v[3].setGL(SkIntToGL(r), SkIntToGL(t));
179 }
180
181 // counter-clockwise fan
setRectFanSkGLVertex182 void setRectFan(const SkRect& r) {
183 this->setRectFan(r.fLeft, r.fTop, r.fRight, r.fBottom);
184 }
185
186 // counter-clockwise fan
setIRectFanSkGLVertex187 void setIRectFan(const SkIRect& r) {
188 this->setIRectFan(r.fLeft, r.fTop, r.fRight, r.fBottom);
189 }
190 };
191
192 struct SkGLMatrix {
193 SkGLScalar fMat[16];
194
resetSkGLMatrix195 void reset() {
196 sk_bzero(fMat, sizeof(fMat));
197 fMat[0] = fMat[5] = fMat[10] = fMat[15] = SK_GLScalar1;
198 }
199
setSkGLMatrix200 void set(const SkMatrix& m) {
201 sk_bzero(fMat, sizeof(fMat));
202 fMat[0] = SkScalarToGL(m[SkMatrix::kMScaleX]);
203 fMat[4] = SkScalarToGL(m[SkMatrix::kMSkewX]);
204 fMat[12] = SkScalarToGL(m[SkMatrix::kMTransX]);
205
206 fMat[1] = SkScalarToGL(m[SkMatrix::kMSkewY]);
207 fMat[5] = SkScalarToGL(m[SkMatrix::kMScaleY]);
208 fMat[13] = SkScalarToGL(m[SkMatrix::kMTransY]);
209
210 fMat[3] = SkPerspToGL(m[SkMatrix::kMPersp0]);
211 fMat[7] = SkPerspToGL(m[SkMatrix::kMPersp1]);
212 fMat[15] = SkPerspToGL(m[SkMatrix::kMPersp2]);
213
214 fMat[10] = SK_GLScalar1; // z-scale
215 }
216 };
217
218 class SkGL {
219 public:
220 static void SetColor(SkColor c);
221 static void SetAlpha(U8CPU alpha);
222 static void SetPaint(const SkPaint&, bool isPremul = true,
223 bool justAlpha = false);
224 static void SetPaintAlpha(const SkPaint& paint, bool isPremul = true) {
225 SetPaint(paint, isPremul, true);
226 }
227
228 static void SetRGBA(uint8_t rgba[], const SkColor src[], int count);
229 static void DumpError(const char caller[]);
230
231 static void Ortho(float left, float right, float bottom, float top,
232 float near, float far);
233
Translate(SkScalar dx,SkScalar dy)234 static inline void Translate(SkScalar dx, SkScalar dy) {
235 MAKE_GL(glTranslate)(SkScalarToGL(dx), SkScalarToGL(dy), 0);
236 }
237
Scale(SkScalar sx,SkScalar sy)238 static inline void Scale(SkScalar sx, SkScalar sy) {
239 MAKE_GL(glScale)(SkScalarToGL(sx), SkScalarToGL(sy), SK_GLScalar1);
240 }
241
Rotate(SkScalar angle)242 static inline void Rotate(SkScalar angle) {
243 MAKE_GL(glRotate)(SkScalarToGL(angle), 0, 0, SK_GLScalar1);
244 }
245
MultMatrix(const SkMatrix & m)246 static inline void MultMatrix(const SkMatrix& m) {
247 SkGLMatrix glm;
248 glm.set(m);
249 MAKE_GL(glMultMatrix)(glm.fMat);
250 }
251
LoadMatrix(const SkMatrix & m)252 static inline void LoadMatrix(const SkMatrix& m) {
253 SkGLMatrix glm;
254 glm.set(m);
255 MAKE_GL(glLoadMatrix)(glm.fMat);
256 }
257
258 static void Scissor(const SkIRect&, int viewportHeight);
259
260 // return the byte size for the associated texture memory. This doesn't
261 // always == bitmap.getSize(), since on a given port we may have to change
262 // the format when the bitmap's pixels are copied over to GL
263 static size_t ComputeTextureMemorySize(const SkBitmap&);
264 // return 0 on failure
265 static GLuint BindNewTexture(const SkBitmap&, SkPoint* dimension);
266
267 static void SetTexParams(bool filter,
268 SkShader::TileMode tx, SkShader::TileMode ty);
269 static void SetTexParamsClamp(bool filter);
270
271 static void DrawVertices(int count, GLenum mode,
272 const SkGLVertex* SK_RESTRICT vertex,
273 const SkGLVertex* SK_RESTRICT texCoords,
274 const uint8_t* SK_RESTRICT colorArray,
275 const uint16_t* SK_RESTRICT indexArray,
276 SkGLClipIter*);
277
278 static void PrepareForFillPath(SkPaint* paint);
279 static void FillPath(const SkPath& path, const SkPaint& paint, bool useTex,
280 SkGLClipIter*);
281 static void DrawPath(const SkPath& path, bool useTex, SkGLClipIter*);
282 };
283
284 #include "SkRegion.h"
285
286 class SkGLClipIter : public SkRegion::Iterator {
287 public:
SkGLClipIter(int viewportHeight)288 SkGLClipIter(int viewportHeight) : fViewportHeight(viewportHeight) {}
289
290 // call rewind only if this is non-null
safeRewind()291 void safeRewind() {
292 if (this) {
293 this->rewind();
294 }
295 }
296
scissor()297 void scissor() {
298 SkASSERT(!this->done());
299 SkGL::Scissor(this->rect(), fViewportHeight);
300 }
301
302 private:
303 const int fViewportHeight;
304 };
305
306 #endif
307
308