OpenGLRenderer.h revision 8d0d4783a0206c5884bf0b958d181f450ba5207d 
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/RefBase.h>
31#include <utils/Vector.h>
32
33#include "Debug.h"
34#include "Extensions.h"
35#include "Matrix.h"
36#include "Program.h"
37#include "Rect.h"
38#include "Snapshot.h"
39#include "Vertex.h"
40#include "SkiaShader.h"
41#include "SkiaColorFilter.h"
42#include "Caches.h"
43
44namespace android {
45namespace uirenderer {
46
47///////////////////////////////////////////////////////////////////////////////
48// Renderer
49///////////////////////////////////////////////////////////////////////////////
50
51class DisplayList;
52
53/**
54 * OpenGL renderer used to draw accelerated 2D graphics. The API is a
55 * simplified version of Skia's Canvas API.
56 */
57class OpenGLRenderer {
58public:
59    OpenGLRenderer();
60    virtual ~OpenGLRenderer();
61
62    virtual void setViewport(int width, int height);
63
64    virtual void prepare(bool opaque);
65    virtual void finish();
66
67    virtual void acquireContext();
68    virtual void releaseContext();
69
70    int getSaveCount() const;
71    virtual int save(int flags);
72    virtual void restore();
73    virtual void restoreToCount(int saveCount);
74
75    virtual int saveLayer(float left, float top, float right, float bottom,
76            SkPaint* p, int flags);
77    virtual int saveLayerAlpha(float left, float top, float right, float bottom,
78            int alpha, int flags);
79
80    virtual void translate(float dx, float dy);
81    virtual void rotate(float degrees);
82    virtual void scale(float sx, float sy);
83
84    const float* getMatrix() const;
85    void getMatrix(SkMatrix* matrix);
86    virtual void setMatrix(SkMatrix* matrix);
87    virtual void concatMatrix(SkMatrix* matrix);
88
89    const Rect& getClipBounds();
90    bool quickReject(float left, float top, float right, float bottom);
91    virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op);
92
93    virtual void drawDisplayList(DisplayList* displayList);
94    virtual void drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint);
95    virtual void drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint);
96    virtual void drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop,
97            float srcRight, float srcBottom, float dstLeft, float dstTop,
98            float dstRight, float dstBottom, SkPaint* paint);
99    virtual void drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
100            const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
101            float left, float top, float right, float bottom, SkPaint* paint);
102    virtual void drawColor(int color, SkXfermode::Mode mode);
103    virtual void drawRect(float left, float top, float right, float bottom, SkPaint* paint);
104    virtual void drawPath(SkPath* path, SkPaint* paint);
105    virtual void drawLines(float* points, int count, SkPaint* paint);
106    virtual void drawText(const char* text, int bytesCount, int count, float x, float y,
107            SkPaint* paint);
108
109    virtual void resetShader();
110    virtual void setupShader(SkiaShader* shader);
111
112    virtual void resetColorFilter();
113    virtual void setupColorFilter(SkiaColorFilter* filter);
114
115    virtual void resetShadow();
116    virtual void setupShadow(float radius, float dx, float dy, int color);
117
118protected:
119    /**
120     * Compose the layer defined in the current snapshot with the layer
121     * defined by the previous snapshot.
122     *
123     * The current snapshot *must* be a layer (flag kFlagIsLayer set.)
124     *
125     * @param curent The current snapshot containing the layer to compose
126     * @param previous The previous snapshot to compose the current layer with
127     */
128    virtual void composeLayer(sp<Snapshot> current, sp<Snapshot> previous);
129
130private:
131    /**
132     * Saves the current state of the renderer as a new snapshot.
133     * The new snapshot is saved in mSnapshot and the previous snapshot
134     * is linked from mSnapshot->previous.
135     *
136     * @param flags The save flags; see SkCanvas for more information
137     *
138     * @return The new save count. This value can be passed to #restoreToCount()
139     */
140    int saveSnapshot(int flags);
141
142    /**
143     * Restores the current snapshot; mSnapshot becomes mSnapshot->previous.
144     *
145     * @return True if the clip was modified.
146     */
147    bool restoreSnapshot();
148
149    /**
150     * Sets the clipping rectangle using glScissor. The clip is defined by
151     * the current snapshot's clipRect member.
152     */
153    void setScissorFromClip();
154
155    /**
156     * Creates a new layer stored in the specified snapshot.
157     *
158     * @param snapshot The snapshot associated with the new layer
159     * @param left The left coordinate of the layer
160     * @param top The top coordinate of the layer
161     * @param right The right coordinate of the layer
162     * @param bottom The bottom coordinate of the layer
163     * @param alpha The translucency of the layer
164     * @param mode The blending mode of the layer
165     * @param flags The layer save flags
166     * @param previousFbo The name of the current framebuffer
167     *
168     * @return True if the layer was successfully created, false otherwise
169     */
170    bool createLayer(sp<Snapshot> snapshot, float left, float top, float right, float bottom,
171            int alpha, SkXfermode::Mode mode, int flags, GLuint previousFbo);
172
173    /**
174     * Creates a new layer stored in the specified snapshot as an FBO.
175     *
176     * @param layer The layer to store as an FBO
177     * @param snapshot The snapshot associated with the new layer
178     * @param bounds The bounds of the layer
179     * @param previousFbo The name of the current framebuffer
180     */
181    bool createFboLayer(Layer* layer, Rect& bounds, sp<Snapshot> snapshot,
182            GLuint previousFbo);
183
184    /**
185     * Compose the specified layer as a region.
186     *
187     * @param layer The layer to compose
188     * @param rect The layer's bounds
189     */
190    void composeLayerRegion(Layer* layer, const Rect& rect);
191
192    /**
193     * Compose the specified layer as a simple rectangle.
194     *
195     * @param layer The layer to compose
196     * @param rect The layer's bounds
197     * @param swap If true, the source and destination are swapped
198     */
199    void composeLayerRect(Layer* layer, const Rect& rect, bool swap = false);
200
201    /**
202     * Clears all the regions corresponding to the current list of layers.
203     * This method MUST be invoked before any drawing operation.
204     */
205    void clearLayerRegions();
206
207    /**
208     * Draws a colored rectangle with the specified color. The specified coordinates
209     * are transformed by the current snapshot's transform matrix.
210     *
211     * @param left The left coordinate of the rectangle
212     * @param top The top coordinate of the rectangle
213     * @param right The right coordinate of the rectangle
214     * @param bottom The bottom coordinate of the rectangle
215     * @param color The rectangle's ARGB color, defined as a packed 32 bits word
216     * @param mode The Skia xfermode to use
217     * @param ignoreTransform True if the current transform should be ignored
218     * @param ignoreBlending True if the blending is set by the caller
219     */
220    void drawColorRect(float left, float top, float right, float bottom,
221            int color, SkXfermode::Mode mode, bool ignoreTransform = false);
222
223    /**
224     * Draws a textured rectangle with the specified texture. The specified coordinates
225     * are transformed by the current snapshot's transform matrix.
226     *
227     * @param left The left coordinate of the rectangle
228     * @param top The top coordinate of the rectangle
229     * @param right The right coordinate of the rectangle
230     * @param bottom The bottom coordinate of the rectangle
231     * @param texture The texture name to map onto the rectangle
232     * @param alpha An additional translucency parameter, between 0.0f and 1.0f
233     * @param mode The blending mode
234     * @param blend True if the texture contains an alpha channel
235     */
236    void drawTextureRect(float left, float top, float right, float bottom, GLuint texture,
237            float alpha, SkXfermode::Mode mode, bool blend);
238
239    /**
240     * Draws a textured rectangle with the specified texture. The specified coordinates
241     * are transformed by the current snapshot's transform matrix.
242     *
243     * @param left The left coordinate of the rectangle
244     * @param top The top coordinate of the rectangle
245     * @param right The right coordinate of the rectangle
246     * @param bottom The bottom coordinate of the rectangle
247     * @param texture The texture to use
248     * @param paint The paint containing the alpha, blending mode, etc.
249     */
250    void drawTextureRect(float left, float top, float right, float bottom,
251            Texture* texture, SkPaint* paint);
252
253    /**
254     * Draws a textured mesh with the specified texture. If the indices are omitted,
255     * the mesh is drawn as a simple quad. The mesh pointers become offsets when a
256     * VBO is bound.
257     *
258     * @param left The left coordinate of the rectangle
259     * @param top The top coordinate of the rectangle
260     * @param right The right coordinate of the rectangle
261     * @param bottom The bottom coordinate of the rectangle
262     * @param texture The texture name to map onto the rectangle
263     * @param alpha An additional translucency parameter, between 0.0f and 1.0f
264     * @param mode The blending mode
265     * @param blend True if the texture contains an alpha channel
266     * @param vertices The vertices that define the mesh
267     * @param texCoords The texture coordinates of each vertex
268     * @param elementsCount The number of elements in the mesh, required by indices
269     * @param swapSrcDst Whether or not the src and dst blending operations should be swapped
270     * @param ignoreTransform True if the current transform should be ignored
271     * @param vbo The VBO used to draw the mesh
272     * @param ignoreScale True if the model view matrix should not be scaled
273     * @param dirty True if calling this method should dirty the current layer
274     */
275    void drawTextureMesh(float left, float top, float right, float bottom, GLuint texture,
276            float alpha, SkXfermode::Mode mode, bool blend,
277            GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,
278            bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0,
279            bool ignoreScale = false, bool dirty = true);
280
281    /**
282     * Draws text underline and strike-through if needed.
283     *
284     * @param text The text to decor
285     * @param bytesCount The number of bytes in the text
286     * @param length The length in pixels of the text, can be <= 0.0f to force a measurement
287     * @param x The x coordinate where the text will be drawn
288     * @param y The y coordinate where the text will be drawn
289     * @param paint The paint to draw the text with
290     */
291    void drawTextDecorations(const char* text, int bytesCount, float length,
292            float x, float y, SkPaint* paint);
293
294    /**
295     * Resets the texture coordinates stored in mMeshVertices. Setting the values
296     * back to default is achieved by calling:
297     *
298     * resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
299     *
300     * @param u1 The left coordinate of the texture
301     * @param v1 The bottom coordinate of the texture
302     * @param u2 The right coordinate of the texture
303     * @param v2 The top coordinate of the texture
304     */
305    void resetDrawTextureTexCoords(float u1, float v1, float u2, float v2);
306
307    /**
308     * Gets the alpha and xfermode out of a paint object. If the paint is null
309     * alpha will be 255 and the xfermode will be SRC_OVER.
310     *
311     * @param paint The paint to extract values from
312     * @param alpha Where to store the resulting alpha
313     * @param mode Where to store the resulting xfermode
314     */
315    inline void getAlphaAndMode(SkPaint* paint, int* alpha, SkXfermode::Mode* mode);
316
317    /**
318     * Binds the specified texture. The texture unit must have been selected
319     * prior to calling this method.
320     */
321    inline void bindTexture(GLuint texture) {
322        glBindTexture(GL_TEXTURE_2D, texture);
323    }
324
325    /**
326     * Sets the wrap modes for the specified texture. The wrap modes are modified
327     * only when needed.
328     */
329    inline void setTextureWrapModes(Texture* texture, GLenum wrapS, GLenum wrapT);
330
331    /**
332     * Enable or disable blending as necessary. This function sets the appropriate
333     * blend function based on the specified xfermode.
334     */
335    inline void chooseBlending(bool blend, SkXfermode::Mode mode, ProgramDescription& description,
336            bool swapSrcDst = false);
337
338    /**
339     * Safely retrieves the mode from the specified xfermode. If the specified
340     * xfermode is null, the mode is assumed to be SkXfermode::kSrcOver_Mode.
341     */
342    inline SkXfermode::Mode getXfermode(SkXfermode* mode);
343
344    /**
345     * Use the specified program with the current GL context. If the program is already
346     * in use, it will not be bound again. If it is not in use, the current program is
347     * marked unused and the specified program becomes used and becomes the new
348     * current program.
349     *
350     * @param program The program to use
351     *
352     * @return true If the specified program was already in use, false otherwise.
353     */
354    inline bool useProgram(Program* program);
355
356    /**
357     * Invoked before any drawing operation. This sets required state.
358     */
359    void setupDraw();
360    /**
361     * Various methods to setup OpenGL rendering.
362     */
363    void setupDrawWithTexture(bool isAlpha8 = false);
364    void setupDrawColor(int color);
365    void setupDrawColor(int color, int alpha);
366    void setupDrawColor(float r, float g, float b, float a);
367    void setupDrawAlpha8Color(int color, int alpha);
368    void setupDrawAlpha8Color(float r, float g, float b, float a);
369    void setupDrawShader();
370    void setupDrawColorFilter();
371    void setupDrawBlending(SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
372            bool swapSrcDst = false);
373    void setupDrawBlending(bool blend = true, SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
374            bool swapSrcDst = false);
375    void setupDrawProgram();
376    void setupDrawDirtyRegionsDisabled();
377    void setupDrawModelViewIdentity();
378    void setupDrawModelView(float left, float top, float right, float bottom,
379            bool ignoreTransform = false, bool ignoreModelView = false);
380    void setupDrawModelViewTranslate(float left, float top, float right, float bottom,
381            bool ignoreTransform = false);
382    void setupDrawColorUniforms();
383    void setupDrawPureColorUniforms();
384    void setupDrawShaderIdentityUniforms();
385    void setupDrawShaderUniforms(bool ignoreTransform = false);
386    void setupDrawColorFilterUniforms();
387    void setupDrawSimpleMesh();
388    void setupDrawTexture(GLuint texture);
389    void setupDrawMesh(GLvoid* vertices, GLvoid* texCoords = NULL, GLuint vbo = 0);
390    void finishDrawTexture();
391
392    /**
393     * Should be invoked every time the glScissor is modified.
394     */
395    inline void dirtyClip() {
396        mDirtyClip = true;
397    }
398
399    /**
400     * Mark the layer as dirty at the specified coordinates. The coordinates
401     * are transformed with the supplied matrix.
402     */
403    void dirtyLayer(const float left, const float top, const float right, const float bottom,
404            const mat4 transform);
405
406    /**
407     * Mark the layer as dirty at the specified coordinates.
408     */
409    void dirtyLayer(const float left, const float top, const float right, const float bottom);
410
411    // Dimensions of the drawing surface
412    int mWidth, mHeight;
413
414    // Matrix used for ortho projection in shaders
415    mat4 mOrthoMatrix;
416
417    // Model-view matrix used to position/size objects
418    mat4 mModelView;
419
420    // Number of saved states
421    int mSaveCount;
422    // Base state
423    sp<Snapshot> mFirstSnapshot;
424    // Current state
425    sp<Snapshot> mSnapshot;
426
427    // Shaders
428    SkiaShader* mShader;
429
430    // Color filters
431    SkiaColorFilter* mColorFilter;
432
433    // Used to draw textured quads
434    TextureVertex mMeshVertices[4];
435
436    // Drop shadow
437    bool mHasShadow;
438    float mShadowRadius;
439    float mShadowDx;
440    float mShadowDy;
441    int mShadowColor;
442
443    // Various caches
444    Caches& mCaches;
445
446    // List of rectangles to clear due to calls to saveLayer()
447    Vector<Rect*> mLayers;
448
449    // Indentity matrix
450    const mat4 mIdentity;
451
452    // Indicates whether the clip must be restored
453    bool mDirtyClip;
454
455    // The following fields are used to setup drawing
456    // Used to describe the shaders to generate
457    ProgramDescription mDescription;
458    // Color description
459    bool mColorSet;
460    float mColorA, mColorR, mColorG, mColorB;
461    // Indicates that the shader should get a color
462    bool mSetShaderColor;
463    // Current texture unit
464    GLuint mTextureUnit;
465    // Track dirty regions, true by default
466    bool mTrackDirtyRegions;
467    // Texture coordinates slot
468    int mTexCoordsSlot;
469
470    friend class DisplayListRenderer;
471
472}; // class OpenGLRenderer
473
474}; // namespace uirenderer
475}; // namespace android
476
477#endif // ANDROID_HWUI_OPENGL_RENDERER_H
478