OpenGLRenderer.h revision 17112ad8a21a77620eb1ff14dcf8bdd6b7859712 
1/*
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
17#ifndef ANDROID_HWUI_OPENGL_RENDERER_H
18#define ANDROID_HWUI_OPENGL_RENDERER_H
19
20#include <GLES2/gl2.h>
21#include <GLES2/gl2ext.h>
22
23#include <SkBitmap.h>
24#include <SkMatrix.h>
25#include <SkPaint.h>
26#include <SkRegion.h>
27#include <SkShader.h>
28#include <SkXfermode.h>
29
30#include <utils/Functor.h>
31#include <utils/RefBase.h>
32#include <utils/SortedVector.h>
33#include <utils/Vector.h>
34
35#include <cutils/compiler.h>
36
37#include "Debug.h"
38#include "Extensions.h"
39#include "Matrix.h"
40#include "Program.h"
41#include "Rect.h"
42#include "Snapshot.h"
43#include "Vertex.h"
44#include "SkiaShader.h"
45#include "SkiaColorFilter.h"
46#include "Caches.h"
47
48namespace android {
49namespace uirenderer {
50
51///////////////////////////////////////////////////////////////////////////////
52// Renderer
53///////////////////////////////////////////////////////////////////////////////
54
55class DisplayList;
56
57/**
58 * OpenGL renderer used to draw accelerated 2D graphics. The API is a
59 * simplified version of Skia's Canvas API.
60 */
61class OpenGLRenderer {
62public:
63    ANDROID_API OpenGLRenderer();
64    virtual ~OpenGLRenderer();
65
66    /**
67     * Indicates whether this renderer executes drawing commands immediately.
68     * If this method returns true, the drawing commands will be executed
69     * later.
70     */
71    virtual bool isDeferred();
72
73    /**
74     * Sets the dimension of the underlying drawing surface. This method must
75     * be called at least once every time the drawing surface changes size.
76     *
77     * @param width The width in pixels of the underlysing surface
78     * @param height The height in pixels of the underlysing surface
79     */
80    virtual void setViewport(int width, int height);
81
82    /**
83     * Prepares the renderer to draw a frame. This method must be invoked
84     * at the beginning of each frame. When this method is invoked, the
85     * entire drawing surface is assumed to be redrawn.
86     *
87     * @param opaque If true, the target surface is considered opaque
88     *               and will not be cleared. If false, the target surface
89     *               will be cleared
90     */
91    ANDROID_API int prepare(bool opaque);
92
93    /**
94     * Prepares the renderer to draw a frame. This method must be invoked
95     * at the beginning of each frame. Only the specified rectangle of the
96     * frame is assumed to be dirty. A clip will automatically be set to
97     * the specified rectangle.
98     *
99     * @param left The left coordinate of the dirty rectangle
100     * @param top The top coordinate of the dirty rectangle
101     * @param right The right coordinate of the dirty rectangle
102     * @param bottom The bottom coordinate of the dirty rectangle
103     * @param opaque If true, the target surface is considered opaque
104     *               and will not be cleared. If false, the target surface
105     *               will be cleared in the specified dirty rectangle
106     */
107    virtual int prepareDirty(float left, float top, float right, float bottom, bool opaque);
108
109    /**
110     * Indicates the end of a frame. This method must be invoked whenever
111     * the caller is done rendering a frame.
112     */
113    virtual void finish();
114
115    ANDROID_API status_t invokeFunctors(Rect& dirty);
116    ANDROID_API void detachFunctor(Functor* functor);
117    ANDROID_API void attachFunctor(Functor* functor);
118    virtual status_t callDrawGLFunction(Functor* functor, Rect& dirty);
119
120    ANDROID_API int getSaveCount() const;
121    virtual int save(int flags);
122    virtual void restore();
123    virtual void restoreToCount(int saveCount);
124
125    virtual int saveLayer(float left, float top, float right, float bottom,
126            SkPaint* p, int flags);
127    virtual int saveLayerAlpha(float left, float top, float right, float bottom,
128            int alpha, int flags);
129
130    virtual void translate(float dx, float dy);
131    virtual void rotate(float degrees);
132    virtual void scale(float sx, float sy);
133    virtual void skew(float sx, float sy);
134
135    ANDROID_API void getMatrix(SkMatrix* matrix);
136    virtual void setMatrix(SkMatrix* matrix);
137    virtual void concatMatrix(SkMatrix* matrix);
138
139    ANDROID_API const Rect& getClipBounds();
140    ANDROID_API bool quickReject(float left, float top, float right, float bottom);
141    bool quickRejectNoScissor(float left, float top, float right, float bottom);
142    virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op);
143    virtual Rect* getClipRect();
144
145    virtual status_t drawDisplayList(DisplayList* displayList, Rect& dirty, int32_t flags,
146            uint32_t level = 0);
147    virtual void outputDisplayList(DisplayList* displayList, uint32_t level = 0);
148    virtual status_t drawLayer(Layer* layer, float x, float y, SkPaint* paint);
149    virtual status_t drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint);
150    virtual status_t drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint);
151    virtual status_t drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop,
152            float srcRight, float srcBottom, float dstLeft, float dstTop,
153            float dstRight, float dstBottom, SkPaint* paint);
154    virtual status_t drawBitmapData(SkBitmap* bitmap, float left, float top, SkPaint* paint);
155    virtual status_t drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight,
156            float* vertices, int* colors, SkPaint* paint);
157    virtual status_t drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
158            const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
159            float left, float top, float right, float bottom, SkPaint* paint);
160    status_t drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
161            const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
162            float left, float top, float right, float bottom, int alpha, SkXfermode::Mode mode);
163    virtual status_t drawColor(int color, SkXfermode::Mode mode);
164    virtual status_t drawRect(float left, float top, float right, float bottom, SkPaint* paint);
165    virtual status_t drawRoundRect(float left, float top, float right, float bottom,
166            float rx, float ry, SkPaint* paint);
167    virtual status_t drawCircle(float x, float y, float radius, SkPaint* paint);
168    virtual status_t drawOval(float left, float top, float right, float bottom, SkPaint* paint);
169    virtual status_t drawArc(float left, float top, float right, float bottom,
170            float startAngle, float sweepAngle, bool useCenter, SkPaint* paint);
171    virtual status_t drawPath(SkPath* path, SkPaint* paint);
172    virtual status_t drawLines(float* points, int count, SkPaint* paint);
173    virtual status_t drawPoints(float* points, int count, SkPaint* paint);
174    virtual status_t drawTextOnPath(const char* text, int bytesCount, int count, SkPath* path,
175            float hOffset, float vOffset, SkPaint* paint);
176    virtual status_t drawPosText(const char* text, int bytesCount, int count,
177            const float* positions, SkPaint* paint);
178    virtual status_t drawText(const char* text, int bytesCount, int count, float x, float y,
179            const float* positions, SkPaint* paint, float length = -1.0f);
180
181    virtual void resetShader();
182    virtual void setupShader(SkiaShader* shader);
183
184    virtual void resetColorFilter();
185    virtual void setupColorFilter(SkiaColorFilter* filter);
186
187    virtual void resetShadow();
188    virtual void setupShadow(float radius, float dx, float dy, int color);
189
190    virtual void resetPaintFilter();
191    virtual void setupPaintFilter(int clearBits, int setBits);
192
193    SkPaint* filterPaint(SkPaint* paint);
194
195    /**
196     * Returns the desired size for the stencil buffer. If the returned value
197     * is 0, then no stencil buffer is required.
198     */
199    ANDROID_API static uint32_t getStencilSize();
200
201    /**
202     * Sets the alpha on the current snapshot. This alpha value will be modulated
203     * with other alpha values when drawing primitives.
204     */
205    void setAlpha(float alpha) {
206        mSnapshot->alpha = alpha;
207    }
208
209    /**
210     * Inserts a named group marker in the stream of GL commands. This marker
211     * can be used by tools to group commands into logical groups. A call to
212     * this method must always be followed later on by a call to endMark().
213     */
214    void startMark(const char* name) const;
215
216    /**
217     * Closes the last group marker opened by startMark().
218     */
219    void endMark() const;
220
221protected:
222
223    /**
224     * This method must be invoked before handing control over to a draw functor.
225     * See callDrawGLFunction() for instance.
226     *
227     * This command must not be recorded inside display lists.
228     */
229    void interrupt();
230
231    /**
232     * This method must be invoked after getting control back from a draw functor.
233     *
234     * This command must not be recorded inside display lists.
235     */
236    void resume();
237
238    /**
239     * Compose the layer defined in the current snapshot with the layer
240     * defined by the previous snapshot.
241     *
242     * The current snapshot *must* be a layer (flag kFlagIsLayer set.)
243     *
244     * @param curent The current snapshot containing the layer to compose
245     * @param previous The previous snapshot to compose the current layer with
246     */
247    virtual void composeLayer(sp<Snapshot> current, sp<Snapshot> previous);
248
249    /**
250     * Marks the specified region as dirty at the specified bounds.
251     */
252    void dirtyLayerUnchecked(Rect& bounds, Region* region);
253
254    /**
255     * Returns the current snapshot.
256     */
257    sp<Snapshot> getSnapshot() {
258        return mSnapshot;
259    }
260
261    /**
262     * Returns the region of the current layer.
263     */
264    virtual Region* getRegion() {
265        return mSnapshot->region;
266    }
267
268    /**
269     * Indicates whether rendering is currently targeted at a layer.
270     */
271    virtual bool hasLayer() {
272        return (mSnapshot->flags & Snapshot::kFlagFboTarget) && mSnapshot->region;
273    }
274
275    /**
276     * Returns the name of the FBO this renderer is rendering into.
277     */
278    virtual GLint getTargetFbo() {
279        return 0;
280    }
281
282    /**
283     * Renders the specified layer as a textured quad.
284     *
285     * @param layer The layer to render
286     * @param rect The bounds of the layer
287     */
288    void drawTextureLayer(Layer* layer, const Rect& rect);
289
290    /**
291     * Gets the alpha and xfermode out of a paint object. If the paint is null
292     * alpha will be 255 and the xfermode will be SRC_OVER.
293     *
294     * @param paint The paint to extract values from
295     * @param alpha Where to store the resulting alpha
296     * @param mode Where to store the resulting xfermode
297     */
298    inline void getAlphaAndMode(SkPaint* paint, int* alpha, SkXfermode::Mode* mode);
299
300    /**
301     * Gets the alpha and xfermode out of a paint object. If the paint is null
302     * alpha will be 255 and the xfermode will be SRC_OVER. This method does
303     * not multiply the paint's alpha by the current snapshot's alpha.
304     *
305     * @param paint The paint to extract values from
306     * @param alpha Where to store the resulting alpha
307     * @param mode Where to store the resulting xfermode
308     */
309    static inline void getAlphaAndModeDirect(SkPaint* paint, int* alpha, SkXfermode::Mode* mode) {
310        if (paint) {
311            *mode = getXfermode(paint->getXfermode());
312
313            // Skia draws using the color's alpha channel if < 255
314            // Otherwise, it uses the paint's alpha
315            int color = paint->getColor();
316            *alpha = (color >> 24) & 0xFF;
317            if (*alpha == 255) {
318                *alpha = paint->getAlpha();
319            }
320        } else {
321            *mode = SkXfermode::kSrcOver_Mode;
322            *alpha = 255;
323        }
324    }
325
326    /**
327     * Safely retrieves the mode from the specified xfermode. If the specified
328     * xfermode is null, the mode is assumed to be SkXfermode::kSrcOver_Mode.
329     */
330    static inline SkXfermode::Mode getXfermode(SkXfermode* mode) {
331        SkXfermode::Mode resultMode;
332        if (!SkXfermode::AsMode(mode, &resultMode)) {
333            resultMode = SkXfermode::kSrcOver_Mode;
334        }
335        return resultMode;
336    }
337
338private:
339    /**
340     * Ensures the state of the renderer is the same as the state of
341     * the GL context.
342     */
343    void syncState();
344
345    /**
346     * Saves the current state of the renderer as a new snapshot.
347     * The new snapshot is saved in mSnapshot and the previous snapshot
348     * is linked from mSnapshot->previous.
349     *
350     * @param flags The save flags; see SkCanvas for more information
351     *
352     * @return The new save count. This value can be passed to #restoreToCount()
353     */
354    int saveSnapshot(int flags);
355
356    /**
357     * Restores the current snapshot; mSnapshot becomes mSnapshot->previous.
358     *
359     * @return True if the clip was modified.
360     */
361    bool restoreSnapshot();
362
363    /**
364     * Sets the clipping rectangle using glScissor. The clip is defined by
365     * the current snapshot's clipRect member.
366     */
367    void setScissorFromClip();
368
369    /**
370     * Creates a new layer stored in the specified snapshot.
371     *
372     * @param snapshot The snapshot associated with the new layer
373     * @param left The left coordinate of the layer
374     * @param top The top coordinate of the layer
375     * @param right The right coordinate of the layer
376     * @param bottom The bottom coordinate of the layer
377     * @param alpha The translucency of the layer
378     * @param mode The blending mode of the layer
379     * @param flags The layer save flags
380     * @param previousFbo The name of the current framebuffer
381     *
382     * @return True if the layer was successfully created, false otherwise
383     */
384    bool createLayer(sp<Snapshot> snapshot, float left, float top, float right, float bottom,
385            int alpha, SkXfermode::Mode mode, int flags, GLuint previousFbo);
386
387    /**
388     * Creates a new layer stored in the specified snapshot as an FBO.
389     *
390     * @param layer The layer to store as an FBO
391     * @param snapshot The snapshot associated with the new layer
392     * @param bounds The bounds of the layer
393     * @param previousFbo The name of the current framebuffer
394     */
395    bool createFboLayer(Layer* layer, Rect& bounds, sp<Snapshot> snapshot,
396            GLuint previousFbo);
397
398    /**
399     * Compose the specified layer as a region.
400     *
401     * @param layer The layer to compose
402     * @param rect The layer's bounds
403     */
404    void composeLayerRegion(Layer* layer, const Rect& rect);
405
406    /**
407     * Compose the specified layer as a simple rectangle.
408     *
409     * @param layer The layer to compose
410     * @param rect The layer's bounds
411     * @param swap If true, the source and destination are swapped
412     */
413    void composeLayerRect(Layer* layer, const Rect& rect, bool swap = false);
414
415    /**
416     * Clears all the regions corresponding to the current list of layers.
417     * This method MUST be invoked before any drawing operation.
418     */
419    void clearLayerRegions();
420
421    /**
422     * Mark the layer as dirty at the specified coordinates. The coordinates
423     * are transformed with the supplied matrix.
424     */
425    void dirtyLayer(const float left, const float top,
426            const float right, const float bottom, const mat4 transform);
427
428    /**
429     * Mark the layer as dirty at the specified coordinates.
430     */
431    void dirtyLayer(const float left, const float top,
432            const float right, const float bottom);
433
434    /**
435     * Draws a colored rectangle with the specified color. The specified coordinates
436     * are transformed by the current snapshot's transform matrix.
437     *
438     * @param left The left coordinate of the rectangle
439     * @param top The top coordinate of the rectangle
440     * @param right The right coordinate of the rectangle
441     * @param bottom The bottom coordinate of the rectangle
442     * @param color The rectangle's ARGB color, defined as a packed 32 bits word
443     * @param mode The Skia xfermode to use
444     * @param ignoreTransform True if the current transform should be ignored
445     * @param ignoreBlending True if the blending is set by the caller
446     */
447    void drawColorRect(float left, float top, float right, float bottom,
448            int color, SkXfermode::Mode mode, bool ignoreTransform = false);
449
450    /**
451     * Draws the shape represented by the specified path texture.
452     * This method invokes drawPathTexture() but takes into account
453     * the extra left/top offset and the texture offset to correctly
454     * position the final shape.
455     *
456     * @param left The left coordinate of the shape to render
457     * @param top The top coordinate of the shape to render
458     * @param texture The texture reprsenting the shape
459     * @param paint The paint to draw the shape with
460     */
461    status_t drawShape(float left, float top, const PathTexture* texture, SkPaint* paint);
462
463    /**
464     * Renders the rect defined by the specified bounds as a shape.
465     * This will render the rect using a path texture, which is used to render
466     * rects with stroke effects.
467     *
468     * @param left The left coordinate of the rect to draw
469     * @param top The top coordinate of the rect to draw
470     * @param right The right coordinate of the rect to draw
471     * @param bottom The bottom coordinate of the rect to draw
472     * @param p The paint to draw the rect with
473     */
474    status_t drawRectAsShape(float left, float top, float right, float bottom, SkPaint* p);
475
476    /**
477     * Draws the specified texture as an alpha bitmap. Alpha bitmaps obey
478     * different compositing rules.
479     *
480     * @param texture The texture to draw with
481     * @param left The x coordinate of the bitmap
482     * @param top The y coordinate of the bitmap
483     * @param paint The paint to render with
484     */
485    void drawAlphaBitmap(Texture* texture, float left, float top, SkPaint* paint);
486
487    /**
488     * Renders the rect defined by the specified bounds as an anti-aliased rect.
489     *
490     * @param left The left coordinate of the rect to draw
491     * @param top The top coordinate of the rect to draw
492     * @param right The right coordinate of the rect to draw
493     * @param bottom The bottom coordinate of the rect to draw
494     * @param color The color of the rect
495     * @param mode The blending mode to draw the rect
496     */
497    void drawAARect(float left, float top, float right, float bottom,
498            int color, SkXfermode::Mode mode);
499
500    /**
501     * Draws a textured rectangle with the specified texture. The specified coordinates
502     * are transformed by the current snapshot's transform matrix.
503     *
504     * @param left The left coordinate of the rectangle
505     * @param top The top coordinate of the rectangle
506     * @param right The right coordinate of the rectangle
507     * @param bottom The bottom coordinate of the rectangle
508     * @param texture The texture name to map onto the rectangle
509     * @param alpha An additional translucency parameter, between 0.0f and 1.0f
510     * @param mode The blending mode
511     * @param blend True if the texture contains an alpha channel
512     */
513    void drawTextureRect(float left, float top, float right, float bottom, GLuint texture,
514            float alpha, SkXfermode::Mode mode, bool blend);
515
516    /**
517     * Draws a textured rectangle with the specified texture. The specified coordinates
518     * are transformed by the current snapshot's transform matrix.
519     *
520     * @param left The left coordinate of the rectangle
521     * @param top The top coordinate of the rectangle
522     * @param right The right coordinate of the rectangle
523     * @param bottom The bottom coordinate of the rectangle
524     * @param texture The texture to use
525     * @param paint The paint containing the alpha, blending mode, etc.
526     */
527    void drawTextureRect(float left, float top, float right, float bottom,
528            Texture* texture, SkPaint* paint);
529
530    /**
531     * Draws a textured mesh with the specified texture. If the indices are omitted,
532     * the mesh is drawn as a simple quad. The mesh pointers become offsets when a
533     * VBO is bound.
534     *
535     * @param left The left coordinate of the rectangle
536     * @param top The top coordinate of the rectangle
537     * @param right The right coordinate of the rectangle
538     * @param bottom The bottom coordinate of the rectangle
539     * @param texture The texture name to map onto the rectangle
540     * @param alpha An additional translucency parameter, between 0.0f and 1.0f
541     * @param mode The blending mode
542     * @param blend True if the texture contains an alpha channel
543     * @param vertices The vertices that define the mesh
544     * @param texCoords The texture coordinates of each vertex
545     * @param elementsCount The number of elements in the mesh, required by indices
546     * @param swapSrcDst Whether or not the src and dst blending operations should be swapped
547     * @param ignoreTransform True if the current transform should be ignored
548     * @param vbo The VBO used to draw the mesh
549     * @param ignoreScale True if the model view matrix should not be scaled
550     * @param dirty True if calling this method should dirty the current layer
551     */
552    void drawTextureMesh(float left, float top, float right, float bottom, GLuint texture,
553            float alpha, SkXfermode::Mode mode, bool blend,
554            GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,
555            bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0,
556            bool ignoreScale = false, bool dirty = true);
557
558    /**
559     * Draws text underline and strike-through if needed.
560     *
561     * @param text The text to decor
562     * @param bytesCount The number of bytes in the text
563     * @param length The length in pixels of the text, can be <= 0.0f to force a measurement
564     * @param x The x coordinate where the text will be drawn
565     * @param y The y coordinate where the text will be drawn
566     * @param paint The paint to draw the text with
567     */
568    void drawTextDecorations(const char* text, int bytesCount, float length,
569            float x, float y, SkPaint* paint);
570
571   /**
572     * Draws shadow layer on text (with optional positions).
573     *
574     * @param paint The paint to draw the shadow with
575     * @param text The text to draw
576     * @param bytesCount The number of bytes in the text
577     * @param count The number of glyphs in the text
578     * @param positions The x, y positions of individual glyphs (or NULL)
579     * @param fontRenderer The font renderer object
580     * @param alpha The alpha value for drawing the shadow
581     * @param mode The xfermode for drawing the shadow
582     * @param x The x coordinate where the shadow will be drawn
583     * @param y The y coordinate where the shadow will be drawn
584     */
585    void drawTextShadow(SkPaint* paint, const char* text, int bytesCount, int count,
586            const float* positions, FontRenderer& fontRenderer, int alpha, SkXfermode::Mode mode,
587            float x, float y);
588
589    /**
590     * Draws a path texture. Path textures are alpha8 bitmaps that need special
591     * compositing to apply colors/filters/etc.
592     *
593     * @param texture The texture to render
594     * @param x The x coordinate where the texture will be drawn
595     * @param y The y coordinate where the texture will be drawn
596     * @param paint The paint to draw the texture with
597     */
598     void drawPathTexture(const PathTexture* texture, float x, float y, SkPaint* paint);
599
600    /**
601     * Resets the texture coordinates stored in mMeshVertices. Setting the values
602     * back to default is achieved by calling:
603     *
604     * resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
605     *
606     * @param u1 The left coordinate of the texture
607     * @param v1 The bottom coordinate of the texture
608     * @param u2 The right coordinate of the texture
609     * @param v2 The top coordinate of the texture
610     */
611    void resetDrawTextureTexCoords(float u1, float v1, float u2, float v2);
612
613    /**
614     * Binds the specified texture. The texture unit must have been selected
615     * prior to calling this method.
616     */
617    inline void bindTexture(GLuint texture) {
618        glBindTexture(GL_TEXTURE_2D, texture);
619    }
620
621    /**
622     * Binds the specified EGLImage texture. The texture unit must have been selected
623     * prior to calling this method.
624     */
625    inline void bindExternalTexture(GLuint texture) {
626        glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
627    }
628
629    /**
630     * Enable or disable blending as necessary. This function sets the appropriate
631     * blend function based on the specified xfermode.
632     */
633    inline void chooseBlending(bool blend, SkXfermode::Mode mode, ProgramDescription& description,
634            bool swapSrcDst = false);
635
636    /**
637     * Use the specified program with the current GL context. If the program is already
638     * in use, it will not be bound again. If it is not in use, the current program is
639     * marked unused and the specified program becomes used and becomes the new
640     * current program.
641     *
642     * @param program The program to use
643     *
644     * @return true If the specified program was already in use, false otherwise.
645     */
646    inline bool useProgram(Program* program);
647
648    /**
649     * Invoked before any drawing operation. This sets required state.
650     */
651    void setupDraw(bool clear = true);
652
653    /**
654     * Various methods to setup OpenGL rendering.
655     */
656    void setupDrawWithTexture(bool isAlpha8 = false);
657    void setupDrawWithExternalTexture();
658    void setupDrawNoTexture();
659    void setupDrawAALine();
660    void setupDrawPoint(float pointSize);
661    void setupDrawColor(int color);
662    void setupDrawColor(int color, int alpha);
663    void setupDrawColor(float r, float g, float b, float a);
664    void setupDrawAlpha8Color(int color, int alpha);
665    void setupDrawTextGamma(const SkPaint* paint);
666    void setupDrawShader();
667    void setupDrawColorFilter();
668    void setupDrawBlending(SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
669            bool swapSrcDst = false);
670    void setupDrawBlending(bool blend = true, SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
671            bool swapSrcDst = false);
672    void setupDrawProgram();
673    void setupDrawDirtyRegionsDisabled();
674    void setupDrawModelViewIdentity(bool offset = false);
675    void setupDrawModelView(float left, float top, float right, float bottom,
676            bool ignoreTransform = false, bool ignoreModelView = false);
677    void setupDrawModelViewTranslate(float left, float top, float right, float bottom,
678            bool ignoreTransform = false);
679    void setupDrawPointUniforms();
680    void setupDrawColorUniforms();
681    void setupDrawPureColorUniforms();
682    void setupDrawShaderIdentityUniforms();
683    void setupDrawShaderUniforms(bool ignoreTransform = false);
684    void setupDrawColorFilterUniforms();
685    void setupDrawSimpleMesh();
686    void setupDrawTexture(GLuint texture);
687    void setupDrawExternalTexture(GLuint texture);
688    void setupDrawTextureTransform();
689    void setupDrawTextureTransformUniforms(mat4& transform);
690    void setupDrawTextGammaUniforms();
691    void setupDrawMesh(GLvoid* vertices, GLvoid* texCoords = NULL, GLuint vbo = 0);
692    void setupDrawMeshIndices(GLvoid* vertices, GLvoid* texCoords);
693    void setupDrawVertices(GLvoid* vertices);
694    void setupDrawAALine(GLvoid* vertices, GLvoid* distanceCoords, GLvoid* lengthCoords,
695            float strokeWidth, int& widthSlot, int& lengthSlot);
696    void finishDrawAALine(const int widthSlot, const int lengthSlot);
697    void finishDrawTexture();
698    void accountForClear(SkXfermode::Mode mode);
699
700    /**
701     * Renders the specified region as a series of rectangles. This method
702     * is used for debugging only.
703     */
704    void drawRegionRects(const Region& region);
705
706    /**
707     * Should be invoked every time the glScissor is modified.
708     */
709    inline void dirtyClip() {
710        mDirtyClip = true;
711    }
712
713    // Dimensions of the drawing surface
714    int mWidth, mHeight;
715
716    // Matrix used for ortho projection in shaders
717    mat4 mOrthoMatrix;
718
719    // Model-view matrix used to position/size objects
720    mat4 mModelView;
721
722    // Number of saved states
723    int mSaveCount;
724    // Base state
725    sp<Snapshot> mFirstSnapshot;
726    // Current state
727    sp<Snapshot> mSnapshot;
728
729    // Shaders
730    SkiaShader* mShader;
731
732    // Color filters
733    SkiaColorFilter* mColorFilter;
734
735    // Used to draw textured quads
736    TextureVertex mMeshVertices[4];
737
738    // Drop shadow
739    bool mHasShadow;
740    float mShadowRadius;
741    float mShadowDx;
742    float mShadowDy;
743    int mShadowColor;
744
745    // Draw filters
746    bool mHasDrawFilter;
747    int mPaintFilterClearBits;
748    int mPaintFilterSetBits;
749    SkPaint mFilteredPaint;
750
751    // Various caches
752    Caches& mCaches;
753
754    // List of rectangles to clear after saveLayer() is invoked
755    Vector<Rect*> mLayers;
756    // List of functors to invoke after a frame is drawn
757    SortedVector<Functor*> mFunctors;
758
759    // Indentity matrix
760    const mat4 mIdentity;
761
762    // Indicates whether the clip must be restored
763    bool mDirtyClip;
764
765    // The following fields are used to setup drawing
766    // Used to describe the shaders to generate
767    ProgramDescription mDescription;
768    // Color description
769    bool mColorSet;
770    float mColorA, mColorR, mColorG, mColorB;
771    // Indicates that the shader should get a color
772    bool mSetShaderColor;
773    // Current texture unit
774    GLuint mTextureUnit;
775    // Track dirty regions, true by default
776    bool mTrackDirtyRegions;
777
778    friend class DisplayListRenderer;
779
780}; // class OpenGLRenderer
781
782}; // namespace uirenderer
783}; // namespace android
784
785#endif // ANDROID_HWUI_OPENGL_RENDERER_H
786