OpenGLRenderer.cpp revision 03750a067e818ca7fbd0f590e2ff6a8fded21e6c 
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#define LOG_TAG "OpenGLRenderer"
18
19#include <stdlib.h>
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <SkCanvas.h>
24#include <SkTypeface.h>
25
26#include <utils/Log.h>
27#include <utils/StopWatch.h>
28
29#include "OpenGLRenderer.h"
30
31namespace android {
32namespace uirenderer {
33
34///////////////////////////////////////////////////////////////////////////////
35// Defines
36///////////////////////////////////////////////////////////////////////////////
37
38#define RAD_TO_DEG (180.0f / 3.14159265f)
39#define MIN_ANGLE 0.001f
40
41// TODO: This should be set in properties
42#define ALPHA_THRESHOLD (0x7f / PANEL_BIT_DEPTH)
43
44///////////////////////////////////////////////////////////////////////////////
45// Globals
46///////////////////////////////////////////////////////////////////////////////
47
48/**
49 * Structure mapping Skia xfermodes to OpenGL blending factors.
50 */
51struct Blender {
52    SkXfermode::Mode mode;
53    GLenum src;
54    GLenum dst;
55}; // struct Blender
56
57// In this array, the index of each Blender equals the value of the first
58// entry. For instance, gBlends[1] == gBlends[SkXfermode::kSrc_Mode]
59static const Blender gBlends[] = {
60        { SkXfermode::kClear_Mode,   GL_ZERO,                 GL_ZERO },
61        { SkXfermode::kSrc_Mode,     GL_ONE,                  GL_ZERO },
62        { SkXfermode::kDst_Mode,     GL_ZERO,                 GL_ONE },
63        { SkXfermode::kSrcOver_Mode, GL_ONE,                  GL_ONE_MINUS_SRC_ALPHA },
64        { SkXfermode::kDstOver_Mode, GL_ONE_MINUS_DST_ALPHA,  GL_ONE },
65        { SkXfermode::kSrcIn_Mode,   GL_DST_ALPHA,            GL_ZERO },
66        { SkXfermode::kDstIn_Mode,   GL_ZERO,                 GL_SRC_ALPHA },
67        { SkXfermode::kSrcOut_Mode,  GL_ONE_MINUS_DST_ALPHA,  GL_ZERO },
68        { SkXfermode::kDstOut_Mode,  GL_ZERO,                 GL_ONE_MINUS_SRC_ALPHA },
69        { SkXfermode::kSrcATop_Mode, GL_DST_ALPHA,            GL_ONE_MINUS_SRC_ALPHA },
70        { SkXfermode::kDstATop_Mode, GL_ONE_MINUS_DST_ALPHA,  GL_SRC_ALPHA },
71        { SkXfermode::kXor_Mode,     GL_ONE_MINUS_DST_ALPHA,  GL_ONE_MINUS_SRC_ALPHA }
72};
73
74// This array contains the swapped version of each SkXfermode. For instance
75// this array's SrcOver blending mode is actually DstOver. You can refer to
76// createLayer() for more information on the purpose of this array.
77static const Blender gBlendsSwap[] = {
78        { SkXfermode::kClear_Mode,   GL_ZERO,                 GL_ZERO },
79        { SkXfermode::kSrc_Mode,     GL_ZERO,                 GL_ONE },
80        { SkXfermode::kDst_Mode,     GL_ONE,                  GL_ZERO },
81        { SkXfermode::kSrcOver_Mode, GL_ONE_MINUS_DST_ALPHA,  GL_ONE },
82        { SkXfermode::kDstOver_Mode, GL_ONE,                  GL_ONE_MINUS_SRC_ALPHA },
83        { SkXfermode::kSrcIn_Mode,   GL_ZERO,                 GL_SRC_ALPHA },
84        { SkXfermode::kDstIn_Mode,   GL_DST_ALPHA,            GL_ZERO },
85        { SkXfermode::kSrcOut_Mode,  GL_ZERO,                 GL_ONE_MINUS_SRC_ALPHA },
86        { SkXfermode::kDstOut_Mode,  GL_ONE_MINUS_DST_ALPHA,  GL_ZERO },
87        { SkXfermode::kSrcATop_Mode, GL_ONE_MINUS_DST_ALPHA,  GL_SRC_ALPHA },
88        { SkXfermode::kDstATop_Mode, GL_DST_ALPHA,            GL_ONE_MINUS_SRC_ALPHA },
89        { SkXfermode::kXor_Mode,     GL_ONE_MINUS_DST_ALPHA,  GL_ONE_MINUS_SRC_ALPHA }
90};
91
92static const GLenum gTextureUnits[] = {
93        GL_TEXTURE0,
94        GL_TEXTURE1,
95        GL_TEXTURE2
96};
97
98///////////////////////////////////////////////////////////////////////////////
99// Constructors/destructor
100///////////////////////////////////////////////////////////////////////////////
101
102OpenGLRenderer::OpenGLRenderer(): mCaches(Caches::getInstance()) {
103    mShader = NULL;
104    mColorFilter = NULL;
105    mHasShadow = false;
106
107    memcpy(mMeshVertices, gMeshVertices, sizeof(gMeshVertices));
108
109    mFirstSnapshot = new Snapshot;
110
111    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
112}
113
114OpenGLRenderer::~OpenGLRenderer() {
115    // The context has already been destroyed at this point, do not call
116    // GL APIs. All GL state should be kept in Caches.h
117}
118
119///////////////////////////////////////////////////////////////////////////////
120// Setup
121///////////////////////////////////////////////////////////////////////////////
122
123void OpenGLRenderer::setViewport(int width, int height) {
124    glViewport(0, 0, width, height);
125    mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1);
126
127    mWidth = width;
128    mHeight = height;
129
130    mFirstSnapshot->height = height;
131    mFirstSnapshot->viewport.set(0, 0, width, height);
132}
133
134void OpenGLRenderer::prepare(bool opaque) {
135    mSnapshot = new Snapshot(mFirstSnapshot,
136            SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
137    mSaveCount = 1;
138
139    glViewport(0, 0, mWidth, mHeight);
140
141    glDisable(GL_DITHER);
142    glDisable(GL_SCISSOR_TEST);
143
144    if (!opaque) {
145        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
146        glClear(GL_COLOR_BUFFER_BIT);
147    }
148
149    glEnable(GL_SCISSOR_TEST);
150    glScissor(0, 0, mWidth, mHeight);
151
152    mSnapshot->setClip(0.0f, 0.0f, mWidth, mHeight);
153}
154
155void OpenGLRenderer::finish() {
156#if DEBUG_OPENGL
157    GLenum status = GL_NO_ERROR;
158    while ((status = glGetError()) != GL_NO_ERROR) {
159        LOGD("GL error from OpenGLRenderer: 0x%x", status);
160    }
161#endif
162}
163
164void OpenGLRenderer::acquireContext() {
165    if (mCaches.currentProgram) {
166        if (mCaches.currentProgram->isInUse()) {
167            mCaches.currentProgram->remove();
168            mCaches.currentProgram = NULL;
169        }
170    }
171}
172
173void OpenGLRenderer::releaseContext() {
174    glViewport(0, 0, mSnapshot->viewport.getWidth(), mSnapshot->viewport.getHeight());
175
176    glEnable(GL_SCISSOR_TEST);
177    setScissorFromClip();
178
179    glDisable(GL_DITHER);
180
181    glBindFramebuffer(GL_FRAMEBUFFER, 0);
182    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
183    mCaches.bindMeshBuffer();
184
185    if (mCaches.blend) {
186        glEnable(GL_BLEND);
187        glBlendFunc(mCaches.lastSrcMode, mCaches.lastDstMode);
188        glBlendEquation(GL_FUNC_ADD);
189    } else {
190        glDisable(GL_BLEND);
191    }
192}
193
194///////////////////////////////////////////////////////////////////////////////
195// State management
196///////////////////////////////////////////////////////////////////////////////
197
198int OpenGLRenderer::getSaveCount() const {
199    return mSaveCount;
200}
201
202int OpenGLRenderer::save(int flags) {
203    return saveSnapshot(flags);
204}
205
206void OpenGLRenderer::restore() {
207    if (mSaveCount > 1) {
208        restoreSnapshot();
209    }
210}
211
212void OpenGLRenderer::restoreToCount(int saveCount) {
213    if (saveCount < 1) saveCount = 1;
214
215    while (mSaveCount > saveCount) {
216        restoreSnapshot();
217    }
218}
219
220int OpenGLRenderer::saveSnapshot(int flags) {
221    mSnapshot = new Snapshot(mSnapshot, flags);
222    return mSaveCount++;
223}
224
225bool OpenGLRenderer::restoreSnapshot() {
226    bool restoreClip = mSnapshot->flags & Snapshot::kFlagClipSet;
227    bool restoreLayer = mSnapshot->flags & Snapshot::kFlagIsLayer;
228    bool restoreOrtho = mSnapshot->flags & Snapshot::kFlagDirtyOrtho;
229
230    sp<Snapshot> current = mSnapshot;
231    sp<Snapshot> previous = mSnapshot->previous;
232
233    if (restoreOrtho) {
234        Rect& r = previous->viewport;
235        glViewport(r.left, r.top, r.right, r.bottom);
236        mOrthoMatrix.load(current->orthoMatrix);
237    }
238
239    mSaveCount--;
240    mSnapshot = previous;
241
242    if (restoreLayer) {
243        composeLayer(current, previous);
244    }
245
246    if (restoreClip) {
247        setScissorFromClip();
248    }
249
250    return restoreClip;
251}
252
253///////////////////////////////////////////////////////////////////////////////
254// Layers
255///////////////////////////////////////////////////////////////////////////////
256
257int OpenGLRenderer::saveLayer(float left, float top, float right, float bottom,
258        const SkPaint* p, int flags) {
259    const GLuint previousFbo = mSnapshot->fbo;
260    const int count = saveSnapshot(flags);
261
262    int alpha = 255;
263    SkXfermode::Mode mode;
264
265    if (p) {
266        alpha = p->getAlpha();
267        if (!mExtensions.hasFramebufferFetch()) {
268            const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode);
269            if (!isMode) {
270                // Assume SRC_OVER
271                mode = SkXfermode::kSrcOver_Mode;
272            }
273        } else {
274            mode = getXfermode(p->getXfermode());
275        }
276    } else {
277        mode = SkXfermode::kSrcOver_Mode;
278    }
279
280    if (!mSnapshot->previous->invisible) {
281        createLayer(mSnapshot, left, top, right, bottom, alpha, mode, flags, previousFbo);
282    }
283
284    return count;
285}
286
287int OpenGLRenderer::saveLayerAlpha(float left, float top, float right, float bottom,
288        int alpha, int flags) {
289    if (alpha == 0xff) {
290        return saveLayer(left, top, right, bottom, NULL, flags);
291    } else {
292        SkPaint paint;
293        paint.setAlpha(alpha);
294        return saveLayer(left, top, right, bottom, &paint, flags);
295    }
296}
297
298/**
299 * Layers are viewed by Skia are slightly different than layers in image editing
300 * programs (for instance.) When a layer is created, previously created layers
301 * and the frame buffer still receive every drawing command. For instance, if a
302 * layer is created and a shape intersecting the bounds of the layers and the
303 * framebuffer is draw, the shape will be drawn on both (unless the layer was
304 * created with the SkCanvas::kClipToLayer_SaveFlag flag.)
305 *
306 * A way to implement layers is to create an FBO for each layer, backed by an RGBA
307 * texture. Unfortunately, this is inefficient as it requires every primitive to
308 * be drawn n + 1 times, where n is the number of active layers. In practice this
309 * means, for every primitive:
310 *   - Switch active frame buffer
311 *   - Change viewport, clip and projection matrix
312 *   - Issue the drawing
313 *
314 * Switching rendering target n + 1 times per drawn primitive is extremely costly.
315 * To avoid this, layers are implemented in a different way here, at least in the
316 * general case. FBOs are used, as an optimization, when the "clip to layer" flag
317 * is set. When this flag is set we can redirect all drawing operations into a
318 * single FBO.
319 *
320 * This implementation relies on the frame buffer being at least RGBA 8888. When
321 * a layer is created, only a texture is created, not an FBO. The content of the
322 * frame buffer contained within the layer's bounds is copied into this texture
323 * using glCopyTexImage2D(). The layer's region is then cleared(1) in the frame
324 * buffer and drawing continues as normal. This technique therefore treats the
325 * frame buffer as a scratch buffer for the layers.
326 *
327 * To compose the layers back onto the frame buffer, each layer texture
328 * (containing the original frame buffer data) is drawn as a simple quad over
329 * the frame buffer. The trick is that the quad is set as the composition
330 * destination in the blending equation, and the frame buffer becomes the source
331 * of the composition.
332 *
333 * Drawing layers with an alpha value requires an extra step before composition.
334 * An empty quad is drawn over the layer's region in the frame buffer. This quad
335 * is drawn with the rgba color (0,0,0,alpha). The alpha value offered by the
336 * quad is used to multiply the colors in the frame buffer. This is achieved by
337 * changing the GL blend functions for the GL_FUNC_ADD blend equation to
338 * GL_ZERO, GL_SRC_ALPHA.
339 *
340 * Because glCopyTexImage2D() can be slow, an alternative implementation might
341 * be use to draw a single clipped layer. The implementation described above
342 * is correct in every case.
343 *
344 * (1) The frame buffer is actually not cleared right away. To allow the GPU
345 *     to potentially optimize series of calls to glCopyTexImage2D, the frame
346 *     buffer is left untouched until the first drawing operation. Only when
347 *     something actually gets drawn are the layers regions cleared.
348 */
349bool OpenGLRenderer::createLayer(sp<Snapshot> snapshot, float left, float top,
350        float right, float bottom, int alpha, SkXfermode::Mode mode,
351        int flags, GLuint previousFbo) {
352    LAYER_LOGD("Requesting layer %.2fx%.2f", right - left, bottom - top);
353    LAYER_LOGD("Layer cache size = %d", mCaches.layerCache.getSize());
354
355    const bool fboLayer = flags & SkCanvas::kClipToLayer_SaveFlag;
356
357    // Window coordinates of the layer
358    Rect bounds(left, top, right, bottom);
359    if (!fboLayer) {
360        mSnapshot->transform->mapRect(bounds);
361        // Layers only make sense if they are in the framebuffer's bounds
362        bounds.intersect(*mSnapshot->clipRect);
363        bounds.snapToPixelBoundaries();
364    }
365
366    if (bounds.isEmpty() || bounds.getWidth() > mMaxTextureSize ||
367            bounds.getHeight() > mMaxTextureSize) {
368        snapshot->invisible = true;
369    } else {
370        // TODO: Should take the mode into account
371        snapshot->invisible = snapshot->previous->invisible ||
372                (alpha <= ALPHA_THRESHOLD && fboLayer);
373    }
374
375    // Bail out if we won't draw in this snapshot
376    if (snapshot->invisible) {
377        return false;
378    }
379
380    glActiveTexture(GL_TEXTURE0);
381
382    Layer* layer = mCaches.layerCache.get(bounds.getWidth(), bounds.getHeight());
383    if (!layer) {
384        return false;
385    }
386
387    layer->mode = mode;
388    layer->alpha = alpha;
389    layer->layer.set(bounds);
390    layer->texCoords.set(0.0f, bounds.getHeight() / float(layer->height),
391            bounds.getWidth() / float(layer->width), 0.0f);
392
393    // Save the layer in the snapshot
394    snapshot->flags |= Snapshot::kFlagIsLayer;
395    snapshot->layer = layer;
396
397    if (fboLayer) {
398        layer->fbo = mCaches.fboCache.get();
399
400        snapshot->flags |= Snapshot::kFlagIsFboLayer;
401        snapshot->fbo = layer->fbo;
402        snapshot->resetTransform(-bounds.left, -bounds.top, 0.0f);
403        snapshot->resetClip(0.0f, 0.0f, bounds.getWidth(), bounds.getHeight());
404        snapshot->viewport.set(0.0f, 0.0f, bounds.getWidth(), bounds.getHeight());
405        snapshot->height = bounds.getHeight();
406        snapshot->flags |= Snapshot::kFlagDirtyOrtho;
407        snapshot->orthoMatrix.load(mOrthoMatrix);
408
409        // Bind texture to FBO
410        glBindFramebuffer(GL_FRAMEBUFFER, layer->fbo);
411        glBindTexture(GL_TEXTURE_2D, layer->texture);
412
413        // Initialize the texture if needed
414        if (layer->empty) {
415            layer->empty = false;
416            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, layer->width, layer->height, 0,
417                    GL_RGBA, GL_UNSIGNED_BYTE, NULL);
418        }
419
420        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
421                layer->texture, 0);
422
423#if DEBUG_LAYERS
424        GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
425        if (status != GL_FRAMEBUFFER_COMPLETE) {
426            LOGE("Framebuffer incomplete (GL error code 0x%x)", status);
427
428            glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
429            glDeleteTextures(1, &layer->texture);
430            mCaches.fboCache.put(layer->fbo);
431
432            delete layer;
433
434            return false;
435        }
436#endif
437
438        // Clear the FBO
439        glScissor(0.0f, 0.0f, bounds.getWidth() + 1.0f, bounds.getHeight() + 1.0f);
440        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
441        glClear(GL_COLOR_BUFFER_BIT);
442
443        setScissorFromClip();
444
445        // Change the ortho projection
446        glViewport(0, 0, bounds.getWidth(), bounds.getHeight());
447        mOrthoMatrix.loadOrtho(0.0f, bounds.getWidth(), bounds.getHeight(), 0.0f, -1.0f, 1.0f);
448    } else {
449        // Copy the framebuffer into the layer
450        glBindTexture(GL_TEXTURE_2D, layer->texture);
451
452         if (layer->empty) {
453             glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bounds.left, mHeight - bounds.bottom,
454                     layer->width, layer->height, 0);
455             layer->empty = false;
456         } else {
457             glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bounds.left, mHeight - bounds.bottom,
458                     bounds.getWidth(), bounds.getHeight());
459          }
460
461        // Enqueue the buffer coordinates to clear the corresponding region later
462        mLayers.push(new Rect(bounds));
463    }
464
465    return true;
466}
467
468/**
469 * Read the documentation of createLayer() before doing anything in this method.
470 */
471void OpenGLRenderer::composeLayer(sp<Snapshot> current, sp<Snapshot> previous) {
472    if (!current->layer) {
473        LOGE("Attempting to compose a layer that does not exist");
474        return;
475    }
476
477    const bool fboLayer = current->flags & SkCanvas::kClipToLayer_SaveFlag;
478
479    if (fboLayer) {
480        // Unbind current FBO and restore previous one
481        glBindFramebuffer(GL_FRAMEBUFFER, previous->fbo);
482    }
483
484    // Restore the clip from the previous snapshot
485    const Rect& clip = *previous->clipRect;
486    glScissor(clip.left, previous->height - clip.bottom, clip.getWidth(), clip.getHeight());
487
488    Layer* layer = current->layer;
489    const Rect& rect = layer->layer;
490
491    if (!fboLayer && layer->alpha < 255) {
492        drawColorRect(rect.left, rect.top, rect.right, rect.bottom,
493                layer->alpha << 24, SkXfermode::kDstIn_Mode, true);
494    }
495
496    const Rect& texCoords = layer->texCoords;
497    mCaches.unbindMeshBuffer();
498    resetDrawTextureTexCoords(texCoords.left, texCoords.top, texCoords.right, texCoords.bottom);
499
500    if (fboLayer) {
501        drawTextureMesh(rect.left, rect.top, rect.right, rect.bottom, layer->texture,
502                layer->alpha / 255.0f, layer->mode, layer->blend, &mMeshVertices[0].position[0],
503                &mMeshVertices[0].texture[0], GL_TRIANGLE_STRIP, gMeshCount);
504    } else {
505        drawTextureMesh(rect.left, rect.top, rect.right, rect.bottom, layer->texture,
506                1.0f, layer->mode, layer->blend, &mMeshVertices[0].position[0],
507                &mMeshVertices[0].texture[0], GL_TRIANGLE_STRIP, gMeshCount, true, true);
508    }
509
510    resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
511
512    if (fboLayer) {
513        // Detach the texture from the FBO
514        glBindFramebuffer(GL_FRAMEBUFFER, current->fbo);
515        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
516        glBindFramebuffer(GL_FRAMEBUFFER, previous->fbo);
517
518        // Put the FBO name back in the cache, if it doesn't fit, it will be destroyed
519        mCaches.fboCache.put(current->fbo);
520    }
521
522    // Failing to add the layer to the cache should happen only if the layer is too large
523    if (!mCaches.layerCache.put(layer)) {
524        LAYER_LOGD("Deleting layer");
525        glDeleteTextures(1, &layer->texture);
526        delete layer;
527    }
528}
529
530void OpenGLRenderer::clearLayerRegions() {
531    if (mLayers.size() == 0 || mSnapshot->invisible) return;
532
533    for (uint32_t i = 0; i < mLayers.size(); i++) {
534        Rect* bounds = mLayers.itemAt(i);
535
536        // Clear the framebuffer where the layer will draw
537        glScissor(bounds->left, mSnapshot->height - bounds->bottom,
538                bounds->getWidth(), bounds->getHeight());
539        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
540        glClear(GL_COLOR_BUFFER_BIT);
541
542        delete bounds;
543    }
544    mLayers.clear();
545
546    // Restore the clip
547    setScissorFromClip();
548}
549
550///////////////////////////////////////////////////////////////////////////////
551// Transforms
552///////////////////////////////////////////////////////////////////////////////
553
554void OpenGLRenderer::translate(float dx, float dy) {
555    mSnapshot->transform->translate(dx, dy, 0.0f);
556}
557
558void OpenGLRenderer::rotate(float degrees) {
559    mSnapshot->transform->rotate(degrees, 0.0f, 0.0f, 1.0f);
560}
561
562void OpenGLRenderer::scale(float sx, float sy) {
563    mSnapshot->transform->scale(sx, sy, 1.0f);
564}
565
566void OpenGLRenderer::setMatrix(SkMatrix* matrix) {
567    mSnapshot->transform->load(*matrix);
568}
569
570const float* OpenGLRenderer::getMatrix() const {
571    if (mSnapshot->fbo != 0) {
572        return &mSnapshot->transform->data[0];
573    }
574    return &mIdentity.data[0];
575}
576
577void OpenGLRenderer::getMatrix(SkMatrix* matrix) {
578    mSnapshot->transform->copyTo(*matrix);
579}
580
581void OpenGLRenderer::concatMatrix(SkMatrix* matrix) {
582    SkMatrix transform;
583    mSnapshot->transform->copyTo(transform);
584    transform.preConcat(*matrix);
585    mSnapshot->transform->load(transform);
586}
587
588///////////////////////////////////////////////////////////////////////////////
589// Clipping
590///////////////////////////////////////////////////////////////////////////////
591
592void OpenGLRenderer::setScissorFromClip() {
593    Rect clip(*mSnapshot->clipRect);
594    clip.snapToPixelBoundaries();
595    glScissor(clip.left, mSnapshot->height - clip.bottom, clip.getWidth(), clip.getHeight());
596}
597
598const Rect& OpenGLRenderer::getClipBounds() {
599    return mSnapshot->getLocalClip();
600}
601
602bool OpenGLRenderer::quickReject(float left, float top, float right, float bottom) {
603    if (mSnapshot->invisible) {
604        return true;
605    }
606
607    Rect r(left, top, right, bottom);
608    mSnapshot->transform->mapRect(r);
609    r.snapToPixelBoundaries();
610
611    Rect clipRect(*mSnapshot->clipRect);
612    clipRect.snapToPixelBoundaries();
613
614    return !clipRect.intersects(r);
615}
616
617bool OpenGLRenderer::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {
618    bool clipped = mSnapshot->clip(left, top, right, bottom, op);
619    if (clipped) {
620        setScissorFromClip();
621    }
622    return !mSnapshot->clipRect->isEmpty();
623}
624
625///////////////////////////////////////////////////////////////////////////////
626// Drawing
627///////////////////////////////////////////////////////////////////////////////
628
629void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, const SkPaint* paint) {
630    const float right = left + bitmap->width();
631    const float bottom = top + bitmap->height();
632
633    if (quickReject(left, top, right, bottom)) {
634        return;
635    }
636
637    glActiveTexture(GL_TEXTURE0);
638    const Texture* texture = mCaches.textureCache.get(bitmap);
639    if (!texture) return;
640    const AutoTexture autoCleanup(texture);
641
642    drawTextureRect(left, top, right, bottom, texture, paint);
643}
644
645void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, const SkMatrix* matrix, const SkPaint* paint) {
646    Rect r(0.0f, 0.0f, bitmap->width(), bitmap->height());
647    const mat4 transform(*matrix);
648    transform.mapRect(r);
649
650    if (quickReject(r.left, r.top, r.right, r.bottom)) {
651        return;
652    }
653
654    glActiveTexture(GL_TEXTURE0);
655    const Texture* texture = mCaches.textureCache.get(bitmap);
656    if (!texture) return;
657    const AutoTexture autoCleanup(texture);
658
659    drawTextureRect(r.left, r.top, r.right, r.bottom, texture, paint);
660}
661
662void OpenGLRenderer::drawBitmap(SkBitmap* bitmap,
663         float srcLeft, float srcTop, float srcRight, float srcBottom,
664         float dstLeft, float dstTop, float dstRight, float dstBottom,
665         const SkPaint* paint) {
666    if (quickReject(dstLeft, dstTop, dstRight, dstBottom)) {
667        return;
668    }
669
670    glActiveTexture(GL_TEXTURE0);
671    const Texture* texture = mCaches.textureCache.get(bitmap);
672    if (!texture) return;
673    const AutoTexture autoCleanup(texture);
674
675    const float width = texture->width;
676    const float height = texture->height;
677
678    const float u1 = srcLeft / width;
679    const float v1 = srcTop / height;
680    const float u2 = srcRight / width;
681    const float v2 = srcBottom / height;
682
683    mCaches.unbindMeshBuffer();
684    resetDrawTextureTexCoords(u1, v1, u2, v2);
685
686    int alpha;
687    SkXfermode::Mode mode;
688    getAlphaAndMode(paint, &alpha, &mode);
689
690    drawTextureMesh(dstLeft, dstTop, dstRight, dstBottom, texture->id, alpha / 255.0f,
691            mode, texture->blend, &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0],
692            GL_TRIANGLE_STRIP, gMeshCount);
693
694    resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
695}
696
697void OpenGLRenderer::drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
698        const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
699        float left, float top, float right, float bottom, const SkPaint* paint) {
700    if (quickReject(left, top, right, bottom)) {
701        return;
702    }
703
704    glActiveTexture(GL_TEXTURE0);
705    const Texture* texture = mCaches.textureCache.get(bitmap);
706    if (!texture) return;
707    const AutoTexture autoCleanup(texture);
708
709    int alpha;
710    SkXfermode::Mode mode;
711    getAlphaAndMode(paint, &alpha, &mode);
712
713    const Patch* mesh = mCaches.patchCache.get(bitmap->width(), bitmap->height(),
714            right - left, bottom - top, xDivs, yDivs, colors, width, height, numColors);
715
716    if (mesh) {
717        // Specify right and bottom as +1.0f from left/top to prevent scaling since the
718        // patch mesh already defines the final size
719        drawTextureMesh(left, top, left + 1.0f, top + 1.0f, texture->id, alpha / 255.0f,
720                mode, texture->blend, (GLvoid*) 0, (GLvoid*) gMeshTextureOffset,
721                GL_TRIANGLES, mesh->verticesCount, false, false, mesh->meshBuffer);
722    }
723}
724
725void OpenGLRenderer::drawLines(float* points, int count, const SkPaint* paint) {
726    if (mSnapshot->invisible) return;
727
728    int alpha;
729    SkXfermode::Mode mode;
730    getAlphaAndMode(paint, &alpha, &mode);
731
732    uint32_t color = paint->getColor();
733    const GLfloat a = alpha / 255.0f;
734    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;
735    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;
736    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;
737
738    const bool isAA = paint->isAntiAlias();
739    if (isAA) {
740        GLuint textureUnit = 0;
741        setupTextureAlpha8(mCaches.line.getTexture(), 0, 0, textureUnit, 0.0f, 0.0f, r, g, b, a,
742                mode, false, true, (GLvoid*) 0, (GLvoid*) gMeshTextureOffset,
743                mCaches.line.getMeshBuffer());
744    } else {
745        setupColorRect(0.0f, 0.0f, 1.0f, 1.0f, r, g, b, a, mode, false);
746    }
747
748    const float strokeWidth = paint->getStrokeWidth();
749    const GLsizei elementsCount = isAA ? mCaches.line.getElementsCount() : gMeshCount;
750    const GLenum drawMode = isAA ? GL_TRIANGLES : GL_TRIANGLE_STRIP;
751
752    for (int i = 0; i < count; i += 4) {
753        float tx = 0.0f;
754        float ty = 0.0f;
755
756        if (isAA) {
757            mCaches.line.update(points[i], points[i + 1], points[i + 2], points[i + 3],
758                    strokeWidth, tx, ty);
759        } else {
760            ty = strokeWidth <= 1.0f ? 0.0f : -strokeWidth * 0.5f;
761        }
762
763        const float dx = points[i + 2] - points[i];
764        const float dy = points[i + 3] - points[i + 1];
765        const float mag = sqrtf(dx * dx + dy * dy);
766        const float angle = acos(dx / mag);
767
768        mModelView.loadTranslate(points[i], points[i + 1], 0.0f);
769        if (angle > MIN_ANGLE || angle < -MIN_ANGLE) {
770            mModelView.rotate(angle * RAD_TO_DEG, 0.0f, 0.0f, 1.0f);
771        }
772        mModelView.translate(tx, ty, 0.0f);
773        if (!isAA) {
774            float length = mCaches.line.getLength(points[i], points[i + 1],
775                    points[i + 2], points[i + 3]);
776            mModelView.scale(length, strokeWidth, 1.0f);
777        }
778        mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform);
779
780        if (mShader) {
781            mShader->updateTransforms(mCaches.currentProgram, mModelView, *mSnapshot);
782        }
783
784        glDrawArrays(drawMode, 0, elementsCount);
785    }
786
787    if (isAA) {
788        glDisableVertexAttribArray(mCaches.currentProgram->getAttrib("texCoords"));
789    }
790}
791
792void OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) {
793    const Rect& clip = *mSnapshot->clipRect;
794    drawColorRect(clip.left, clip.top, clip.right, clip.bottom, color, mode, true);
795}
796
797void OpenGLRenderer::drawRect(float left, float top, float right, float bottom, const SkPaint* p) {
798    if (quickReject(left, top, right, bottom)) {
799        return;
800    }
801
802    SkXfermode::Mode mode;
803    if (!mExtensions.hasFramebufferFetch()) {
804        const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode);
805        if (!isMode) {
806            // Assume SRC_OVER
807            mode = SkXfermode::kSrcOver_Mode;
808        }
809    } else {
810        mode = getXfermode(p->getXfermode());
811    }
812
813    // Skia draws using the color's alpha channel if < 255
814    // Otherwise, it uses the paint's alpha
815    int color = p->getColor();
816    if (((color >> 24) & 0xff) == 255) {
817        color |= p->getAlpha() << 24;
818    }
819
820    drawColorRect(left, top, right, bottom, color, mode);
821}
822
823void OpenGLRenderer::drawText(const char* text, int bytesCount, int count,
824        float x, float y, SkPaint* paint) {
825    if (text == NULL || count == 0 || (paint->getAlpha() == 0 && paint->getXfermode() == NULL)) {
826        return;
827    }
828    if (mSnapshot->invisible) return;
829
830    paint->setAntiAlias(true);
831
832    float length = -1.0f;
833    switch (paint->getTextAlign()) {
834        case SkPaint::kCenter_Align:
835            length = paint->measureText(text, bytesCount);
836            x -= length / 2.0f;
837            break;
838        case SkPaint::kRight_Align:
839            length = paint->measureText(text, bytesCount);
840            x -= length;
841            break;
842        default:
843            break;
844    }
845
846    int alpha;
847    SkXfermode::Mode mode;
848    getAlphaAndMode(paint, &alpha, &mode);
849
850    uint32_t color = paint->getColor();
851    const GLfloat a = alpha / 255.0f;
852    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;
853    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;
854    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;
855
856    FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer(paint);
857    fontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()),
858            paint->getTextSize());
859
860    Rect clipRect(*mSnapshot->clipRect);
861    glScissor(clipRect.left, mSnapshot->height - clipRect.bottom,
862            clipRect.getWidth(), clipRect.getHeight());
863
864    if (mHasShadow) {
865        glActiveTexture(gTextureUnits[0]);
866        mCaches.dropShadowCache.setFontRenderer(fontRenderer);
867        const ShadowTexture* shadow = mCaches.dropShadowCache.get(paint, text, bytesCount,
868                count, mShadowRadius);
869        const AutoTexture autoCleanup(shadow);
870
871        setupShadow(shadow, x, y, mode, a);
872
873        // Draw the mesh
874        glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
875        glDisableVertexAttribArray(mCaches.currentProgram->getAttrib("texCoords"));
876    }
877
878    GLuint textureUnit = 0;
879    glActiveTexture(gTextureUnits[textureUnit]);
880
881    // Assume that the modelView matrix does not force scales, rotates, etc.
882    const bool linearFilter = mSnapshot->transform->changesBounds();
883    setupTextureAlpha8(fontRenderer.getTexture(linearFilter), 0, 0, textureUnit,
884            x, y, r, g, b, a, mode, false, true, NULL, NULL);
885
886    const Rect& clip = mSnapshot->getLocalClip();
887    clearLayerRegions();
888
889    mCaches.unbindMeshBuffer();
890    fontRenderer.renderText(paint, &clip, text, 0, bytesCount, count, x, y);
891
892    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
893    glDisableVertexAttribArray(mCaches.currentProgram->getAttrib("texCoords"));
894
895    drawTextDecorations(text, bytesCount, length, x, y, paint);
896
897    setScissorFromClip();
898}
899
900void OpenGLRenderer::drawPath(SkPath* path, SkPaint* paint) {
901    if (mSnapshot->invisible) return;
902
903    GLuint textureUnit = 0;
904    glActiveTexture(gTextureUnits[textureUnit]);
905
906    const PathTexture* texture = mCaches.pathCache.get(path, paint);
907    if (!texture) return;
908    const AutoTexture autoCleanup(texture);
909
910    const float x = texture->left - texture->offset;
911    const float y = texture->top - texture->offset;
912
913    if (quickReject(x, y, x + texture->width, y + texture->height)) {
914        return;
915    }
916
917    int alpha;
918    SkXfermode::Mode mode;
919    getAlphaAndMode(paint, &alpha, &mode);
920
921    uint32_t color = paint->getColor();
922    const GLfloat a = alpha / 255.0f;
923    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;
924    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;
925    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;
926
927    setupTextureAlpha8(texture, textureUnit, x, y, r, g, b, a, mode, true, true);
928
929    clearLayerRegions();
930
931    // Draw the mesh
932    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
933    glDisableVertexAttribArray(mCaches.currentProgram->getAttrib("texCoords"));
934}
935
936///////////////////////////////////////////////////////////////////////////////
937// Shaders
938///////////////////////////////////////////////////////////////////////////////
939
940void OpenGLRenderer::resetShader() {
941    mShader = NULL;
942}
943
944void OpenGLRenderer::setupShader(SkiaShader* shader) {
945    mShader = shader;
946    if (mShader) {
947        mShader->set(&mCaches.textureCache, &mCaches.gradientCache);
948    }
949}
950
951///////////////////////////////////////////////////////////////////////////////
952// Color filters
953///////////////////////////////////////////////////////////////////////////////
954
955void OpenGLRenderer::resetColorFilter() {
956    mColorFilter = NULL;
957}
958
959void OpenGLRenderer::setupColorFilter(SkiaColorFilter* filter) {
960    mColorFilter = filter;
961}
962
963///////////////////////////////////////////////////////////////////////////////
964// Drop shadow
965///////////////////////////////////////////////////////////////////////////////
966
967void OpenGLRenderer::resetShadow() {
968    mHasShadow = false;
969}
970
971void OpenGLRenderer::setupShadow(float radius, float dx, float dy, int color) {
972    mHasShadow = true;
973    mShadowRadius = radius;
974    mShadowDx = dx;
975    mShadowDy = dy;
976    mShadowColor = color;
977}
978
979///////////////////////////////////////////////////////////////////////////////
980// Drawing implementation
981///////////////////////////////////////////////////////////////////////////////
982
983void OpenGLRenderer::setupShadow(const ShadowTexture* texture, float x, float y,
984        SkXfermode::Mode mode, float alpha) {
985    const float sx = x - texture->left + mShadowDx;
986    const float sy = y - texture->top + mShadowDy;
987
988    const int shadowAlpha = ((mShadowColor >> 24) & 0xFF);
989    const GLfloat a = shadowAlpha < 255 ? shadowAlpha / 255.0f : alpha;
990    const GLfloat r = a * ((mShadowColor >> 16) & 0xFF) / 255.0f;
991    const GLfloat g = a * ((mShadowColor >>  8) & 0xFF) / 255.0f;
992    const GLfloat b = a * ((mShadowColor      ) & 0xFF) / 255.0f;
993
994    GLuint textureUnit = 0;
995    setupTextureAlpha8(texture, textureUnit, sx, sy, r, g, b, a, mode, true, false);
996}
997
998void OpenGLRenderer::setupTextureAlpha8(const Texture* texture, GLuint& textureUnit,
999        float x, float y, float r, float g, float b, float a, SkXfermode::Mode mode,
1000        bool transforms, bool applyFilters) {
1001    setupTextureAlpha8(texture->id, texture->width, texture->height, textureUnit,
1002            x, y, r, g, b, a, mode, transforms, applyFilters,
1003            (GLvoid*) 0, (GLvoid*) gMeshTextureOffset);
1004}
1005
1006void OpenGLRenderer::setupTextureAlpha8(GLuint texture, uint32_t width, uint32_t height,
1007        GLuint& textureUnit, float x, float y, float r, float g, float b, float a,
1008        SkXfermode::Mode mode, bool transforms, bool applyFilters) {
1009    setupTextureAlpha8(texture, width, height, textureUnit, x, y, r, g, b, a, mode,
1010            transforms, applyFilters, (GLvoid*) 0, (GLvoid*) gMeshTextureOffset);
1011}
1012
1013void OpenGLRenderer::setupTextureAlpha8(GLuint texture, uint32_t width, uint32_t height,
1014        GLuint& textureUnit, float x, float y, float r, float g, float b, float a,
1015        SkXfermode::Mode mode, bool transforms, bool applyFilters,
1016        GLvoid* vertices, GLvoid* texCoords, GLuint vbo) {
1017     // Describe the required shaders
1018     ProgramDescription description;
1019     description.hasTexture = true;
1020     description.hasAlpha8Texture = true;
1021     const bool setColor = description.setAlpha8Color(r, g, b, a);
1022
1023     if (applyFilters) {
1024         if (mShader) {
1025             mShader->describe(description, mExtensions);
1026         }
1027         if (mColorFilter) {
1028             mColorFilter->describe(description, mExtensions);
1029         }
1030     }
1031
1032     // Setup the blending mode
1033     chooseBlending(true, mode, description);
1034
1035     // Build and use the appropriate shader
1036     useProgram(mCaches.programCache.get(description));
1037
1038     bindTexture(texture, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, textureUnit);
1039     glUniform1i(mCaches.currentProgram->getUniform("sampler"), textureUnit);
1040
1041     int texCoordsSlot = mCaches.currentProgram->getAttrib("texCoords");
1042     glEnableVertexAttribArray(texCoordsSlot);
1043
1044     if (texCoords) {
1045         // Setup attributes
1046         if (!vertices) {
1047             mCaches.bindMeshBuffer(vbo == 0 ? mCaches.meshBuffer : vbo);
1048         } else {
1049             mCaches.unbindMeshBuffer();
1050         }
1051         glVertexAttribPointer(mCaches.currentProgram->position, 2, GL_FLOAT, GL_FALSE,
1052                 gMeshStride, vertices);
1053         glVertexAttribPointer(texCoordsSlot, 2, GL_FLOAT, GL_FALSE, gMeshStride, texCoords);
1054     }
1055
1056     // Setup uniforms
1057     if (transforms) {
1058         mModelView.loadTranslate(x, y, 0.0f);
1059         mModelView.scale(width, height, 1.0f);
1060     } else {
1061         mModelView.loadIdentity();
1062     }
1063     mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform);
1064     if (setColor) {
1065         mCaches.currentProgram->setColor(r, g, b, a);
1066     }
1067
1068     textureUnit++;
1069     if (applyFilters) {
1070         // Setup attributes and uniforms required by the shaders
1071         if (mShader) {
1072             mShader->setupProgram(mCaches.currentProgram, mModelView, *mSnapshot, &textureUnit);
1073         }
1074         if (mColorFilter) {
1075             mColorFilter->setupProgram(mCaches.currentProgram);
1076         }
1077     }
1078}
1079
1080// Same values used by Skia
1081#define kStdStrikeThru_Offset   (-6.0f / 21.0f)
1082#define kStdUnderline_Offset    (1.0f / 9.0f)
1083#define kStdUnderline_Thickness (1.0f / 18.0f)
1084
1085void OpenGLRenderer::drawTextDecorations(const char* text, int bytesCount, float length,
1086        float x, float y, SkPaint* paint) {
1087    // Handle underline and strike-through
1088    uint32_t flags = paint->getFlags();
1089    if (flags & (SkPaint::kUnderlineText_Flag | SkPaint::kStrikeThruText_Flag)) {
1090        float underlineWidth = length;
1091        // If length is > 0.0f, we already measured the text for the text alignment
1092        if (length <= 0.0f) {
1093            underlineWidth = paint->measureText(text, bytesCount);
1094        }
1095
1096        float offsetX = 0;
1097        switch (paint->getTextAlign()) {
1098            case SkPaint::kCenter_Align:
1099                offsetX = underlineWidth * 0.5f;
1100                break;
1101            case SkPaint::kRight_Align:
1102                offsetX = underlineWidth;
1103                break;
1104            default:
1105                break;
1106        }
1107
1108        if (underlineWidth > 0.0f) {
1109            const float textSize = paint->getTextSize();
1110            const float strokeWidth = textSize * kStdUnderline_Thickness;
1111
1112            const float left = x - offsetX;
1113            float top = 0.0f;
1114
1115            const int pointsCount = 4 * (flags & SkPaint::kStrikeThruText_Flag ? 2 : 1);
1116            float points[pointsCount];
1117            int currentPoint = 0;
1118
1119            if (flags & SkPaint::kUnderlineText_Flag) {
1120                top = y + textSize * kStdUnderline_Offset;
1121                points[currentPoint++] = left;
1122                points[currentPoint++] = top;
1123                points[currentPoint++] = left + underlineWidth;
1124                points[currentPoint++] = top;
1125            }
1126
1127            if (flags & SkPaint::kStrikeThruText_Flag) {
1128                top = y + textSize * kStdStrikeThru_Offset;
1129                points[currentPoint++] = left;
1130                points[currentPoint++] = top;
1131                points[currentPoint++] = left + underlineWidth;
1132                points[currentPoint++] = top;
1133            }
1134
1135            SkPaint linesPaint(*paint);
1136            linesPaint.setStrokeWidth(strokeWidth);
1137
1138            drawLines(&points[0], pointsCount, &linesPaint);
1139        }
1140    }
1141}
1142
1143void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom,
1144        int color, SkXfermode::Mode mode, bool ignoreTransform) {
1145    clearLayerRegions();
1146
1147    // If a shader is set, preserve only the alpha
1148    if (mShader) {
1149        color |= 0x00ffffff;
1150    }
1151
1152    // Render using pre-multiplied alpha
1153    const int alpha = (color >> 24) & 0xFF;
1154    const GLfloat a = alpha / 255.0f;
1155    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;
1156    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;
1157    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;
1158
1159    setupColorRect(left, top, right, bottom, r, g, b, a, mode, ignoreTransform);
1160
1161    // Draw the mesh
1162    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
1163}
1164
1165void OpenGLRenderer::setupColorRect(float left, float top, float right, float bottom,
1166        float r, float g, float b, float a, SkXfermode::Mode mode, bool ignoreTransform) {
1167    GLuint textureUnit = 0;
1168
1169    // Describe the required shaders
1170    ProgramDescription description;
1171    const bool setColor = description.setColor(r, g, b, a);
1172
1173    if (mShader) {
1174        mShader->describe(description, mExtensions);
1175    }
1176    if (mColorFilter) {
1177        mColorFilter->describe(description, mExtensions);
1178    }
1179
1180    // Setup the blending mode
1181    chooseBlending(a < 1.0f || (mShader && mShader->blend()), mode, description);
1182
1183    // Build and use the appropriate shader
1184    useProgram(mCaches.programCache.get(description));
1185
1186    // Setup attributes
1187    mCaches.bindMeshBuffer();
1188    glVertexAttribPointer(mCaches.currentProgram->position, 2, GL_FLOAT, GL_FALSE,
1189            gMeshStride, 0);
1190
1191    // Setup uniforms
1192    mModelView.loadTranslate(left, top, 0.0f);
1193    mModelView.scale(right - left, bottom - top, 1.0f);
1194    if (!ignoreTransform) {
1195        mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform);
1196    } else {
1197        mat4 identity;
1198        mCaches.currentProgram->set(mOrthoMatrix, mModelView, identity);
1199    }
1200    mCaches.currentProgram->setColor(r, g, b, a);
1201
1202    // Setup attributes and uniforms required by the shaders
1203    if (mShader) {
1204        mShader->setupProgram(mCaches.currentProgram, mModelView, *mSnapshot, &textureUnit);
1205    }
1206    if (mColorFilter) {
1207        mColorFilter->setupProgram(mCaches.currentProgram);
1208    }
1209}
1210
1211void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
1212        const Texture* texture, const SkPaint* paint) {
1213    int alpha;
1214    SkXfermode::Mode mode;
1215    getAlphaAndMode(paint, &alpha, &mode);
1216
1217    drawTextureMesh(left, top, right, bottom, texture->id, alpha / 255.0f, mode,
1218            texture->blend, (GLvoid*) NULL, (GLvoid*) gMeshTextureOffset,
1219            GL_TRIANGLE_STRIP, gMeshCount);
1220}
1221
1222void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
1223        GLuint texture, float alpha, SkXfermode::Mode mode, bool blend) {
1224    drawTextureMesh(left, top, right, bottom, texture, alpha, mode, blend,
1225            (GLvoid*) NULL, (GLvoid*) gMeshTextureOffset, GL_TRIANGLE_STRIP, gMeshCount);
1226}
1227
1228void OpenGLRenderer::drawTextureMesh(float left, float top, float right, float bottom,
1229        GLuint texture, float alpha, SkXfermode::Mode mode, bool blend,
1230        GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,
1231        bool swapSrcDst, bool ignoreTransform, GLuint vbo) {
1232    clearLayerRegions();
1233
1234    ProgramDescription description;
1235    description.hasTexture = true;
1236    const bool setColor = description.setColor(alpha, alpha, alpha, alpha);
1237    if (mColorFilter) {
1238        mColorFilter->describe(description, mExtensions);
1239    }
1240
1241    mModelView.loadTranslate(left, top, 0.0f);
1242    mModelView.scale(right - left, bottom - top, 1.0f);
1243
1244    chooseBlending(blend || alpha < 1.0f, mode, description, swapSrcDst);
1245
1246    useProgram(mCaches.programCache.get(description));
1247    if (!ignoreTransform) {
1248        mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform);
1249    } else {
1250        mat4 m;
1251        mCaches.currentProgram->set(mOrthoMatrix, mModelView, m);
1252    }
1253
1254    // Texture
1255    bindTexture(texture, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, 0);
1256    glUniform1i(mCaches.currentProgram->getUniform("sampler"), 0);
1257
1258    // Always premultiplied
1259    if (setColor) {
1260        mCaches.currentProgram->setColor(alpha, alpha, alpha, alpha);
1261    }
1262
1263    // Mesh
1264    int texCoordsSlot = mCaches.currentProgram->getAttrib("texCoords");
1265    glEnableVertexAttribArray(texCoordsSlot);
1266
1267    if (!vertices) {
1268        mCaches.bindMeshBuffer(vbo == 0 ? mCaches.meshBuffer : vbo);
1269    } else {
1270        mCaches.unbindMeshBuffer();
1271    }
1272    glVertexAttribPointer(mCaches.currentProgram->position, 2, GL_FLOAT, GL_FALSE,
1273            gMeshStride, vertices);
1274    glVertexAttribPointer(texCoordsSlot, 2, GL_FLOAT, GL_FALSE, gMeshStride, texCoords);
1275
1276    // Color filter
1277    if (mColorFilter) {
1278        mColorFilter->setupProgram(mCaches.currentProgram);
1279    }
1280
1281    glDrawArrays(drawMode, 0, elementsCount);
1282    glDisableVertexAttribArray(texCoordsSlot);
1283}
1284
1285void OpenGLRenderer::chooseBlending(bool blend, SkXfermode::Mode mode,
1286        ProgramDescription& description, bool swapSrcDst) {
1287    blend = blend || mode != SkXfermode::kSrcOver_Mode;
1288    if (blend) {
1289        if (mode < SkXfermode::kPlus_Mode) {
1290            if (!mCaches.blend) {
1291                glEnable(GL_BLEND);
1292            }
1293
1294            GLenum sourceMode = swapSrcDst ? gBlendsSwap[mode].src : gBlends[mode].src;
1295            GLenum destMode = swapSrcDst ? gBlendsSwap[mode].dst : gBlends[mode].dst;
1296
1297            if (sourceMode != mCaches.lastSrcMode || destMode != mCaches.lastDstMode) {
1298                glBlendFunc(sourceMode, destMode);
1299                mCaches.lastSrcMode = sourceMode;
1300                mCaches.lastDstMode = destMode;
1301            }
1302        } else {
1303            // These blend modes are not supported by OpenGL directly and have
1304            // to be implemented using shaders. Since the shader will perform
1305            // the blending, turn blending off here
1306            if (mExtensions.hasFramebufferFetch()) {
1307                description.framebufferMode = mode;
1308                description.swapSrcDst = swapSrcDst;
1309            }
1310
1311            if (mCaches.blend) {
1312                glDisable(GL_BLEND);
1313            }
1314            blend = false;
1315        }
1316    } else if (mCaches.blend) {
1317        glDisable(GL_BLEND);
1318    }
1319    mCaches.blend = blend;
1320}
1321
1322bool OpenGLRenderer::useProgram(Program* program) {
1323    if (!program->isInUse()) {
1324        if (mCaches.currentProgram != NULL) mCaches.currentProgram->remove();
1325        program->use();
1326        mCaches.currentProgram = program;
1327        return false;
1328    }
1329    return true;
1330}
1331
1332void OpenGLRenderer::resetDrawTextureTexCoords(float u1, float v1, float u2, float v2) {
1333    TextureVertex* v = &mMeshVertices[0];
1334    TextureVertex::setUV(v++, u1, v1);
1335    TextureVertex::setUV(v++, u2, v1);
1336    TextureVertex::setUV(v++, u1, v2);
1337    TextureVertex::setUV(v++, u2, v2);
1338}
1339
1340void OpenGLRenderer::getAlphaAndMode(const SkPaint* paint, int* alpha, SkXfermode::Mode* mode) {
1341    if (paint) {
1342        if (!mExtensions.hasFramebufferFetch()) {
1343            const bool isMode = SkXfermode::IsMode(paint->getXfermode(), mode);
1344            if (!isMode) {
1345                // Assume SRC_OVER
1346                *mode = SkXfermode::kSrcOver_Mode;
1347            }
1348        } else {
1349            *mode = getXfermode(paint->getXfermode());
1350        }
1351
1352        // Skia draws using the color's alpha channel if < 255
1353        // Otherwise, it uses the paint's alpha
1354        int color = paint->getColor();
1355        *alpha = (color >> 24) & 0xFF;
1356        if (*alpha == 255) {
1357            *alpha = paint->getAlpha();
1358        }
1359    } else {
1360        *mode = SkXfermode::kSrcOver_Mode;
1361        *alpha = 255;
1362    }
1363}
1364
1365SkXfermode::Mode OpenGLRenderer::getXfermode(SkXfermode* mode) {
1366    if (mode == NULL) {
1367        return SkXfermode::kSrcOver_Mode;
1368    }
1369    return mode->fMode;
1370}
1371
1372void OpenGLRenderer::bindTexture(GLuint texture, GLenum wrapS, GLenum wrapT, GLuint textureUnit) {
1373    glActiveTexture(gTextureUnits[textureUnit]);
1374    glBindTexture(GL_TEXTURE_2D, texture);
1375    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
1376    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);
1377}
1378
1379}; // namespace uirenderer
1380}; // namespace android
1381