blob: ad80d36cbaa2f6a41576bf546d4c043d8cd8d072 [file] [log] [blame]
Romain Guye4d01122010-06-16 18:44:05 -07001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Romain Guy5b3b3522010-10-27 18:57:51 -070017#ifndef ANDROID_HWUI_OPENGL_RENDERER_H
18#define ANDROID_HWUI_OPENGL_RENDERER_H
Romain Guy9d5316e2010-06-24 19:30:36 -070019
20#include <GLES2/gl2.h>
21#include <GLES2/gl2ext.h>
Romain Guy85bf02f2010-06-22 13:11:24 -070022
Romain Guyce0537b2010-06-29 21:05:21 -070023#include <SkBitmap.h>
Romain Guyf6a11b82010-06-23 17:47:49 -070024#include <SkMatrix.h>
Romain Guyce0537b2010-06-29 21:05:21 -070025#include <SkPaint.h>
Romain Guy079ba2c2010-07-16 14:12:24 -070026#include <SkRegion.h>
Romain Guyd27977d2010-07-14 19:18:51 -070027#include <SkShader.h>
Romain Guy85bf02f2010-06-22 13:11:24 -070028#include <SkXfermode.h>
Romain Guye4d01122010-06-16 18:44:05 -070029
Chet Haasedaf98e92011-01-10 14:10:36 -080030#include <utils/Functor.h>
Romain Guybb9524b2010-06-22 18:56:38 -070031#include <utils/RefBase.h>
Romain Guyba6be8a2012-04-23 18:22:09 -070032#include <utils/SortedVector.h>
Romain Guy86942302010-09-12 13:02:16 -070033#include <utils/Vector.h>
Romain Guybb9524b2010-06-22 18:56:38 -070034
Romain Guy79537452011-10-12 13:48:51 -070035#include <cutils/compiler.h>
36
Romain Guyc15008e2010-11-10 11:59:15 -080037#include "Debug.h"
Romain Guy51769a62010-07-23 00:28:00 -070038#include "Extensions.h"
Romain Guyf6a11b82010-06-23 17:47:49 -070039#include "Matrix.h"
Romain Guy5cbbce52010-06-27 22:59:20 -070040#include "Program.h"
Romain Guybb9524b2010-06-22 18:56:38 -070041#include "Rect.h"
Romain Guy5cbbce52010-06-27 22:59:20 -070042#include "Snapshot.h"
Romain Guyf7f93552010-07-08 19:17:03 -070043#include "Vertex.h"
Romain Guy06f96e22010-07-30 19:18:16 -070044#include "SkiaShader.h"
Romain Guydb1938e2010-08-02 18:50:22 -070045#include "SkiaColorFilter.h"
Romain Guyfb8b7632010-08-23 21:05:08 -070046#include "Caches.h"
Romain Guybb9524b2010-06-22 18:56:38 -070047
Romain Guye4d01122010-06-16 18:44:05 -070048namespace android {
Romain Guy9d5316e2010-06-24 19:30:36 -070049namespace uirenderer {
Romain Guye4d01122010-06-16 18:44:05 -070050
Romain Guyf6a11b82010-06-23 17:47:49 -070051///////////////////////////////////////////////////////////////////////////////
Romain Guyf6a11b82010-06-23 17:47:49 -070052// Renderer
53///////////////////////////////////////////////////////////////////////////////
54
Romain Guy0fe478e2010-11-08 12:08:41 -080055class DisplayList;
Chris Craik65cd6122012-12-10 17:56:27 -080056class VertexBuffer;
Romain Guyb051e892010-09-28 19:09:36 -070057
Romain Guy5cbbce52010-06-27 22:59:20 -070058/**
59 * OpenGL renderer used to draw accelerated 2D graphics. The API is a
60 * simplified version of Skia's Canvas API.
61 */
Romain Guy85bf02f2010-06-22 13:11:24 -070062class OpenGLRenderer {
Romain Guye4d01122010-06-16 18:44:05 -070063public:
Romain Guy79537452011-10-12 13:48:51 -070064 ANDROID_API OpenGLRenderer();
Romain Guye2d345e2010-09-24 18:39:22 -070065 virtual ~OpenGLRenderer();
Romain Guye4d01122010-06-16 18:44:05 -070066
Romain Guy17112ad2012-08-07 11:24:39 -070067 /**
Romain Guyef359272013-01-31 19:07:29 -080068 * Sets the name of this renderer. The name is optional and
69 * empty by default. If the pointer is null the name is set
70 * to the empty string.
71 */
72 ANDROID_API void setName(const char* name);
73
74 /**
75 * Returns the name of this renderer as UTF8 string.
76 * The returned pointer is never null.
77 */
78 ANDROID_API const char* getName() const;
79
80 /**
Romain Guy87e2f7572012-09-24 11:37:12 -070081 * Read externally defined properties to control the behavior
82 * of the renderer.
83 */
84 ANDROID_API void initProperties();
85
86 /**
Romain Guy17112ad2012-08-07 11:24:39 -070087 * Indicates whether this renderer executes drawing commands immediately.
88 * If this method returns true, the drawing commands will be executed
89 * later.
90 */
Romain Guy49c5fc02012-05-15 11:10:01 -070091 virtual bool isDeferred();
92
Romain Guy17112ad2012-08-07 11:24:39 -070093 /**
94 * Sets the dimension of the underlying drawing surface. This method must
95 * be called at least once every time the drawing surface changes size.
96 *
97 * @param width The width in pixels of the underlysing surface
98 * @param height The height in pixels of the underlysing surface
99 */
Romain Guyb051e892010-09-28 19:09:36 -0700100 virtual void setViewport(int width, int height);
Romain Guye2d345e2010-09-24 18:39:22 -0700101
Romain Guy17112ad2012-08-07 11:24:39 -0700102 /**
103 * Prepares the renderer to draw a frame. This method must be invoked
104 * at the beginning of each frame. When this method is invoked, the
105 * entire drawing surface is assumed to be redrawn.
106 *
107 * @param opaque If true, the target surface is considered opaque
108 * and will not be cleared. If false, the target surface
109 * will be cleared
110 */
Romain Guy7c25aab2012-10-18 15:05:02 -0700111 ANDROID_API status_t prepare(bool opaque);
Romain Guye2d345e2010-09-24 18:39:22 -0700112
Romain Guy17112ad2012-08-07 11:24:39 -0700113 /**
114 * Prepares the renderer to draw a frame. This method must be invoked
115 * at the beginning of each frame. Only the specified rectangle of the
116 * frame is assumed to be dirty. A clip will automatically be set to
117 * the specified rectangle.
118 *
119 * @param left The left coordinate of the dirty rectangle
120 * @param top The top coordinate of the dirty rectangle
121 * @param right The right coordinate of the dirty rectangle
122 * @param bottom The bottom coordinate of the dirty rectangle
123 * @param opaque If true, the target surface is considered opaque
124 * and will not be cleared. If false, the target surface
125 * will be cleared in the specified dirty rectangle
126 */
Romain Guy7c25aab2012-10-18 15:05:02 -0700127 virtual status_t prepareDirty(float left, float top, float right, float bottom, bool opaque);
Romain Guy17112ad2012-08-07 11:24:39 -0700128
129 /**
130 * Indicates the end of a frame. This method must be invoked whenever
131 * the caller is done rendering a frame.
132 */
133 virtual void finish();
Romain Guy6c319ca2011-01-11 14:29:25 -0800134
Romain Guyc89b14b2012-08-08 14:53:48 -0700135 /**
136 * This method must be invoked before handing control over to a draw functor.
137 * See callDrawGLFunction() for instance.
138 *
139 * This command must not be recorded inside display lists.
140 */
141 virtual void interrupt();
142
143 /**
144 * This method must be invoked after getting control back from a draw functor.
145 *
146 * This command must not be recorded inside display lists.
147 */
148 virtual void resume();
149
Romain Guy8f3b8e32012-03-27 16:33:45 -0700150 ANDROID_API status_t invokeFunctors(Rect& dirty);
Romain Guyba6be8a2012-04-23 18:22:09 -0700151 ANDROID_API void detachFunctor(Functor* functor);
152 ANDROID_API void attachFunctor(Functor* functor);
Romain Guy8f3b8e32012-03-27 16:33:45 -0700153 virtual status_t callDrawGLFunction(Functor* functor, Rect& dirty);
Romain Guy08ae3172010-06-21 19:35:50 -0700154
Romain Guy11cb6422012-09-21 00:39:43 -0700155 ANDROID_API void pushLayerUpdate(Layer* layer);
156 ANDROID_API void clearLayerUpdates();
157
Romain Guy79537452011-10-12 13:48:51 -0700158 ANDROID_API int getSaveCount() const;
Romain Guy4aa90572010-09-26 18:40:37 -0700159 virtual int save(int flags);
160 virtual void restore();
161 virtual void restoreToCount(int saveCount);
Romain Guybb9524b2010-06-22 18:56:38 -0700162
Romain Guye2d345e2010-09-24 18:39:22 -0700163 virtual int saveLayer(float left, float top, float right, float bottom,
Chet Haase5c13d892010-10-08 08:37:55 -0700164 SkPaint* p, int flags);
Romain Guye2d345e2010-09-24 18:39:22 -0700165 virtual int saveLayerAlpha(float left, float top, float right, float bottom,
166 int alpha, int flags);
Romain Guybd6b79b2010-06-26 00:13:53 -0700167
Romain Guy4aa90572010-09-26 18:40:37 -0700168 virtual void translate(float dx, float dy);
169 virtual void rotate(float degrees);
170 virtual void scale(float sx, float sy);
Romain Guy807daf72011-01-18 11:19:19 -0800171 virtual void skew(float sx, float sy);
Romain Guyf6a11b82010-06-23 17:47:49 -0700172
Romain Guy79537452011-10-12 13:48:51 -0700173 ANDROID_API void getMatrix(SkMatrix* matrix);
Romain Guy4aa90572010-09-26 18:40:37 -0700174 virtual void setMatrix(SkMatrix* matrix);
175 virtual void concatMatrix(SkMatrix* matrix);
Romain Guyf6a11b82010-06-23 17:47:49 -0700176
Romain Guy79537452011-10-12 13:48:51 -0700177 ANDROID_API const Rect& getClipBounds();
178 ANDROID_API bool quickReject(float left, float top, float right, float bottom);
Romain Guy8a4ac612012-07-17 17:32:48 -0700179 bool quickRejectNoScissor(float left, float top, float right, float bottom);
Romain Guy4aa90572010-09-26 18:40:37 -0700180 virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op);
Romain Guy735738c2012-12-03 12:34:51 -0800181 virtual bool clipPath(SkPath* path, SkRegion::Op op);
182 virtual bool clipRegion(SkRegion* region, SkRegion::Op op);
Chet Haasea23eed82012-04-12 15:19:04 -0700183 virtual Rect* getClipRect();
Romain Guybb9524b2010-06-22 18:56:38 -0700184
Chet Haase1271e2c2012-04-20 09:54:27 -0700185 virtual status_t drawDisplayList(DisplayList* displayList, Rect& dirty, int32_t flags,
186 uint32_t level = 0);
Chet Haaseed30fd82011-04-22 16:18:45 -0700187 virtual void outputDisplayList(DisplayList* displayList, uint32_t level = 0);
Chet Haase48659092012-05-31 15:21:51 -0700188 virtual status_t drawLayer(Layer* layer, float x, float y, SkPaint* paint);
189 virtual status_t drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint);
190 virtual status_t drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint);
191 virtual status_t drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop,
Romain Guye2d345e2010-09-24 18:39:22 -0700192 float srcRight, float srcBottom, float dstLeft, float dstTop,
Chet Haase5c13d892010-10-08 08:37:55 -0700193 float dstRight, float dstBottom, SkPaint* paint);
Chet Haase48659092012-05-31 15:21:51 -0700194 virtual status_t drawBitmapData(SkBitmap* bitmap, float left, float top, SkPaint* paint);
195 virtual status_t drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight,
Romain Guy5a7b4662011-01-20 19:09:30 -0800196 float* vertices, int* colors, SkPaint* paint);
Chet Haase48659092012-05-31 15:21:51 -0700197 virtual status_t drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
Romain Guy4bb94202010-10-12 15:59:26 -0700198 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
Chet Haase5c13d892010-10-08 08:37:55 -0700199 float left, float top, float right, float bottom, SkPaint* paint);
Romain Guybe6f9dc2012-07-16 12:41:17 -0700200 status_t drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
201 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
202 float left, float top, float right, float bottom, int alpha, SkXfermode::Mode mode);
Chet Haase48659092012-05-31 15:21:51 -0700203 virtual status_t drawColor(int color, SkXfermode::Mode mode);
204 virtual status_t drawRect(float left, float top, float right, float bottom, SkPaint* paint);
205 virtual status_t drawRoundRect(float left, float top, float right, float bottom,
Romain Guy01d58e42011-01-19 21:54:02 -0800206 float rx, float ry, SkPaint* paint);
Chet Haase48659092012-05-31 15:21:51 -0700207 virtual status_t drawCircle(float x, float y, float radius, SkPaint* paint);
208 virtual status_t drawOval(float left, float top, float right, float bottom, SkPaint* paint);
209 virtual status_t drawArc(float left, float top, float right, float bottom,
Romain Guy8b2f5262011-01-23 16:15:02 -0800210 float startAngle, float sweepAngle, bool useCenter, SkPaint* paint);
Chet Haase48659092012-05-31 15:21:51 -0700211 virtual status_t drawPath(SkPath* path, SkPaint* paint);
212 virtual status_t drawLines(float* points, int count, SkPaint* paint);
213 virtual status_t drawPoints(float* points, int count, SkPaint* paint);
Chet Haase48659092012-05-31 15:21:51 -0700214 virtual status_t drawTextOnPath(const char* text, int bytesCount, int count, SkPath* path,
Romain Guy325740f2012-02-24 16:48:34 -0800215 float hOffset, float vOffset, SkPaint* paint);
Chet Haase48659092012-05-31 15:21:51 -0700216 virtual status_t drawPosText(const char* text, int bytesCount, int count,
Romain Guy325740f2012-02-24 16:48:34 -0800217 const float* positions, SkPaint* paint);
Romain Guyc2525952012-07-27 16:41:22 -0700218 virtual status_t drawText(const char* text, int bytesCount, int count, float x, float y,
Raph Levien996e57c2012-07-23 15:22:52 -0700219 const float* positions, SkPaint* paint, float length = -1.0f);
Romain Guy672433d2013-01-04 19:05:13 -0800220 virtual status_t drawRects(const float* rects, int count, SkPaint* paint);
Romain Guy08ae3172010-06-21 19:35:50 -0700221
Romain Guy4aa90572010-09-26 18:40:37 -0700222 virtual void resetShader();
223 virtual void setupShader(SkiaShader* shader);
Romain Guyd27977d2010-07-14 19:18:51 -0700224
Romain Guy4aa90572010-09-26 18:40:37 -0700225 virtual void resetColorFilter();
226 virtual void setupColorFilter(SkiaColorFilter* filter);
Romain Guydb1938e2010-08-02 18:50:22 -0700227
Romain Guy4aa90572010-09-26 18:40:37 -0700228 virtual void resetShadow();
229 virtual void setupShadow(float radius, float dx, float dy, int color);
Romain Guy1e45aae2010-08-13 19:39:53 -0700230
Romain Guy5ff9df62012-01-23 17:09:05 -0800231 virtual void resetPaintFilter();
232 virtual void setupPaintFilter(int clearBits, int setBits);
233
234 SkPaint* filterPaint(SkPaint* paint);
235
Romain Guy672433d2013-01-04 19:05:13 -0800236 ANDROID_API bool isCurrentTransformSimple() {
237 return mSnapshot->transform->isSimple();
238 }
239
Romain Guy17112ad2012-08-07 11:24:39 -0700240 /**
Romain Guy17112ad2012-08-07 11:24:39 -0700241 * Sets the alpha on the current snapshot. This alpha value will be modulated
242 * with other alpha values when drawing primitives.
243 */
244 void setAlpha(float alpha) {
245 mSnapshot->alpha = alpha;
246 }
247
248 /**
249 * Inserts a named group marker in the stream of GL commands. This marker
250 * can be used by tools to group commands into logical groups. A call to
251 * this method must always be followed later on by a call to endMark().
252 */
Romain Guy13631f32012-01-30 17:41:55 -0800253 void startMark(const char* name) const;
Romain Guy17112ad2012-08-07 11:24:39 -0700254
255 /**
256 * Closes the last group marker opened by startMark().
257 */
Romain Guy13631f32012-01-30 17:41:55 -0800258 void endMark() const;
259
Chet Haased15ebf22012-09-05 11:40:29 -0700260 /**
261 * Gets the alpha and xfermode out of a paint object. If the paint is null
262 * alpha will be 255 and the xfermode will be SRC_OVER. This method does
263 * not multiply the paint's alpha by the current snapshot's alpha.
264 *
265 * @param paint The paint to extract values from
266 * @param alpha Where to store the resulting alpha
267 * @param mode Where to store the resulting xfermode
268 */
269 static inline void getAlphaAndModeDirect(SkPaint* paint, int* alpha, SkXfermode::Mode* mode) {
270 if (paint) {
271 *mode = getXfermode(paint->getXfermode());
272
273 // Skia draws using the color's alpha channel if < 255
274 // Otherwise, it uses the paint's alpha
275 int color = paint->getColor();
276 *alpha = (color >> 24) & 0xFF;
277 if (*alpha == 255) {
278 *alpha = paint->getAlpha();
279 }
280 } else {
281 *mode = SkXfermode::kSrcOver_Mode;
282 *alpha = 255;
283 }
284 }
285
Romain Guye2d345e2010-09-24 18:39:22 -0700286protected:
287 /**
Romain Guy35643dd2012-09-18 15:40:58 -0700288 * Computes the projection matrix, initialize the first snapshot
289 * and stores the dimensions of the render target.
290 */
291 void initViewport(int width, int height);
292
293 /**
Romain Guy7c25aab2012-10-18 15:05:02 -0700294 * Clears the underlying surface if needed.
295 */
296 virtual status_t clear(float left, float top, float right, float bottom, bool opaque);
297
298 /**
Romain Guy35643dd2012-09-18 15:40:58 -0700299 * Call this method after updating a layer during a drawing pass.
300 */
301 void resumeAfterLayer();
302
303 /**
Romain Guy8ce00302013-01-15 18:51:42 -0800304 * This method is called whenever a stencil buffer is required. Subclasses
305 * should override this method and call attachStencilBufferToLayer() on the
306 * appropriate layer(s).
307 */
308 virtual void ensureStencilBuffer();
309
310 /**
311 * Obtains a stencil render buffer (allocating it if necessary) and
312 * attaches it to the specified layer.
313 */
314 void attachStencilBufferToLayer(Layer* layer);
315
316 /**
Romain Guye2d345e2010-09-24 18:39:22 -0700317 * Compose the layer defined in the current snapshot with the layer
318 * defined by the previous snapshot.
319 *
320 * The current snapshot *must* be a layer (flag kFlagIsLayer set.)
321 *
322 * @param curent The current snapshot containing the layer to compose
323 * @param previous The previous snapshot to compose the current layer with
324 */
325 virtual void composeLayer(sp<Snapshot> current, sp<Snapshot> previous);
Romain Guy694b5192010-07-21 21:33:20 -0700326
Romain Guyada830f2011-01-13 12:13:20 -0800327 /**
Romain Guyf219da52011-01-16 12:54:25 -0800328 * Marks the specified region as dirty at the specified bounds.
Romain Guyada830f2011-01-13 12:13:20 -0800329 */
Romain Guyf219da52011-01-16 12:54:25 -0800330 void dirtyLayerUnchecked(Rect& bounds, Region* region);
Romain Guyada830f2011-01-13 12:13:20 -0800331
332 /**
Romain Guyf219da52011-01-16 12:54:25 -0800333 * Returns the current snapshot.
Romain Guyada830f2011-01-13 12:13:20 -0800334 */
Romain Guyf219da52011-01-16 12:54:25 -0800335 sp<Snapshot> getSnapshot() {
336 return mSnapshot;
337 }
Romain Guyada830f2011-01-13 12:13:20 -0800338
Romain Guy42f3a4b2011-01-19 13:42:26 -0800339 /**
340 * Returns the region of the current layer.
341 */
Romain Guyf219da52011-01-16 12:54:25 -0800342 virtual Region* getRegion() {
343 return mSnapshot->region;
344 }
345
Romain Guy42f3a4b2011-01-19 13:42:26 -0800346 /**
347 * Indicates whether rendering is currently targeted at a layer.
348 */
Romain Guyf219da52011-01-16 12:54:25 -0800349 virtual bool hasLayer() {
350 return (mSnapshot->flags & Snapshot::kFlagFboTarget) && mSnapshot->region;
351 }
Romain Guy1bd1bad2011-01-14 20:07:20 -0800352
Romain Guy42f3a4b2011-01-19 13:42:26 -0800353 /**
354 * Returns the name of the FBO this renderer is rendering into.
355 */
356 virtual GLint getTargetFbo() {
357 return 0;
358 }
359
Romain Guy77a81162011-06-14 16:45:55 -0700360 /**
361 * Renders the specified layer as a textured quad.
362 *
363 * @param layer The layer to render
364 * @param rect The bounds of the layer
365 */
366 void drawTextureLayer(Layer* layer, const Rect& rect);
367
Romain Guybe6f9dc2012-07-16 12:41:17 -0700368 /**
369 * Gets the alpha and xfermode out of a paint object. If the paint is null
370 * alpha will be 255 and the xfermode will be SRC_OVER.
371 *
372 * @param paint The paint to extract values from
373 * @param alpha Where to store the resulting alpha
374 * @param mode Where to store the resulting xfermode
375 */
376 inline void getAlphaAndMode(SkPaint* paint, int* alpha, SkXfermode::Mode* mode);
377
378 /**
Romain Guybe6f9dc2012-07-16 12:41:17 -0700379 * Safely retrieves the mode from the specified xfermode. If the specified
380 * xfermode is null, the mode is assumed to be SkXfermode::kSrcOver_Mode.
381 */
382 static inline SkXfermode::Mode getXfermode(SkXfermode* mode) {
383 SkXfermode::Mode resultMode;
384 if (!SkXfermode::AsMode(mode, &resultMode)) {
385 resultMode = SkXfermode::kSrcOver_Mode;
386 }
387 return resultMode;
388 }
389
Romain Guy11cb6422012-09-21 00:39:43 -0700390 /**
391 * Set to true to suppress error checks at the end of a frame.
392 */
393 virtual bool suppressErrorChecks() {
394 return false;
395 }
396
Romain Guy7c25aab2012-10-18 15:05:02 -0700397 Caches& getCaches() {
398 return mCaches;
399 }
400
Romain Guy85bf02f2010-06-22 13:11:24 -0700401private:
Romain Guy5cbbce52010-06-27 22:59:20 -0700402 /**
Romain Guydcfc8362013-01-03 13:08:57 -0800403 * Discards the content of the framebuffer if supported by the driver.
404 * This method should be called at the beginning of a frame to optimize
405 * rendering on some tiler architectures.
406 */
407 void discardFramebuffer(float left, float top, float right, float bottom);
408
409 /**
Romain Guyddf74372012-05-22 14:07:07 -0700410 * Ensures the state of the renderer is the same as the state of
411 * the GL context.
412 */
413 void syncState();
414
415 /**
Romain Guy2b7028e2012-09-19 17:25:38 -0700416 * Tells the GPU what part of the screen is about to be redrawn.
Romain Guyc3fedaf2013-01-29 17:26:25 -0800417 * This method will use the clip rect that we started drawing the
418 * frame with.
Romain Guy2b7028e2012-09-19 17:25:38 -0700419 * This method needs to be invoked every time getTargetFbo() is
420 * bound again.
421 */
Romain Guy57b52682012-09-20 17:38:46 -0700422 void startTiling(const sp<Snapshot>& snapshot, bool opaque = false);
Romain Guy2b7028e2012-09-19 17:25:38 -0700423
424 /**
Romain Guyc3fedaf2013-01-29 17:26:25 -0800425 * Tells the GPU what part of the screen is about to be redrawn.
426 * This method needs to be invoked every time getTargetFbo() is
427 * bound again.
428 */
429 void startTiling(const Rect& clip, int windowHeight, bool opaque = false);
430
431 /**
Romain Guy2b7028e2012-09-19 17:25:38 -0700432 * Tells the GPU that we are done drawing the frame or that we
433 * are switching to another render target.
434 */
435 void endTiling();
436
437 /**
Romain Guy5cbbce52010-06-27 22:59:20 -0700438 * Saves the current state of the renderer as a new snapshot.
439 * The new snapshot is saved in mSnapshot and the previous snapshot
440 * is linked from mSnapshot->previous.
441 *
Romain Guy8aef54f2010-09-01 15:13:49 -0700442 * @param flags The save flags; see SkCanvas for more information
443 *
Romain Guy5cbbce52010-06-27 22:59:20 -0700444 * @return The new save count. This value can be passed to #restoreToCount()
445 */
Romain Guy8aef54f2010-09-01 15:13:49 -0700446 int saveSnapshot(int flags);
Romain Guy5cbbce52010-06-27 22:59:20 -0700447
448 /**
449 * Restores the current snapshot; mSnapshot becomes mSnapshot->previous.
450 *
Romain Guy2542d192010-08-18 11:47:12 -0700451 * @return True if the clip was modified.
Romain Guy5cbbce52010-06-27 22:59:20 -0700452 */
Romain Guybb9524b2010-06-22 18:56:38 -0700453 bool restoreSnapshot();
454
Romain Guy5cbbce52010-06-27 22:59:20 -0700455 /**
456 * Sets the clipping rectangle using glScissor. The clip is defined by
457 * the current snapshot's clipRect member.
458 */
Romain Guybb9524b2010-06-22 18:56:38 -0700459 void setScissorFromClip();
460
Romain Guy5cbbce52010-06-27 22:59:20 -0700461 /**
Romain Guy8ce00302013-01-15 18:51:42 -0800462 * Sets the clipping region using the stencil buffer. The clip region
463 * is defined by the current snapshot's clipRegion member.
464 */
465 void setStencilFromClip();
466
467 /**
Romain Guy35643dd2012-09-18 15:40:58 -0700468 * Performs a quick reject but does not affect the scissor. Returns
469 * the transformed rect to test and the current clip.
470 */
471 bool quickRejectNoScissor(float left, float top, float right, float bottom,
472 Rect& transformed, Rect& clip);
473
474 /**
Chris Craikcb4d6002012-09-25 12:00:29 -0700475 * Performs a quick reject but adjust the bounds to account for stroke width if necessary
476 */
477 bool quickRejectPreStroke(float left, float top, float right, float bottom, SkPaint* paint);
478
479 /**
Romain Guyd55a8612010-06-28 17:42:46 -0700480 * Creates a new layer stored in the specified snapshot.
481 *
482 * @param snapshot The snapshot associated with the new layer
483 * @param left The left coordinate of the layer
484 * @param top The top coordinate of the layer
485 * @param right The right coordinate of the layer
486 * @param bottom The bottom coordinate of the layer
487 * @param alpha The translucency of the layer
488 * @param mode The blending mode of the layer
489 * @param flags The layer save flags
Romain Guyeb993562010-10-05 18:14:38 -0700490 * @param previousFbo The name of the current framebuffer
Romain Guyd55a8612010-06-28 17:42:46 -0700491 *
492 * @return True if the layer was successfully created, false otherwise
493 */
Chet Haased48885a2012-08-28 17:43:28 -0700494 bool createLayer(float left, float top, float right, float bottom,
Romain Guyeb993562010-10-05 18:14:38 -0700495 int alpha, SkXfermode::Mode mode, int flags, GLuint previousFbo);
Romain Guyd55a8612010-06-28 17:42:46 -0700496
497 /**
Romain Guy5b3b3522010-10-27 18:57:51 -0700498 * Creates a new layer stored in the specified snapshot as an FBO.
499 *
500 * @param layer The layer to store as an FBO
501 * @param snapshot The snapshot associated with the new layer
502 * @param bounds The bounds of the layer
503 * @param previousFbo The name of the current framebuffer
504 */
Chet Haased48885a2012-08-28 17:43:28 -0700505 bool createFboLayer(Layer* layer, Rect& bounds, Rect& clip, GLuint previousFbo);
Romain Guy5b3b3522010-10-27 18:57:51 -0700506
507 /**
508 * Compose the specified layer as a region.
509 *
510 * @param layer The layer to compose
511 * @param rect The layer's bounds
512 */
513 void composeLayerRegion(Layer* layer, const Rect& rect);
514
515 /**
516 * Compose the specified layer as a simple rectangle.
517 *
518 * @param layer The layer to compose
519 * @param rect The layer's bounds
520 * @param swap If true, the source and destination are swapped
521 */
522 void composeLayerRect(Layer* layer, const Rect& rect, bool swap = false);
523
Romain Guy54be1cd2011-06-13 19:04:27 -0700524 /**
525 * Clears all the regions corresponding to the current list of layers.
526 * This method MUST be invoked before any drawing operation.
527 */
528 void clearLayerRegions();
529
530 /**
Romain Guyf219da52011-01-16 12:54:25 -0800531 * Mark the layer as dirty at the specified coordinates. The coordinates
532 * are transformed with the supplied matrix.
533 */
534 void dirtyLayer(const float left, const float top,
535 const float right, const float bottom, const mat4 transform);
536
537 /**
538 * Mark the layer as dirty at the specified coordinates.
539 */
540 void dirtyLayer(const float left, const float top,
541 const float right, const float bottom);
542
543 /**
Romain Guy5cbbce52010-06-27 22:59:20 -0700544 * Draws a colored rectangle with the specified color. The specified coordinates
Romain Guy735738c2012-12-03 12:34:51 -0800545 * are transformed by the current snapshot's transform matrix unless specified
546 * otherwise.
Romain Guy5cbbce52010-06-27 22:59:20 -0700547 *
548 * @param left The left coordinate of the rectangle
549 * @param top The top coordinate of the rectangle
550 * @param right The right coordinate of the rectangle
551 * @param bottom The bottom coordinate of the rectangle
552 * @param color The rectangle's ARGB color, defined as a packed 32 bits word
Romain Guy026c5e162010-06-28 17:12:22 -0700553 * @param mode The Skia xfermode to use
Romain Guy3d58c032010-07-14 16:34:53 -0700554 * @param ignoreTransform True if the current transform should be ignored
Romain Guy5cbbce52010-06-27 22:59:20 -0700555 */
Romain Guy026c5e162010-06-28 17:12:22 -0700556 void drawColorRect(float left, float top, float right, float bottom,
Romain Guy1c740bc2010-09-13 18:00:09 -0700557 int color, SkXfermode::Mode mode, bool ignoreTransform = false);
Romain Guy5cbbce52010-06-27 22:59:20 -0700558
Romain Guy54be1cd2011-06-13 19:04:27 -0700559 /**
Romain Guy735738c2012-12-03 12:34:51 -0800560 * Draws a series of colored rectangles with the specified color. The specified
561 * coordinates are transformed by the current snapshot's transform matrix unless
562 * specified otherwise.
563 *
564 * @param rects A list of rectangles, 4 floats (left, top, right, bottom)
565 * per rectangle
566 * @param color The rectangles' ARGB color, defined as a packed 32 bits word
567 * @param mode The Skia xfermode to use
568 * @param ignoreTransform True if the current transform should be ignored
Romain Guy8ce00302013-01-15 18:51:42 -0800569 * @param dirty True if calling this method should dirty the current layer
Romain Guy3bbacf22013-02-06 16:51:04 -0800570 * @param clip True if the rects should be clipped, false otherwise
Romain Guy735738c2012-12-03 12:34:51 -0800571 */
572 status_t drawColorRects(const float* rects, int count, int color,
Romain Guy3bbacf22013-02-06 16:51:04 -0800573 SkXfermode::Mode mode, bool ignoreTransform = false,
574 bool dirty = true, bool clip = true);
Romain Guy735738c2012-12-03 12:34:51 -0800575
576 /**
Romain Guy54be1cd2011-06-13 19:04:27 -0700577 * Draws the shape represented by the specified path texture.
578 * This method invokes drawPathTexture() but takes into account
579 * the extra left/top offset and the texture offset to correctly
580 * position the final shape.
581 *
582 * @param left The left coordinate of the shape to render
583 * @param top The top coordinate of the shape to render
584 * @param texture The texture reprsenting the shape
585 * @param paint The paint to draw the shape with
586 */
Chet Haase48659092012-05-31 15:21:51 -0700587 status_t drawShape(float left, float top, const PathTexture* texture, SkPaint* paint);
Romain Guy54be1cd2011-06-13 19:04:27 -0700588
589 /**
Romain Guy54be1cd2011-06-13 19:04:27 -0700590 * Draws the specified texture as an alpha bitmap. Alpha bitmaps obey
591 * different compositing rules.
592 *
593 * @param texture The texture to draw with
594 * @param left The x coordinate of the bitmap
595 * @param top The y coordinate of the bitmap
596 * @param paint The paint to render with
597 */
Romain Guya168d732011-03-18 16:50:13 -0700598 void drawAlphaBitmap(Texture* texture, float left, float top, SkPaint* paint);
599
Romain Guy54be1cd2011-06-13 19:04:27 -0700600 /**
Chris Craik65cd6122012-12-10 17:56:27 -0800601 * Renders a strip of polygons with the specified paint, used for tessellated geometry.
602 *
603 * @param vertexBuffer The VertexBuffer to be drawn
604 * @param paint The paint to render with
605 * @param useOffset Offset the vertexBuffer (used in drawing non-AA lines)
606 */
607 status_t drawVertexBuffer(const VertexBuffer& vertexBuffer, SkPaint* paint,
608 bool useOffset = false);
609
610 /**
Chris Craik710f46d2012-09-17 17:25:49 -0700611 * Renders the convex hull defined by the specified path as a strip of polygons.
Romain Guy54be1cd2011-06-13 19:04:27 -0700612 *
Chris Craik710f46d2012-09-17 17:25:49 -0700613 * @param path The hull of the path to draw
Chris Craikcb4d6002012-09-25 12:00:29 -0700614 * @param paint The paint to render with
Romain Guy54be1cd2011-06-13 19:04:27 -0700615 */
Chris Craik65cd6122012-12-10 17:56:27 -0800616 status_t drawConvexPath(const SkPath& path, SkPaint* paint);
Chet Haase858aa932011-05-12 09:06:00 -0700617
Romain Guy5cbbce52010-06-27 22:59:20 -0700618 /**
619 * Draws a textured rectangle with the specified texture. The specified coordinates
620 * are transformed by the current snapshot's transform matrix.
621 *
622 * @param left The left coordinate of the rectangle
623 * @param top The top coordinate of the rectangle
624 * @param right The right coordinate of the rectangle
625 * @param bottom The bottom coordinate of the rectangle
626 * @param texture The texture name to map onto the rectangle
627 * @param alpha An additional translucency parameter, between 0.0f and 1.0f
Romain Guyd55a8612010-06-28 17:42:46 -0700628 * @param mode The blending mode
Romain Guyc1396e92010-06-30 17:56:19 -0700629 * @param blend True if the texture contains an alpha channel
Romain Guy5cbbce52010-06-27 22:59:20 -0700630 */
Romain Guybd6b79b2010-06-26 00:13:53 -0700631 void drawTextureRect(float left, float top, float right, float bottom, GLuint texture,
Romain Guya9794742010-07-13 11:37:54 -0700632 float alpha, SkXfermode::Mode mode, bool blend);
Romain Guyc7d53492010-06-25 13:41:57 -0700633
Romain Guy026c5e162010-06-28 17:12:22 -0700634 /**
Romain Guy82ba8142010-07-09 13:25:56 -0700635 * Draws a textured rectangle with the specified texture. The specified coordinates
636 * are transformed by the current snapshot's transform matrix.
637 *
638 * @param left The left coordinate of the rectangle
639 * @param top The top coordinate of the rectangle
640 * @param right The right coordinate of the rectangle
641 * @param bottom The bottom coordinate of the rectangle
642 * @param texture The texture to use
643 * @param paint The paint containing the alpha, blending mode, etc.
Romain Guy82ba8142010-07-09 13:25:56 -0700644 */
Romain Guya9794742010-07-13 11:37:54 -0700645 void drawTextureRect(float left, float top, float right, float bottom,
Romain Guy8164c2d2010-10-25 18:03:28 -0700646 Texture* texture, SkPaint* paint);
Romain Guy82ba8142010-07-09 13:25:56 -0700647
648 /**
Romain Guy03750a02010-10-18 14:06:08 -0700649 * Draws a textured mesh with the specified texture. If the indices are omitted,
650 * the mesh is drawn as a simple quad. The mesh pointers become offsets when a
651 * VBO is bound.
Romain Guy82ba8142010-07-09 13:25:56 -0700652 *
653 * @param left The left coordinate of the rectangle
654 * @param top The top coordinate of the rectangle
655 * @param right The right coordinate of the rectangle
656 * @param bottom The bottom coordinate of the rectangle
657 * @param texture The texture name to map onto the rectangle
658 * @param alpha An additional translucency parameter, between 0.0f and 1.0f
659 * @param mode The blending mode
660 * @param blend True if the texture contains an alpha channel
Romain Guy82ba8142010-07-09 13:25:56 -0700661 * @param vertices The vertices that define the mesh
662 * @param texCoords The texture coordinates of each vertex
Romain Guy82ba8142010-07-09 13:25:56 -0700663 * @param elementsCount The number of elements in the mesh, required by indices
Romain Guyf607bdc2010-09-10 19:20:06 -0700664 * @param swapSrcDst Whether or not the src and dst blending operations should be swapped
665 * @param ignoreTransform True if the current transform should be ignored
Romain Guy03750a02010-10-18 14:06:08 -0700666 * @param vbo The VBO used to draw the mesh
Romain Guy5b3b3522010-10-27 18:57:51 -0700667 * @param ignoreScale True if the model view matrix should not be scaled
668 * @param dirty True if calling this method should dirty the current layer
Romain Guyf7f93552010-07-08 19:17:03 -0700669 */
670 void drawTextureMesh(float left, float top, float right, float bottom, GLuint texture,
Romain Guya9794742010-07-13 11:37:54 -0700671 float alpha, SkXfermode::Mode mode, bool blend,
Romain Guy6820ac82010-09-15 18:11:50 -0700672 GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,
Romain Guy5b3b3522010-10-27 18:57:51 -0700673 bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0,
674 bool ignoreScale = false, bool dirty = true);
Romain Guyf7f93552010-07-08 19:17:03 -0700675
Romain Guy886b2752013-01-04 12:26:18 -0800676 void drawAlpha8TextureMesh(float left, float top, float right, float bottom,
677 GLuint texture, bool hasColor, int color, int alpha, SkXfermode::Mode mode,
678 GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,
679 bool ignoreTransform, bool dirty = true);
680
Romain Guyf7f93552010-07-08 19:17:03 -0700681 /**
Romain Guy0a417492010-08-16 20:26:20 -0700682 * Draws text underline and strike-through if needed.
683 *
684 * @param text The text to decor
685 * @param bytesCount The number of bytes in the text
686 * @param length The length in pixels of the text, can be <= 0.0f to force a measurement
687 * @param x The x coordinate where the text will be drawn
688 * @param y The y coordinate where the text will be drawn
689 * @param paint The paint to draw the text with
690 */
691 void drawTextDecorations(const char* text, int bytesCount, float length,
692 float x, float y, SkPaint* paint);
Romain Guy1e45aae2010-08-13 19:39:53 -0700693
Raph Levien416a8472012-07-19 22:48:17 -0700694 /**
695 * Draws shadow layer on text (with optional positions).
696 *
697 * @param paint The paint to draw the shadow with
698 * @param text The text to draw
699 * @param bytesCount The number of bytes in the text
700 * @param count The number of glyphs in the text
701 * @param positions The x, y positions of individual glyphs (or NULL)
702 * @param fontRenderer The font renderer object
703 * @param alpha The alpha value for drawing the shadow
704 * @param mode The xfermode for drawing the shadow
705 * @param x The x coordinate where the shadow will be drawn
706 * @param y The y coordinate where the shadow will be drawn
707 */
708 void drawTextShadow(SkPaint* paint, const char* text, int bytesCount, int count,
709 const float* positions, FontRenderer& fontRenderer, int alpha, SkXfermode::Mode mode,
710 float x, float y);
711
Romain Guy54be1cd2011-06-13 19:04:27 -0700712 /**
713 * Draws a path texture. Path textures are alpha8 bitmaps that need special
714 * compositing to apply colors/filters/etc.
715 *
716 * @param texture The texture to render
717 * @param x The x coordinate where the texture will be drawn
718 * @param y The y coordinate where the texture will be drawn
719 * @param paint The paint to draw the texture with
720 */
Raph Levien416a8472012-07-19 22:48:17 -0700721 void drawPathTexture(const PathTexture* texture, float x, float y, SkPaint* paint);
Romain Guy01d58e42011-01-19 21:54:02 -0800722
Romain Guy1e45aae2010-08-13 19:39:53 -0700723 /**
Romain Guyac670c02010-07-27 17:39:27 -0700724 * Resets the texture coordinates stored in mMeshVertices. Setting the values
Romain Guy026c5e162010-06-28 17:12:22 -0700725 * back to default is achieved by calling:
726 *
Romain Guy8ba548f2010-06-30 19:21:21 -0700727 * resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
Romain Guy026c5e162010-06-28 17:12:22 -0700728 *
729 * @param u1 The left coordinate of the texture
730 * @param v1 The bottom coordinate of the texture
731 * @param u2 The right coordinate of the texture
732 * @param v2 The top coordinate of the texture
733 */
734 void resetDrawTextureTexCoords(float u1, float v1, float u2, float v2);
735
Romain Guy8ba548f2010-06-30 19:21:21 -0700736 /**
Romain Guy746b7402010-10-26 16:27:31 -0700737 * Binds the specified texture. The texture unit must have been selected
738 * prior to calling this method.
Romain Guya1db5742010-07-20 13:09:13 -0700739 */
Romain Guy746b7402010-10-26 16:27:31 -0700740 inline void bindTexture(GLuint texture) {
741 glBindTexture(GL_TEXTURE_2D, texture);
742 }
743
744 /**
Romain Guyaa6c24c2011-04-28 18:40:04 -0700745 * Binds the specified EGLImage texture. The texture unit must have been selected
746 * prior to calling this method.
747 */
748 inline void bindExternalTexture(GLuint texture) {
749 glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
750 }
751
752 /**
Romain Guy82ba8142010-07-09 13:25:56 -0700753 * Enable or disable blending as necessary. This function sets the appropriate
754 * blend function based on the specified xfermode.
755 */
Romain Guyf607bdc2010-09-10 19:20:06 -0700756 inline void chooseBlending(bool blend, SkXfermode::Mode mode, ProgramDescription& description,
757 bool swapSrcDst = false);
Romain Guya5aed0d2010-09-09 14:42:43 -0700758
Romain Guyf607bdc2010-09-10 19:20:06 -0700759 /**
Romain Guyd27977d2010-07-14 19:18:51 -0700760 * Use the specified program with the current GL context. If the program is already
761 * in use, it will not be bound again. If it is not in use, the current program is
762 * marked unused and the specified program becomes used and becomes the new
763 * current program.
Romain Guy6926c722010-07-12 20:20:03 -0700764 *
Romain Guyd27977d2010-07-14 19:18:51 -0700765 * @param program The program to use
766 *
767 * @return true If the specified program was already in use, false otherwise.
Romain Guy260e1022010-07-12 14:41:06 -0700768 */
Romain Guy889f8d12010-07-29 14:37:42 -0700769 inline bool useProgram(Program* program);
Romain Guy260e1022010-07-12 14:41:06 -0700770
Romain Guy746b7402010-10-26 16:27:31 -0700771 /**
772 * Invoked before any drawing operation. This sets required state.
773 */
Romain Guy54be1cd2011-06-13 19:04:27 -0700774 void setupDraw(bool clear = true);
Romain Guy17112ad2012-08-07 11:24:39 -0700775
Romain Guy70ca14e2010-12-13 18:24:33 -0800776 /**
777 * Various methods to setup OpenGL rendering.
778 */
779 void setupDrawWithTexture(bool isAlpha8 = false);
Romain Guyff316ec2013-02-13 18:39:43 -0800780 void setupDrawWithTextureAndColor(bool isAlpha8 = false);
Romain Guyaa6c24c2011-04-28 18:40:04 -0700781 void setupDrawWithExternalTexture();
Romain Guy15bc6432011-12-13 13:11:32 -0800782 void setupDrawNoTexture();
Chris Craik710f46d2012-09-17 17:25:49 -0700783 void setupDrawAA();
Romain Guyed6fcb02011-03-21 13:11:28 -0700784 void setupDrawPoint(float pointSize);
Romain Guy8d0d4782010-12-14 20:13:35 -0800785 void setupDrawColor(int color, int alpha);
Romain Guy70ca14e2010-12-13 18:24:33 -0800786 void setupDrawColor(float r, float g, float b, float a);
Romain Guy86568192010-12-14 15:55:39 -0800787 void setupDrawAlpha8Color(int color, int alpha);
Romain Guy41210632012-07-16 17:04:24 -0700788 void setupDrawTextGamma(const SkPaint* paint);
Romain Guy70ca14e2010-12-13 18:24:33 -0800789 void setupDrawShader();
790 void setupDrawColorFilter();
791 void setupDrawBlending(SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
792 bool swapSrcDst = false);
793 void setupDrawBlending(bool blend = true, SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
794 bool swapSrcDst = false);
795 void setupDrawProgram();
796 void setupDrawDirtyRegionsDisabled();
Chet Haase8a5cc922011-04-26 07:28:09 -0700797 void setupDrawModelViewIdentity(bool offset = false);
Romain Guy70ca14e2010-12-13 18:24:33 -0800798 void setupDrawModelView(float left, float top, float right, float bottom,
799 bool ignoreTransform = false, bool ignoreModelView = false);
800 void setupDrawModelViewTranslate(float left, float top, float right, float bottom,
801 bool ignoreTransform = false);
Romain Guyed6fcb02011-03-21 13:11:28 -0700802 void setupDrawPointUniforms();
Romain Guy70ca14e2010-12-13 18:24:33 -0800803 void setupDrawColorUniforms();
Romain Guy86568192010-12-14 15:55:39 -0800804 void setupDrawPureColorUniforms();
Romain Guy8d0d4782010-12-14 20:13:35 -0800805 void setupDrawShaderIdentityUniforms();
Romain Guy70ca14e2010-12-13 18:24:33 -0800806 void setupDrawShaderUniforms(bool ignoreTransform = false);
807 void setupDrawColorFilterUniforms();
808 void setupDrawSimpleMesh();
809 void setupDrawTexture(GLuint texture);
Romain Guyaa6c24c2011-04-28 18:40:04 -0700810 void setupDrawExternalTexture(GLuint texture);
Romain Guy8f0095c2011-05-02 17:24:22 -0700811 void setupDrawTextureTransform();
812 void setupDrawTextureTransformUniforms(mat4& transform);
Romain Guy41210632012-07-16 17:04:24 -0700813 void setupDrawTextGammaUniforms();
Romain Guy8d0d4782010-12-14 20:13:35 -0800814 void setupDrawMesh(GLvoid* vertices, GLvoid* texCoords = NULL, GLuint vbo = 0);
Romain Guyff316ec2013-02-13 18:39:43 -0800815 void setupDrawMesh(GLvoid* vertices, GLvoid* texCoords, GLvoid* colors);
Romain Guy15bc6432011-12-13 13:11:32 -0800816 void setupDrawMeshIndices(GLvoid* vertices, GLvoid* texCoords);
Chet Haase5b0200b2011-04-13 17:58:08 -0700817 void setupDrawVertices(GLvoid* vertices);
Romain Guy70ca14e2010-12-13 18:24:33 -0800818 void finishDrawTexture();
Romain Guyf09ef512011-05-27 11:43:46 -0700819 void accountForClear(SkXfermode::Mode mode);
Romain Guy746b7402010-10-26 16:27:31 -0700820
Romain Guy11cb6422012-09-21 00:39:43 -0700821 bool updateLayer(Layer* layer, bool inFrame);
822 void updateLayers();
823
Romain Guy17112ad2012-08-07 11:24:39 -0700824 /**
825 * Renders the specified region as a series of rectangles. This method
826 * is used for debugging only.
827 */
Romain Guy3a3133d2011-02-01 22:59:58 -0800828 void drawRegionRects(const Region& region);
829
Romain Guy8ce00302013-01-15 18:51:42 -0800830 /**
831 * Renders the specified region as a series of rectangles. The region
832 * must be in screen-space coordinates.
833 */
834 void drawRegionRects(const SkRegion& region, int color, SkXfermode::Mode mode,
835 bool dirty = false);
836
837 /**
838 * Draws the current clip region if any. Only when DEBUG_CLIP_REGIONS
839 * is turned on.
840 */
841 void debugClip();
842
Romain Guy7c450aa2012-09-21 19:15:00 -0700843 void debugOverdraw(bool enable, bool clear);
844 void renderOverdraw();
845
Romain Guy746b7402010-10-26 16:27:31 -0700846 /**
847 * Should be invoked every time the glScissor is modified.
848 */
849 inline void dirtyClip() {
850 mDirtyClip = true;
851 }
852
Romain Guybb9524b2010-06-22 18:56:38 -0700853 // Dimensions of the drawing surface
854 int mWidth, mHeight;
855
Romain Guy85bf02f2010-06-22 13:11:24 -0700856 // Matrix used for ortho projection in shaders
Romain Guy260e1022010-07-12 14:41:06 -0700857 mat4 mOrthoMatrix;
Romain Guybb9524b2010-06-22 18:56:38 -0700858
Romain Guyc7d53492010-06-25 13:41:57 -0700859 // Model-view matrix used to position/size objects
860 mat4 mModelView;
861
Romain Guybb9524b2010-06-22 18:56:38 -0700862 // Number of saved states
863 int mSaveCount;
Romain Guyf6a11b82010-06-23 17:47:49 -0700864 // Base state
Romain Guyae5575b2010-07-29 18:48:04 -0700865 sp<Snapshot> mFirstSnapshot;
Romain Guybb9524b2010-06-22 18:56:38 -0700866 // Current state
867 sp<Snapshot> mSnapshot;
Romain Guy2b7028e2012-09-19 17:25:38 -0700868 // State used to define the clipping region
869 sp<Snapshot> mTilingSnapshot;
Romain Guy9d5316e2010-06-24 19:30:36 -0700870
871 // Shaders
Romain Guy06f96e22010-07-30 19:18:16 -0700872 SkiaShader* mShader;
Romain Guy026c5e162010-06-28 17:12:22 -0700873
Romain Guydb1938e2010-08-02 18:50:22 -0700874 // Color filters
875 SkiaColorFilter* mColorFilter;
876
Romain Guy026c5e162010-06-28 17:12:22 -0700877 // Used to draw textured quads
Romain Guyac670c02010-07-27 17:39:27 -0700878 TextureVertex mMeshVertices[4];
Romain Guyce0537b2010-06-29 21:05:21 -0700879
Romain Guy1e45aae2010-08-13 19:39:53 -0700880 // Drop shadow
881 bool mHasShadow;
882 float mShadowRadius;
883 float mShadowDx;
884 float mShadowDy;
885 int mShadowColor;
886
Romain Guy5ff9df62012-01-23 17:09:05 -0800887 // Draw filters
888 bool mHasDrawFilter;
889 int mPaintFilterClearBits;
890 int mPaintFilterSetBits;
891 SkPaint mFilteredPaint;
892
Romain Guy82ba8142010-07-09 13:25:56 -0700893 // Various caches
Romain Guyfb8b7632010-08-23 21:05:08 -0700894 Caches& mCaches;
Romain Guy3bbacf22013-02-06 16:51:04 -0800895 Extensions& mExtensions;
Romain Guy86942302010-09-12 13:02:16 -0700896
Romain Guy8f3b8e32012-03-27 16:33:45 -0700897 // List of rectangles to clear after saveLayer() is invoked
Romain Guy54be1cd2011-06-13 19:04:27 -0700898 Vector<Rect*> mLayers;
Romain Guy8f3b8e32012-03-27 16:33:45 -0700899 // List of functors to invoke after a frame is drawn
Romain Guyba6be8a2012-04-23 18:22:09 -0700900 SortedVector<Functor*> mFunctors;
Romain Guy11cb6422012-09-21 00:39:43 -0700901 // List of layers to update at the beginning of a frame
902 Vector<Layer*> mLayerUpdates;
Romain Guy54be1cd2011-06-13 19:04:27 -0700903
Romain Guy99bcdc52010-10-13 15:17:00 -0700904 // Indentity matrix
905 const mat4 mIdentity;
906
Romain Guy746b7402010-10-26 16:27:31 -0700907 // Indicates whether the clip must be restored
908 bool mDirtyClip;
909
Romain Guy70ca14e2010-12-13 18:24:33 -0800910 // The following fields are used to setup drawing
911 // Used to describe the shaders to generate
912 ProgramDescription mDescription;
913 // Color description
914 bool mColorSet;
915 float mColorA, mColorR, mColorG, mColorB;
916 // Indicates that the shader should get a color
917 bool mSetShaderColor;
918 // Current texture unit
919 GLuint mTextureUnit;
920 // Track dirty regions, true by default
921 bool mTrackDirtyRegions;
Romain Guy2b7028e2012-09-19 17:25:38 -0700922 // Indicate whether we are drawing an opaque frame
923 bool mOpaqueFrame;
Romain Guy70ca14e2010-12-13 18:24:33 -0800924
Romain Guy87e2f7572012-09-24 11:37:12 -0700925 // See PROPERTY_DISABLE_SCISSOR_OPTIMIZATION in
926 // Properties.h
927 bool mScissorOptimizationDisabled;
928
Romain Guy54c1a642012-09-27 17:55:46 -0700929 // No-ops start/endTiling when set
930 bool mSuppressTiling;
931
Romain Guyef359272013-01-31 19:07:29 -0800932 // Optional name of the renderer
933 String8 mName;
934
Romain Guyb051e892010-09-28 19:09:36 -0700935 friend class DisplayListRenderer;
936
Romain Guybb9524b2010-06-22 18:56:38 -0700937}; // class OpenGLRenderer
Romain Guye4d01122010-06-16 18:44:05 -0700938
Romain Guy9d5316e2010-06-24 19:30:36 -0700939}; // namespace uirenderer
Romain Guye4d01122010-06-16 18:44:05 -0700940}; // namespace android
941
Romain Guy5b3b3522010-10-27 18:57:51 -0700942#endif // ANDROID_HWUI_OPENGL_RENDERER_H