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