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