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