OpenGLRenderer.cpp revision 35643ddc689913f5b5f80ceed864470d987bd6cd 
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 <SkPathMeasure.h>
25#include <SkTypeface.h>
26
27#include <utils/Log.h>
28#include <utils/StopWatch.h>
29
30#include <private/hwui/DrawGlInfo.h>
31
32#include <ui/Rect.h>
33
34#include "OpenGLRenderer.h"
35#include "DisplayListRenderer.h"
36#include "Vector.h"
37
38namespace android {
39namespace uirenderer {
40
41///////////////////////////////////////////////////////////////////////////////
42// Defines
43///////////////////////////////////////////////////////////////////////////////
44
45#define RAD_TO_DEG (180.0f / 3.14159265f)
46#define MIN_ANGLE 0.001f
47
48#define ALPHA_THRESHOLD 0
49
50#define FILTER(paint) (paint && paint->isFilterBitmap() ? GL_LINEAR : GL_NEAREST)
51
52///////////////////////////////////////////////////////////////////////////////
53// Globals
54///////////////////////////////////////////////////////////////////////////////
55
56/**
57 * Structure mapping Skia xfermodes to OpenGL blending factors.
58 */
59struct Blender {
60    SkXfermode::Mode mode;
61    GLenum src;
62    GLenum dst;
63}; // struct Blender
64
65// In this array, the index of each Blender equals the value of the first
66// entry. For instance, gBlends[1] == gBlends[SkXfermode::kSrc_Mode]
67static const Blender gBlends[] = {
68    { SkXfermode::kClear_Mode,    GL_ZERO,                GL_ONE_MINUS_SRC_ALPHA },
69    { SkXfermode::kSrc_Mode,      GL_ONE,                 GL_ZERO },
70    { SkXfermode::kDst_Mode,      GL_ZERO,                GL_ONE },
71    { SkXfermode::kSrcOver_Mode,  GL_ONE,                 GL_ONE_MINUS_SRC_ALPHA },
72    { SkXfermode::kDstOver_Mode,  GL_ONE_MINUS_DST_ALPHA, GL_ONE },
73    { SkXfermode::kSrcIn_Mode,    GL_DST_ALPHA,           GL_ZERO },
74    { SkXfermode::kDstIn_Mode,    GL_ZERO,                GL_SRC_ALPHA },
75    { SkXfermode::kSrcOut_Mode,   GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
76    { SkXfermode::kDstOut_Mode,   GL_ZERO,                GL_ONE_MINUS_SRC_ALPHA },
77    { SkXfermode::kSrcATop_Mode,  GL_DST_ALPHA,           GL_ONE_MINUS_SRC_ALPHA },
78    { SkXfermode::kDstATop_Mode,  GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA },
79    { SkXfermode::kXor_Mode,      GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
80    { SkXfermode::kPlus_Mode,     GL_ONE,                 GL_ONE },
81    { SkXfermode::kMultiply_Mode, GL_ZERO,                GL_SRC_COLOR },
82    { SkXfermode::kScreen_Mode,   GL_ONE,                 GL_ONE_MINUS_SRC_COLOR }
83};
84
85// This array contains the swapped version of each SkXfermode. For instance
86// this array's SrcOver blending mode is actually DstOver. You can refer to
87// createLayer() for more information on the purpose of this array.
88static const Blender gBlendsSwap[] = {
89    { SkXfermode::kClear_Mode,    GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
90    { SkXfermode::kSrc_Mode,      GL_ZERO,                GL_ONE },
91    { SkXfermode::kDst_Mode,      GL_ONE,                 GL_ZERO },
92    { SkXfermode::kSrcOver_Mode,  GL_ONE_MINUS_DST_ALPHA, GL_ONE },
93    { SkXfermode::kDstOver_Mode,  GL_ONE,                 GL_ONE_MINUS_SRC_ALPHA },
94    { SkXfermode::kSrcIn_Mode,    GL_ZERO,                GL_SRC_ALPHA },
95    { SkXfermode::kDstIn_Mode,    GL_DST_ALPHA,           GL_ZERO },
96    { SkXfermode::kSrcOut_Mode,   GL_ZERO,                GL_ONE_MINUS_SRC_ALPHA },
97    { SkXfermode::kDstOut_Mode,   GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
98    { SkXfermode::kSrcATop_Mode,  GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA },
99    { SkXfermode::kDstATop_Mode,  GL_DST_ALPHA,           GL_ONE_MINUS_SRC_ALPHA },
100    { SkXfermode::kXor_Mode,      GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
101    { SkXfermode::kPlus_Mode,     GL_ONE,                 GL_ONE },
102    { SkXfermode::kMultiply_Mode, GL_DST_COLOR,           GL_ZERO },
103    { SkXfermode::kScreen_Mode,   GL_ONE_MINUS_DST_COLOR, GL_ONE }
104};
105
106///////////////////////////////////////////////////////////////////////////////
107// Constructors/destructor
108///////////////////////////////////////////////////////////////////////////////
109
110OpenGLRenderer::OpenGLRenderer(): mCaches(Caches::getInstance()) {
111    mShader = NULL;
112    mColorFilter = NULL;
113    mHasShadow = false;
114    mHasDrawFilter = false;
115
116    memcpy(mMeshVertices, gMeshVertices, sizeof(gMeshVertices));
117
118    mFirstSnapshot = new Snapshot;
119}
120
121OpenGLRenderer::~OpenGLRenderer() {
122    // The context has already been destroyed at this point, do not call
123    // GL APIs. All GL state should be kept in Caches.h
124}
125
126///////////////////////////////////////////////////////////////////////////////
127// Debug
128///////////////////////////////////////////////////////////////////////////////
129
130void OpenGLRenderer::startMark(const char* name) const {
131    mCaches.startMark(0, name);
132}
133
134void OpenGLRenderer::endMark() const {
135    mCaches.endMark();
136}
137
138///////////////////////////////////////////////////////////////////////////////
139// Setup
140///////////////////////////////////////////////////////////////////////////////
141
142bool OpenGLRenderer::isDeferred() {
143    return false;
144}
145
146void OpenGLRenderer::setViewport(int width, int height) {
147    initViewport(width, height);
148
149    glDisable(GL_DITHER);
150    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
151
152    glEnableVertexAttribArray(Program::kBindingPosition);
153}
154
155void OpenGLRenderer::initViewport(int width, int height) {
156    mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1);
157
158    mWidth = width;
159    mHeight = height;
160
161    mFirstSnapshot->height = height;
162    mFirstSnapshot->viewport.set(0, 0, width, height);
163}
164
165int OpenGLRenderer::prepare(bool opaque) {
166    return prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque);
167}
168
169int OpenGLRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {
170    mCaches.clearGarbage();
171
172    mSnapshot = new Snapshot(mFirstSnapshot,
173            SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
174    mSnapshot->fbo = getTargetFbo();
175    mSaveCount = 1;
176
177    mSnapshot->setClip(left, top, right, bottom);
178    mDirtyClip = opaque;
179
180    // If we know that we are going to redraw the entire framebuffer,
181    // perform a discard to let the driver know we don't need to preserve
182    // the back buffer for this frame.
183    if (mCaches.extensions.hasDiscardFramebuffer() &&
184            left <= 0.0f && top <= 0.0f && right >= mWidth && bottom >= mHeight) {
185        const GLenum attachments[] = { getTargetFbo() == 0 ? GL_COLOR_EXT : GL_COLOR_ATTACHMENT0 };
186        glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, attachments);
187    }
188
189    syncState();
190
191    if (!opaque) {
192        mCaches.enableScissor();
193        mCaches.setScissor(left, mSnapshot->height - bottom, right - left, bottom - top);
194        glClear(GL_COLOR_BUFFER_BIT);
195        return DrawGlInfo::kStatusDrew;
196    } else {
197        mCaches.resetScissor();
198    }
199
200    return DrawGlInfo::kStatusDone;
201}
202
203void OpenGLRenderer::syncState() {
204    glViewport(0, 0, mWidth, mHeight);
205
206    if (mCaches.blend) {
207        glEnable(GL_BLEND);
208    } else {
209        glDisable(GL_BLEND);
210    }
211}
212
213void OpenGLRenderer::finish() {
214#if DEBUG_OPENGL
215    GLenum status = GL_NO_ERROR;
216    while ((status = glGetError()) != GL_NO_ERROR) {
217        ALOGD("GL error from OpenGLRenderer: 0x%x", status);
218        switch (status) {
219            case GL_INVALID_ENUM:
220                ALOGE("  GL_INVALID_ENUM");
221                break;
222            case GL_INVALID_VALUE:
223                ALOGE("  GL_INVALID_VALUE");
224                break;
225            case GL_INVALID_OPERATION:
226                ALOGE("  GL_INVALID_OPERATION");
227                break;
228            case GL_OUT_OF_MEMORY:
229                ALOGE("  Out of memory!");
230                break;
231        }
232    }
233#endif
234#if DEBUG_MEMORY_USAGE
235    mCaches.dumpMemoryUsage();
236#else
237    if (mCaches.getDebugLevel() & kDebugMemory) {
238        mCaches.dumpMemoryUsage();
239    }
240#endif
241}
242
243void OpenGLRenderer::interrupt() {
244    if (mCaches.currentProgram) {
245        if (mCaches.currentProgram->isInUse()) {
246            mCaches.currentProgram->remove();
247            mCaches.currentProgram = NULL;
248        }
249    }
250    mCaches.unbindMeshBuffer();
251    mCaches.unbindIndicesBuffer();
252    mCaches.resetVertexPointers();
253    mCaches.disbaleTexCoordsVertexArray();
254}
255
256void OpenGLRenderer::resume() {
257    sp<Snapshot> snapshot = (mSnapshot != NULL) ? mSnapshot : mFirstSnapshot;
258    glViewport(0, 0, snapshot->viewport.getWidth(), snapshot->viewport.getHeight());
259    glBindFramebuffer(GL_FRAMEBUFFER, snapshot->fbo);
260
261    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
262
263    mCaches.scissorEnabled = glIsEnabled(GL_SCISSOR_TEST);
264    mCaches.enableScissor();
265    mCaches.resetScissor();
266    dirtyClip();
267
268    mCaches.activeTexture(0);
269
270    mCaches.blend = true;
271    glEnable(GL_BLEND);
272    glBlendFunc(mCaches.lastSrcMode, mCaches.lastDstMode);
273    glBlendEquation(GL_FUNC_ADD);
274}
275
276void OpenGLRenderer::resumeAfterLayer() {
277    sp<Snapshot> snapshot = (mSnapshot != NULL) ? mSnapshot : mFirstSnapshot;
278    glViewport(0, 0, snapshot->viewport.getWidth(), snapshot->viewport.getHeight());
279    glBindFramebuffer(GL_FRAMEBUFFER, snapshot->fbo);
280
281    mCaches.resetScissor();
282    dirtyClip();
283}
284
285void OpenGLRenderer::detachFunctor(Functor* functor) {
286    mFunctors.remove(functor);
287}
288
289void OpenGLRenderer::attachFunctor(Functor* functor) {
290    mFunctors.add(functor);
291}
292
293status_t OpenGLRenderer::invokeFunctors(Rect& dirty) {
294    status_t result = DrawGlInfo::kStatusDone;
295    size_t count = mFunctors.size();
296
297    if (count > 0) {
298        SortedVector<Functor*> functors(mFunctors);
299        mFunctors.clear();
300
301        DrawGlInfo info;
302        info.clipLeft = 0;
303        info.clipTop = 0;
304        info.clipRight = 0;
305        info.clipBottom = 0;
306        info.isLayer = false;
307        info.width = 0;
308        info.height = 0;
309        memset(info.transform, 0, sizeof(float) * 16);
310
311        for (size_t i = 0; i < count; i++) {
312            Functor* f = functors.itemAt(i);
313            result |= (*f)(DrawGlInfo::kModeProcess, &info);
314
315            if (result & DrawGlInfo::kStatusDraw) {
316                Rect localDirty(info.dirtyLeft, info.dirtyTop, info.dirtyRight, info.dirtyBottom);
317                dirty.unionWith(localDirty);
318            }
319
320            if (result & DrawGlInfo::kStatusInvoke) {
321                mFunctors.add(f);
322            }
323        }
324        // protect against functors binding to other buffers
325        mCaches.unbindMeshBuffer();
326        mCaches.unbindIndicesBuffer();
327        mCaches.activeTexture(0);
328    }
329
330    return result;
331}
332
333status_t OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& dirty) {
334    interrupt();
335    detachFunctor(functor);
336
337    mCaches.enableScissor();
338    if (mDirtyClip) {
339        setScissorFromClip();
340    }
341
342    Rect clip(*mSnapshot->clipRect);
343    clip.snapToPixelBoundaries();
344
345    // Since we don't know what the functor will draw, let's dirty
346    // tne entire clip region
347    if (hasLayer()) {
348        dirtyLayerUnchecked(clip, getRegion());
349    }
350
351    DrawGlInfo info;
352    info.clipLeft = clip.left;
353    info.clipTop = clip.top;
354    info.clipRight = clip.right;
355    info.clipBottom = clip.bottom;
356    info.isLayer = hasLayer();
357    info.width = getSnapshot()->viewport.getWidth();
358    info.height = getSnapshot()->height;
359    getSnapshot()->transform->copyTo(&info.transform[0]);
360
361    status_t result = (*functor)(DrawGlInfo::kModeDraw, &info) | DrawGlInfo::kStatusDrew;
362
363    if (result != DrawGlInfo::kStatusDone) {
364        Rect localDirty(info.dirtyLeft, info.dirtyTop, info.dirtyRight, info.dirtyBottom);
365        dirty.unionWith(localDirty);
366
367        if (result & DrawGlInfo::kStatusInvoke) {
368            mFunctors.add(functor);
369        }
370    }
371
372    resume();
373    return result;
374}
375
376///////////////////////////////////////////////////////////////////////////////
377// State management
378///////////////////////////////////////////////////////////////////////////////
379
380int OpenGLRenderer::getSaveCount() const {
381    return mSaveCount;
382}
383
384int OpenGLRenderer::save(int flags) {
385    return saveSnapshot(flags);
386}
387
388void OpenGLRenderer::restore() {
389    if (mSaveCount > 1) {
390        restoreSnapshot();
391    }
392}
393
394void OpenGLRenderer::restoreToCount(int saveCount) {
395    if (saveCount < 1) saveCount = 1;
396
397    while (mSaveCount > saveCount) {
398        restoreSnapshot();
399    }
400}
401
402int OpenGLRenderer::saveSnapshot(int flags) {
403    mSnapshot = new Snapshot(mSnapshot, flags);
404    return mSaveCount++;
405}
406
407bool OpenGLRenderer::restoreSnapshot() {
408    bool restoreClip = mSnapshot->flags & Snapshot::kFlagClipSet;
409    bool restoreLayer = mSnapshot->flags & Snapshot::kFlagIsLayer;
410    bool restoreOrtho = mSnapshot->flags & Snapshot::kFlagDirtyOrtho;
411
412    sp<Snapshot> current = mSnapshot;
413    sp<Snapshot> previous = mSnapshot->previous;
414
415    if (restoreOrtho) {
416        Rect& r = previous->viewport;
417        glViewport(r.left, r.top, r.right, r.bottom);
418        mOrthoMatrix.load(current->orthoMatrix);
419    }
420
421    mSaveCount--;
422    mSnapshot = previous;
423
424    if (restoreClip) {
425        dirtyClip();
426    }
427
428    if (restoreLayer) {
429        composeLayer(current, previous);
430    }
431
432    return restoreClip;
433}
434
435///////////////////////////////////////////////////////////////////////////////
436// Layers
437///////////////////////////////////////////////////////////////////////////////
438
439int OpenGLRenderer::saveLayer(float left, float top, float right, float bottom,
440        SkPaint* p, int flags) {
441    const GLuint previousFbo = mSnapshot->fbo;
442    const int count = saveSnapshot(flags);
443
444    if (!mSnapshot->isIgnored()) {
445        int alpha = 255;
446        SkXfermode::Mode mode;
447
448        if (p) {
449            alpha = p->getAlpha();
450            if (!mCaches.extensions.hasFramebufferFetch()) {
451                const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode);
452                if (!isMode) {
453                    // Assume SRC_OVER
454                    mode = SkXfermode::kSrcOver_Mode;
455                }
456            } else {
457                mode = getXfermode(p->getXfermode());
458            }
459        } else {
460            mode = SkXfermode::kSrcOver_Mode;
461        }
462
463        createLayer(left, top, right, bottom, alpha, mode, flags, previousFbo);
464    }
465
466    return count;
467}
468
469int OpenGLRenderer::saveLayerAlpha(float left, float top, float right, float bottom,
470        int alpha, int flags) {
471    if (alpha >= 255) {
472        return saveLayer(left, top, right, bottom, NULL, flags);
473    } else {
474        SkPaint paint;
475        paint.setAlpha(alpha);
476        return saveLayer(left, top, right, bottom, &paint, flags);
477    }
478}
479
480/**
481 * Layers are viewed by Skia are slightly different than layers in image editing
482 * programs (for instance.) When a layer is created, previously created layers
483 * and the frame buffer still receive every drawing command. For instance, if a
484 * layer is created and a shape intersecting the bounds of the layers and the
485 * framebuffer is draw, the shape will be drawn on both (unless the layer was
486 * created with the SkCanvas::kClipToLayer_SaveFlag flag.)
487 *
488 * A way to implement layers is to create an FBO for each layer, backed by an RGBA
489 * texture. Unfortunately, this is inefficient as it requires every primitive to
490 * be drawn n + 1 times, where n is the number of active layers. In practice this
491 * means, for every primitive:
492 *   - Switch active frame buffer
493 *   - Change viewport, clip and projection matrix
494 *   - Issue the drawing
495 *
496 * Switching rendering target n + 1 times per drawn primitive is extremely costly.
497 * To avoid this, layers are implemented in a different way here, at least in the
498 * general case. FBOs are used, as an optimization, when the "clip to layer" flag
499 * is set. When this flag is set we can redirect all drawing operations into a
500 * single FBO.
501 *
502 * This implementation relies on the frame buffer being at least RGBA 8888. When
503 * a layer is created, only a texture is created, not an FBO. The content of the
504 * frame buffer contained within the layer's bounds is copied into this texture
505 * using glCopyTexImage2D(). The layer's region is then cleared(1) in the frame
506 * buffer and drawing continues as normal. This technique therefore treats the
507 * frame buffer as a scratch buffer for the layers.
508 *
509 * To compose the layers back onto the frame buffer, each layer texture
510 * (containing the original frame buffer data) is drawn as a simple quad over
511 * the frame buffer. The trick is that the quad is set as the composition
512 * destination in the blending equation, and the frame buffer becomes the source
513 * of the composition.
514 *
515 * Drawing layers with an alpha value requires an extra step before composition.
516 * An empty quad is drawn over the layer's region in the frame buffer. This quad
517 * is drawn with the rgba color (0,0,0,alpha). The alpha value offered by the
518 * quad is used to multiply the colors in the frame buffer. This is achieved by
519 * changing the GL blend functions for the GL_FUNC_ADD blend equation to
520 * GL_ZERO, GL_SRC_ALPHA.
521 *
522 * Because glCopyTexImage2D() can be slow, an alternative implementation might
523 * be use to draw a single clipped layer. The implementation described above
524 * is correct in every case.
525 *
526 * (1) The frame buffer is actually not cleared right away. To allow the GPU
527 *     to potentially optimize series of calls to glCopyTexImage2D, the frame
528 *     buffer is left untouched until the first drawing operation. Only when
529 *     something actually gets drawn are the layers regions cleared.
530 */
531bool OpenGLRenderer::createLayer(float left, float top, float right, float bottom,
532        int alpha, SkXfermode::Mode mode, int flags, GLuint previousFbo) {
533    LAYER_LOGD("Requesting layer %.2fx%.2f", right - left, bottom - top);
534    LAYER_LOGD("Layer cache size = %d", mCaches.layerCache.getSize());
535
536    const bool fboLayer = flags & SkCanvas::kClipToLayer_SaveFlag;
537
538    // Window coordinates of the layer
539    Rect clip;
540    Rect bounds(left, top, right, bottom);
541    Rect untransformedBounds(bounds);
542    mSnapshot->transform->mapRect(bounds);
543
544    // Layers only make sense if they are in the framebuffer's bounds
545    if (bounds.intersect(*mSnapshot->clipRect)) {
546        // We cannot work with sub-pixels in this case
547        bounds.snapToPixelBoundaries();
548
549        // When the layer is not an FBO, we may use glCopyTexImage so we
550        // need to make sure the layer does not extend outside the bounds
551        // of the framebuffer
552        if (!bounds.intersect(mSnapshot->previous->viewport)) {
553            bounds.setEmpty();
554        } else if (fboLayer) {
555            clip.set(bounds);
556            mat4 inverse;
557            inverse.loadInverse(*mSnapshot->transform);
558            inverse.mapRect(clip);
559            clip.snapToPixelBoundaries();
560            if (clip.intersect(untransformedBounds)) {
561                clip.translate(-left, -top);
562                bounds.set(untransformedBounds);
563            } else {
564                clip.setEmpty();
565            }
566        }
567    } else {
568        bounds.setEmpty();
569    }
570
571    if (bounds.isEmpty() || bounds.getWidth() > mCaches.maxTextureSize ||
572            bounds.getHeight() > mCaches.maxTextureSize ||
573            (fboLayer && clip.isEmpty())) {
574        mSnapshot->empty = fboLayer;
575    } else {
576        mSnapshot->invisible = mSnapshot->invisible || (alpha <= ALPHA_THRESHOLD && fboLayer);
577    }
578
579    // Bail out if we won't draw in this snapshot
580    if (mSnapshot->invisible || mSnapshot->empty) {
581        return false;
582    }
583
584    mCaches.activeTexture(0);
585    Layer* layer = mCaches.layerCache.get(bounds.getWidth(), bounds.getHeight());
586    if (!layer) {
587        return false;
588    }
589
590    layer->setAlpha(alpha, mode);
591    layer->layer.set(bounds);
592    layer->texCoords.set(0.0f, bounds.getHeight() / float(layer->getHeight()),
593            bounds.getWidth() / float(layer->getWidth()), 0.0f);
594    layer->setColorFilter(mColorFilter);
595    layer->setBlend(true);
596
597    // Save the layer in the snapshot
598    mSnapshot->flags |= Snapshot::kFlagIsLayer;
599    mSnapshot->layer = layer;
600
601    if (fboLayer) {
602        return createFboLayer(layer, bounds, clip, previousFbo);
603    } else {
604        // Copy the framebuffer into the layer
605        layer->bindTexture();
606        if (!bounds.isEmpty()) {
607            if (layer->isEmpty()) {
608                glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
609                        bounds.left, mSnapshot->height - bounds.bottom,
610                        layer->getWidth(), layer->getHeight(), 0);
611                layer->setEmpty(false);
612            } else {
613                glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bounds.left,
614                        mSnapshot->height - bounds.bottom, bounds.getWidth(), bounds.getHeight());
615            }
616
617            // Enqueue the buffer coordinates to clear the corresponding region later
618            mLayers.push(new Rect(bounds));
619        }
620    }
621
622    return true;
623}
624
625bool OpenGLRenderer::createFboLayer(Layer* layer, Rect& bounds, Rect& clip, GLuint previousFbo) {
626    layer->setFbo(mCaches.fboCache.get());
627
628    mSnapshot->region = &mSnapshot->layer->region;
629    mSnapshot->flags |= Snapshot::kFlagFboTarget;
630
631    mSnapshot->flags |= Snapshot::kFlagIsFboLayer;
632    mSnapshot->fbo = layer->getFbo();
633    mSnapshot->resetTransform(-bounds.left, -bounds.top, 0.0f);
634    mSnapshot->resetClip(clip.left, clip.top, clip.right, clip.bottom);
635    mSnapshot->viewport.set(0.0f, 0.0f, bounds.getWidth(), bounds.getHeight());
636    mSnapshot->height = bounds.getHeight();
637    mSnapshot->flags |= Snapshot::kFlagDirtyOrtho;
638    mSnapshot->orthoMatrix.load(mOrthoMatrix);
639
640    // Bind texture to FBO
641    glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo());
642    layer->bindTexture();
643
644    // Initialize the texture if needed
645    if (layer->isEmpty()) {
646        layer->allocateTexture(GL_RGBA, GL_UNSIGNED_BYTE);
647        layer->setEmpty(false);
648    }
649
650    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
651            layer->getTexture(), 0);
652
653#if DEBUG_LAYERS_AS_REGIONS
654    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
655    if (status != GL_FRAMEBUFFER_COMPLETE) {
656        ALOGE("Framebuffer incomplete (GL error code 0x%x)", status);
657
658        glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
659
660        Caches::getInstance().resourceCache.decrementRefcount(layer);
661
662        return false;
663    }
664#endif
665
666    // Clear the FBO, expand the clear region by 1 to get nice bilinear filtering
667    mCaches.enableScissor();
668    mCaches.setScissor(clip.left - 1.0f, bounds.getHeight() - clip.bottom - 1.0f,
669            clip.getWidth() + 2.0f, clip.getHeight() + 2.0f);
670    glClear(GL_COLOR_BUFFER_BIT);
671
672    dirtyClip();
673
674    // Change the ortho projection
675    glViewport(0, 0, bounds.getWidth(), bounds.getHeight());
676    mOrthoMatrix.loadOrtho(0.0f, bounds.getWidth(), bounds.getHeight(), 0.0f, -1.0f, 1.0f);
677
678    return true;
679}
680
681/**
682 * Read the documentation of createLayer() before doing anything in this method.
683 */
684void OpenGLRenderer::composeLayer(sp<Snapshot> current, sp<Snapshot> previous) {
685    if (!current->layer) {
686        ALOGE("Attempting to compose a layer that does not exist");
687        return;
688    }
689
690    const bool fboLayer = current->flags & Snapshot::kFlagIsFboLayer;
691
692    if (fboLayer) {
693        // Detach the texture from the FBO
694        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
695
696        // Unbind current FBO and restore previous one
697        glBindFramebuffer(GL_FRAMEBUFFER, previous->fbo);
698    }
699
700    Layer* layer = current->layer;
701    const Rect& rect = layer->layer;
702
703    if (!fboLayer && layer->getAlpha() < 255) {
704        drawColorRect(rect.left, rect.top, rect.right, rect.bottom,
705                layer->getAlpha() << 24, SkXfermode::kDstIn_Mode, true);
706        // Required below, composeLayerRect() will divide by 255
707        layer->setAlpha(255);
708    }
709
710    mCaches.unbindMeshBuffer();
711
712    mCaches.activeTexture(0);
713
714    // When the layer is stored in an FBO, we can save a bit of fillrate by
715    // drawing only the dirty region
716    if (fboLayer) {
717        dirtyLayer(rect.left, rect.top, rect.right, rect.bottom, *previous->transform);
718        if (layer->getColorFilter()) {
719            setupColorFilter(layer->getColorFilter());
720        }
721        composeLayerRegion(layer, rect);
722        if (layer->getColorFilter()) {
723            resetColorFilter();
724        }
725    } else if (!rect.isEmpty()) {
726        dirtyLayer(rect.left, rect.top, rect.right, rect.bottom);
727        composeLayerRect(layer, rect, true);
728    }
729
730    if (fboLayer) {
731        // Note: No need to use glDiscardFramebufferEXT() since we never
732        //       create/compose layers that are not on screen with this
733        //       code path
734        // See LayerRenderer::destroyLayer(Layer*)
735
736        // Put the FBO name back in the cache, if it doesn't fit, it will be destroyed
737        mCaches.fboCache.put(current->fbo);
738        layer->setFbo(0);
739    }
740
741    dirtyClip();
742
743    // Failing to add the layer to the cache should happen only if the layer is too large
744    if (!mCaches.layerCache.put(layer)) {
745        LAYER_LOGD("Deleting layer");
746        Caches::getInstance().resourceCache.decrementRefcount(layer);
747    }
748}
749
750void OpenGLRenderer::drawTextureLayer(Layer* layer, const Rect& rect) {
751    float alpha = layer->getAlpha() / 255.0f;
752
753    mat4& transform = layer->getTransform();
754    if (!transform.isIdentity()) {
755        save(0);
756        mSnapshot->transform->multiply(transform);
757    }
758
759    setupDraw();
760    if (layer->getRenderTarget() == GL_TEXTURE_2D) {
761        setupDrawWithTexture();
762    } else {
763        setupDrawWithExternalTexture();
764    }
765    setupDrawTextureTransform();
766    setupDrawColor(alpha, alpha, alpha, alpha);
767    setupDrawColorFilter();
768    setupDrawBlending(layer->isBlend() || alpha < 1.0f, layer->getMode());
769    setupDrawProgram();
770    setupDrawPureColorUniforms();
771    setupDrawColorFilterUniforms();
772    if (layer->getRenderTarget() == GL_TEXTURE_2D) {
773        setupDrawTexture(layer->getTexture());
774    } else {
775        setupDrawExternalTexture(layer->getTexture());
776    }
777    if (mSnapshot->transform->isPureTranslate() &&
778            layer->getWidth() == (uint32_t) rect.getWidth() &&
779            layer->getHeight() == (uint32_t) rect.getHeight()) {
780        const float x = (int) floorf(rect.left + mSnapshot->transform->getTranslateX() + 0.5f);
781        const float y = (int) floorf(rect.top + mSnapshot->transform->getTranslateY() + 0.5f);
782
783        layer->setFilter(GL_NEAREST);
784        setupDrawModelView(x, y, x + rect.getWidth(), y + rect.getHeight(), true);
785    } else {
786        layer->setFilter(GL_LINEAR);
787        setupDrawModelView(rect.left, rect.top, rect.right, rect.bottom);
788    }
789    setupDrawTextureTransformUniforms(layer->getTexTransform());
790    setupDrawMesh(&mMeshVertices[0].position[0], &mMeshVertices[0].texture[0]);
791
792    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
793
794    finishDrawTexture();
795
796    if (!transform.isIdentity()) {
797        restore();
798    }
799}
800
801void OpenGLRenderer::composeLayerRect(Layer* layer, const Rect& rect, bool swap) {
802    if (!layer->isTextureLayer()) {
803        const Rect& texCoords = layer->texCoords;
804        resetDrawTextureTexCoords(texCoords.left, texCoords.top,
805                texCoords.right, texCoords.bottom);
806
807        float x = rect.left;
808        float y = rect.top;
809        bool simpleTransform = mSnapshot->transform->isPureTranslate() &&
810                layer->getWidth() == (uint32_t) rect.getWidth() &&
811                layer->getHeight() == (uint32_t) rect.getHeight();
812
813        if (simpleTransform) {
814            // When we're swapping, the layer is already in screen coordinates
815            if (!swap) {
816                x = (int) floorf(rect.left + mSnapshot->transform->getTranslateX() + 0.5f);
817                y = (int) floorf(rect.top + mSnapshot->transform->getTranslateY() + 0.5f);
818            }
819
820            layer->setFilter(GL_NEAREST, true);
821        } else {
822            layer->setFilter(GL_LINEAR, true);
823        }
824
825        drawTextureMesh(x, y, x + rect.getWidth(), y + rect.getHeight(),
826                layer->getTexture(), layer->getAlpha() / 255.0f,
827                layer->getMode(), layer->isBlend(),
828                &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0],
829                GL_TRIANGLE_STRIP, gMeshCount, swap, swap || simpleTransform);
830
831        resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
832    } else {
833        resetDrawTextureTexCoords(0.0f, 1.0f, 1.0f, 0.0f);
834        drawTextureLayer(layer, rect);
835        resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
836    }
837}
838
839void OpenGLRenderer::composeLayerRegion(Layer* layer, const Rect& rect) {
840    if (layer->region.isRect()) {
841        layer->setRegionAsRect();
842
843        composeLayerRect(layer, layer->regionRect);
844
845        layer->region.clear();
846        return;
847    }
848
849    // TODO: See LayerRenderer.cpp::generateMesh() for important
850    //       information about this implementation
851    if (CC_LIKELY(!layer->region.isEmpty())) {
852        size_t count;
853        const android::Rect* rects = layer->region.getArray(&count);
854
855        const float alpha = layer->getAlpha() / 255.0f;
856        const float texX = 1.0f / float(layer->getWidth());
857        const float texY = 1.0f / float(layer->getHeight());
858        const float height = rect.getHeight();
859
860        TextureVertex* mesh = mCaches.getRegionMesh();
861        GLsizei numQuads = 0;
862
863        setupDraw();
864        setupDrawWithTexture();
865        setupDrawColor(alpha, alpha, alpha, alpha);
866        setupDrawColorFilter();
867        setupDrawBlending(layer->isBlend() || alpha < 1.0f, layer->getMode(), false);
868        setupDrawProgram();
869        setupDrawDirtyRegionsDisabled();
870        setupDrawPureColorUniforms();
871        setupDrawColorFilterUniforms();
872        setupDrawTexture(layer->getTexture());
873        if (mSnapshot->transform->isPureTranslate()) {
874            const float x = (int) floorf(rect.left + mSnapshot->transform->getTranslateX() + 0.5f);
875            const float y = (int) floorf(rect.top + mSnapshot->transform->getTranslateY() + 0.5f);
876
877            layer->setFilter(GL_NEAREST);
878            setupDrawModelViewTranslate(x, y, x + rect.getWidth(), y + rect.getHeight(), true);
879        } else {
880            layer->setFilter(GL_LINEAR);
881            setupDrawModelViewTranslate(rect.left, rect.top, rect.right, rect.bottom);
882        }
883        setupDrawMeshIndices(&mesh[0].position[0], &mesh[0].texture[0]);
884
885        for (size_t i = 0; i < count; i++) {
886            const android::Rect* r = &rects[i];
887
888            const float u1 = r->left * texX;
889            const float v1 = (height - r->top) * texY;
890            const float u2 = r->right * texX;
891            const float v2 = (height - r->bottom) * texY;
892
893            // TODO: Reject quads outside of the clip
894            TextureVertex::set(mesh++, r->left, r->top, u1, v1);
895            TextureVertex::set(mesh++, r->right, r->top, u2, v1);
896            TextureVertex::set(mesh++, r->left, r->bottom, u1, v2);
897            TextureVertex::set(mesh++, r->right, r->bottom, u2, v2);
898
899            numQuads++;
900
901            if (numQuads >= REGION_MESH_QUAD_COUNT) {
902                glDrawElements(GL_TRIANGLES, numQuads * 6, GL_UNSIGNED_SHORT, NULL);
903                numQuads = 0;
904                mesh = mCaches.getRegionMesh();
905            }
906        }
907
908        if (numQuads > 0) {
909            glDrawElements(GL_TRIANGLES, numQuads * 6, GL_UNSIGNED_SHORT, NULL);
910        }
911
912        finishDrawTexture();
913
914#if DEBUG_LAYERS_AS_REGIONS
915        drawRegionRects(layer->region);
916#endif
917
918        layer->region.clear();
919    }
920}
921
922void OpenGLRenderer::drawRegionRects(const Region& region) {
923#if DEBUG_LAYERS_AS_REGIONS
924    size_t count;
925    const android::Rect* rects = region.getArray(&count);
926
927    uint32_t colors[] = {
928            0x7fff0000, 0x7f00ff00,
929            0x7f0000ff, 0x7fff00ff,
930    };
931
932    int offset = 0;
933    int32_t top = rects[0].top;
934
935    for (size_t i = 0; i < count; i++) {
936        if (top != rects[i].top) {
937            offset ^= 0x2;
938            top = rects[i].top;
939        }
940
941        Rect r(rects[i].left, rects[i].top, rects[i].right, rects[i].bottom);
942        drawColorRect(r.left, r.top, r.right, r.bottom, colors[offset + (i & 0x1)],
943                SkXfermode::kSrcOver_Mode);
944    }
945#endif
946}
947
948void OpenGLRenderer::dirtyLayer(const float left, const float top,
949        const float right, const float bottom, const mat4 transform) {
950    if (hasLayer()) {
951        Rect bounds(left, top, right, bottom);
952        transform.mapRect(bounds);
953        dirtyLayerUnchecked(bounds, getRegion());
954    }
955}
956
957void OpenGLRenderer::dirtyLayer(const float left, const float top,
958        const float right, const float bottom) {
959    if (hasLayer()) {
960        Rect bounds(left, top, right, bottom);
961        dirtyLayerUnchecked(bounds, getRegion());
962    }
963}
964
965void OpenGLRenderer::dirtyLayerUnchecked(Rect& bounds, Region* region) {
966    if (bounds.intersect(*mSnapshot->clipRect)) {
967        bounds.snapToPixelBoundaries();
968        android::Rect dirty(bounds.left, bounds.top, bounds.right, bounds.bottom);
969        if (!dirty.isEmpty()) {
970            region->orSelf(dirty);
971        }
972    }
973}
974
975void OpenGLRenderer::clearLayerRegions() {
976    const size_t count = mLayers.size();
977    if (count == 0) return;
978
979    if (!mSnapshot->isIgnored()) {
980        // Doing several glScissor/glClear here can negatively impact
981        // GPUs with a tiler architecture, instead we draw quads with
982        // the Clear blending mode
983
984        // The list contains bounds that have already been clipped
985        // against their initial clip rect, and the current clip
986        // is likely different so we need to disable clipping here
987        bool scissorChanged = mCaches.disableScissor();
988
989        Vertex mesh[count * 6];
990        Vertex* vertex = mesh;
991
992        for (uint32_t i = 0; i < count; i++) {
993            Rect* bounds = mLayers.itemAt(i);
994
995            Vertex::set(vertex++, bounds->left, bounds->bottom);
996            Vertex::set(vertex++, bounds->left, bounds->top);
997            Vertex::set(vertex++, bounds->right, bounds->top);
998            Vertex::set(vertex++, bounds->left, bounds->bottom);
999            Vertex::set(vertex++, bounds->right, bounds->top);
1000            Vertex::set(vertex++, bounds->right, bounds->bottom);
1001
1002            delete bounds;
1003        }
1004
1005        setupDraw(false);
1006        setupDrawColor(0.0f, 0.0f, 0.0f, 1.0f);
1007        setupDrawBlending(true, SkXfermode::kClear_Mode);
1008        setupDrawProgram();
1009        setupDrawPureColorUniforms();
1010        setupDrawModelViewTranslate(0.0f, 0.0f, 0.0f, 0.0f, true);
1011        setupDrawVertices(&mesh[0].position[0]);
1012
1013        glDrawArrays(GL_TRIANGLES, 0, count * 6);
1014
1015        if (scissorChanged) mCaches.enableScissor();
1016    } else {
1017        for (uint32_t i = 0; i < count; i++) {
1018            delete mLayers.itemAt(i);
1019        }
1020    }
1021
1022    mLayers.clear();
1023}
1024
1025///////////////////////////////////////////////////////////////////////////////
1026// Transforms
1027///////////////////////////////////////////////////////////////////////////////
1028
1029void OpenGLRenderer::translate(float dx, float dy) {
1030    mSnapshot->transform->translate(dx, dy, 0.0f);
1031}
1032
1033void OpenGLRenderer::rotate(float degrees) {
1034    mSnapshot->transform->rotate(degrees, 0.0f, 0.0f, 1.0f);
1035}
1036
1037void OpenGLRenderer::scale(float sx, float sy) {
1038    mSnapshot->transform->scale(sx, sy, 1.0f);
1039}
1040
1041void OpenGLRenderer::skew(float sx, float sy) {
1042    mSnapshot->transform->skew(sx, sy);
1043}
1044
1045void OpenGLRenderer::setMatrix(SkMatrix* matrix) {
1046    if (matrix) {
1047        mSnapshot->transform->load(*matrix);
1048    } else {
1049        mSnapshot->transform->loadIdentity();
1050    }
1051}
1052
1053void OpenGLRenderer::getMatrix(SkMatrix* matrix) {
1054    mSnapshot->transform->copyTo(*matrix);
1055}
1056
1057void OpenGLRenderer::concatMatrix(SkMatrix* matrix) {
1058    SkMatrix transform;
1059    mSnapshot->transform->copyTo(transform);
1060    transform.preConcat(*matrix);
1061    mSnapshot->transform->load(transform);
1062}
1063
1064///////////////////////////////////////////////////////////////////////////////
1065// Clipping
1066///////////////////////////////////////////////////////////////////////////////
1067
1068void OpenGLRenderer::setScissorFromClip() {
1069    Rect clip(*mSnapshot->clipRect);
1070    clip.snapToPixelBoundaries();
1071
1072    if (mCaches.setScissor(clip.left, mSnapshot->height - clip.bottom,
1073            clip.getWidth(), clip.getHeight())) {
1074        mDirtyClip = false;
1075    }
1076}
1077
1078const Rect& OpenGLRenderer::getClipBounds() {
1079    return mSnapshot->getLocalClip();
1080}
1081
1082bool OpenGLRenderer::quickRejectNoScissor(float left, float top, float right, float bottom) {
1083    if (mSnapshot->isIgnored()) {
1084        return true;
1085    }
1086
1087    Rect r(left, top, right, bottom);
1088    mSnapshot->transform->mapRect(r);
1089    r.snapToPixelBoundaries();
1090
1091    Rect clipRect(*mSnapshot->clipRect);
1092    clipRect.snapToPixelBoundaries();
1093
1094    return !clipRect.intersects(r);
1095}
1096
1097bool OpenGLRenderer::quickRejectNoScissor(float left, float top, float right, float bottom,
1098        Rect& transformed, Rect& clip) {
1099    if (mSnapshot->isIgnored()) {
1100        return true;
1101    }
1102
1103    transformed.set(left, top, right, bottom);
1104    mSnapshot->transform->mapRect(transformed);
1105    transformed.snapToPixelBoundaries();
1106
1107    clip.set(*mSnapshot->clipRect);
1108    clip.snapToPixelBoundaries();
1109
1110    return !clip.intersects(transformed);
1111}
1112
1113bool OpenGLRenderer::quickReject(float left, float top, float right, float bottom) {
1114    if (mSnapshot->isIgnored()) {
1115        return true;
1116    }
1117
1118    Rect r(left, top, right, bottom);
1119    mSnapshot->transform->mapRect(r);
1120    r.snapToPixelBoundaries();
1121
1122    Rect clipRect(*mSnapshot->clipRect);
1123    clipRect.snapToPixelBoundaries();
1124
1125    bool rejected = !clipRect.intersects(r);
1126    if (!isDeferred() && !rejected) {
1127        mCaches.setScissorEnabled(!clipRect.contains(r));
1128    }
1129
1130    return rejected;
1131}
1132
1133bool OpenGLRenderer::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {
1134    bool clipped = mSnapshot->clip(left, top, right, bottom, op);
1135    if (clipped) {
1136        dirtyClip();
1137    }
1138    return !mSnapshot->clipRect->isEmpty();
1139}
1140
1141Rect* OpenGLRenderer::getClipRect() {
1142    return mSnapshot->clipRect;
1143}
1144
1145///////////////////////////////////////////////////////////////////////////////
1146// Drawing commands
1147///////////////////////////////////////////////////////////////////////////////
1148
1149void OpenGLRenderer::setupDraw(bool clear) {
1150    // TODO: It would be best if we could do this before quickReject()
1151    //       changes the scissor test state
1152    if (clear) clearLayerRegions();
1153    if (mDirtyClip) {
1154        setScissorFromClip();
1155    }
1156    mDescription.reset();
1157    mSetShaderColor = false;
1158    mColorSet = false;
1159    mColorA = mColorR = mColorG = mColorB = 0.0f;
1160    mTextureUnit = 0;
1161    mTrackDirtyRegions = true;
1162}
1163
1164void OpenGLRenderer::setupDrawWithTexture(bool isAlpha8) {
1165    mDescription.hasTexture = true;
1166    mDescription.hasAlpha8Texture = isAlpha8;
1167}
1168
1169void OpenGLRenderer::setupDrawWithExternalTexture() {
1170    mDescription.hasExternalTexture = true;
1171}
1172
1173void OpenGLRenderer::setupDrawNoTexture() {
1174    mCaches.disbaleTexCoordsVertexArray();
1175}
1176
1177void OpenGLRenderer::setupDrawAALine() {
1178    mDescription.isAA = true;
1179}
1180
1181void OpenGLRenderer::setupDrawAARect() {
1182    mDescription.isAARect = true;
1183}
1184
1185void OpenGLRenderer::setupDrawPoint(float pointSize) {
1186    mDescription.isPoint = true;
1187    mDescription.pointSize = pointSize;
1188}
1189
1190void OpenGLRenderer::setupDrawColor(int color) {
1191    setupDrawColor(color, (color >> 24) & 0xFF);
1192}
1193
1194void OpenGLRenderer::setupDrawColor(int color, int alpha) {
1195    mColorA = alpha / 255.0f;
1196    // Second divide of a by 255 is an optimization, allowing us to simply multiply
1197    // the rgb values by a instead of also dividing by 255
1198    const float a = mColorA / 255.0f;
1199    mColorR = a * ((color >> 16) & 0xFF);
1200    mColorG = a * ((color >>  8) & 0xFF);
1201    mColorB = a * ((color      ) & 0xFF);
1202    mColorSet = true;
1203    mSetShaderColor = mDescription.setColor(mColorR, mColorG, mColorB, mColorA);
1204}
1205
1206void OpenGLRenderer::setupDrawAlpha8Color(int color, int alpha) {
1207    mColorA = alpha / 255.0f;
1208    // Double-divide of a by 255 is an optimization, allowing us to simply multiply
1209    // the rgb values by a instead of also dividing by 255
1210    const float a = mColorA / 255.0f;
1211    mColorR = a * ((color >> 16) & 0xFF);
1212    mColorG = a * ((color >>  8) & 0xFF);
1213    mColorB = a * ((color      ) & 0xFF);
1214    mColorSet = true;
1215    mSetShaderColor = mDescription.setAlpha8Color(mColorR, mColorG, mColorB, mColorA);
1216}
1217
1218void OpenGLRenderer::setupDrawTextGamma(const SkPaint* paint) {
1219    mCaches.fontRenderer->describe(mDescription, paint);
1220}
1221
1222void OpenGLRenderer::setupDrawColor(float r, float g, float b, float a) {
1223    mColorA = a;
1224    mColorR = r;
1225    mColorG = g;
1226    mColorB = b;
1227    mColorSet = true;
1228    mSetShaderColor = mDescription.setColor(r, g, b, a);
1229}
1230
1231void OpenGLRenderer::setupDrawShader() {
1232    if (mShader) {
1233        mShader->describe(mDescription, mCaches.extensions);
1234    }
1235}
1236
1237void OpenGLRenderer::setupDrawColorFilter() {
1238    if (mColorFilter) {
1239        mColorFilter->describe(mDescription, mCaches.extensions);
1240    }
1241}
1242
1243void OpenGLRenderer::accountForClear(SkXfermode::Mode mode) {
1244    if (mColorSet && mode == SkXfermode::kClear_Mode) {
1245        mColorA = 1.0f;
1246        mColorR = mColorG = mColorB = 0.0f;
1247        mSetShaderColor = mDescription.modulate = true;
1248    }
1249}
1250
1251void OpenGLRenderer::setupDrawBlending(SkXfermode::Mode mode, bool swapSrcDst) {
1252    // When the blending mode is kClear_Mode, we need to use a modulate color
1253    // argb=1,0,0,0
1254    accountForClear(mode);
1255    chooseBlending((mColorSet && mColorA < 1.0f) || (mShader && mShader->blend()), mode,
1256            mDescription, swapSrcDst);
1257}
1258
1259void OpenGLRenderer::setupDrawBlending(bool blend, SkXfermode::Mode mode, bool swapSrcDst) {
1260    // When the blending mode is kClear_Mode, we need to use a modulate color
1261    // argb=1,0,0,0
1262    accountForClear(mode);
1263    chooseBlending(blend || (mColorSet && mColorA < 1.0f) || (mShader && mShader->blend()), mode,
1264            mDescription, swapSrcDst);
1265}
1266
1267void OpenGLRenderer::setupDrawProgram() {
1268    useProgram(mCaches.programCache.get(mDescription));
1269}
1270
1271void OpenGLRenderer::setupDrawDirtyRegionsDisabled() {
1272    mTrackDirtyRegions = false;
1273}
1274
1275void OpenGLRenderer::setupDrawModelViewTranslate(float left, float top, float right, float bottom,
1276        bool ignoreTransform) {
1277    mModelView.loadTranslate(left, top, 0.0f);
1278    if (!ignoreTransform) {
1279        mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform);
1280        if (mTrackDirtyRegions) dirtyLayer(left, top, right, bottom, *mSnapshot->transform);
1281    } else {
1282        mCaches.currentProgram->set(mOrthoMatrix, mModelView, mIdentity);
1283        if (mTrackDirtyRegions) dirtyLayer(left, top, right, bottom);
1284    }
1285}
1286
1287void OpenGLRenderer::setupDrawModelViewIdentity(bool offset) {
1288    mCaches.currentProgram->set(mOrthoMatrix, mIdentity, *mSnapshot->transform, offset);
1289}
1290
1291void OpenGLRenderer::setupDrawModelView(float left, float top, float right, float bottom,
1292        bool ignoreTransform, bool ignoreModelView) {
1293    if (!ignoreModelView) {
1294        mModelView.loadTranslate(left, top, 0.0f);
1295        mModelView.scale(right - left, bottom - top, 1.0f);
1296    } else {
1297        mModelView.loadIdentity();
1298    }
1299    bool dirty = right - left > 0.0f && bottom - top > 0.0f;
1300    if (!ignoreTransform) {
1301        mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform);
1302        if (mTrackDirtyRegions && dirty) {
1303            dirtyLayer(left, top, right, bottom, *mSnapshot->transform);
1304        }
1305    } else {
1306        mCaches.currentProgram->set(mOrthoMatrix, mModelView, mIdentity);
1307        if (mTrackDirtyRegions && dirty) dirtyLayer(left, top, right, bottom);
1308    }
1309}
1310
1311void OpenGLRenderer::setupDrawPointUniforms() {
1312    int slot = mCaches.currentProgram->getUniform("pointSize");
1313    glUniform1f(slot, mDescription.pointSize);
1314}
1315
1316void OpenGLRenderer::setupDrawColorUniforms() {
1317    if ((mColorSet && !mShader) || (mShader && mSetShaderColor)) {
1318        mCaches.currentProgram->setColor(mColorR, mColorG, mColorB, mColorA);
1319    }
1320}
1321
1322void OpenGLRenderer::setupDrawPureColorUniforms() {
1323    if (mSetShaderColor) {
1324        mCaches.currentProgram->setColor(mColorR, mColorG, mColorB, mColorA);
1325    }
1326}
1327
1328void OpenGLRenderer::setupDrawShaderUniforms(bool ignoreTransform) {
1329    if (mShader) {
1330        if (ignoreTransform) {
1331            mModelView.loadInverse(*mSnapshot->transform);
1332        }
1333        mShader->setupProgram(mCaches.currentProgram, mModelView, *mSnapshot, &mTextureUnit);
1334    }
1335}
1336
1337void OpenGLRenderer::setupDrawShaderIdentityUniforms() {
1338    if (mShader) {
1339        mShader->setupProgram(mCaches.currentProgram, mIdentity, *mSnapshot, &mTextureUnit);
1340    }
1341}
1342
1343void OpenGLRenderer::setupDrawColorFilterUniforms() {
1344    if (mColorFilter) {
1345        mColorFilter->setupProgram(mCaches.currentProgram);
1346    }
1347}
1348
1349void OpenGLRenderer::setupDrawTextGammaUniforms() {
1350    mCaches.fontRenderer->setupProgram(mDescription, mCaches.currentProgram);
1351}
1352
1353void OpenGLRenderer::setupDrawSimpleMesh() {
1354    bool force = mCaches.bindMeshBuffer();
1355    mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position, 0);
1356    mCaches.unbindIndicesBuffer();
1357}
1358
1359void OpenGLRenderer::setupDrawTexture(GLuint texture) {
1360    bindTexture(texture);
1361    mTextureUnit++;
1362    mCaches.enableTexCoordsVertexArray();
1363}
1364
1365void OpenGLRenderer::setupDrawExternalTexture(GLuint texture) {
1366    bindExternalTexture(texture);
1367    mTextureUnit++;
1368    mCaches.enableTexCoordsVertexArray();
1369}
1370
1371void OpenGLRenderer::setupDrawTextureTransform() {
1372    mDescription.hasTextureTransform = true;
1373}
1374
1375void OpenGLRenderer::setupDrawTextureTransformUniforms(mat4& transform) {
1376    glUniformMatrix4fv(mCaches.currentProgram->getUniform("mainTextureTransform"), 1,
1377            GL_FALSE, &transform.data[0]);
1378}
1379
1380void OpenGLRenderer::setupDrawMesh(GLvoid* vertices, GLvoid* texCoords, GLuint vbo) {
1381    bool force = false;
1382    if (!vertices) {
1383        force = mCaches.bindMeshBuffer(vbo == 0 ? mCaches.meshBuffer : vbo);
1384    } else {
1385        force = mCaches.unbindMeshBuffer();
1386    }
1387
1388    mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position, vertices);
1389    if (mCaches.currentProgram->texCoords >= 0) {
1390        mCaches.bindTexCoordsVertexPointer(force, mCaches.currentProgram->texCoords, texCoords);
1391    }
1392
1393    mCaches.unbindIndicesBuffer();
1394}
1395
1396void OpenGLRenderer::setupDrawMeshIndices(GLvoid* vertices, GLvoid* texCoords) {
1397    bool force = mCaches.unbindMeshBuffer();
1398    mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position, vertices);
1399    if (mCaches.currentProgram->texCoords >= 0) {
1400        mCaches.bindTexCoordsVertexPointer(force, mCaches.currentProgram->texCoords, texCoords);
1401    }
1402}
1403
1404void OpenGLRenderer::setupDrawVertices(GLvoid* vertices) {
1405    bool force = mCaches.unbindMeshBuffer();
1406    mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position,
1407            vertices, gVertexStride);
1408    mCaches.unbindIndicesBuffer();
1409}
1410
1411/**
1412 * Sets up the shader to draw an AA line. We draw AA lines with quads, where there is an
1413 * outer boundary that fades out to 0. The variables set in the shader define the proportion of
1414 * the width and length of the primitive occupied by the AA region. The vtxWidth and vtxLength
1415 * attributes (one per vertex) are values from zero to one that tells the fragment
1416 * shader where the fragment is in relation to the line width/length overall; these values are
1417 * then used to compute the proper color, based on whether the fragment lies in the fading AA
1418 * region of the line.
1419 * Note that we only pass down the width values in this setup function. The length coordinates
1420 * are set up for each individual segment.
1421 */
1422void OpenGLRenderer::setupDrawAALine(GLvoid* vertices, GLvoid* widthCoords,
1423        GLvoid* lengthCoords, float boundaryWidthProportion, int& widthSlot, int& lengthSlot) {
1424    bool force = mCaches.unbindMeshBuffer();
1425    mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position,
1426            vertices, gAAVertexStride);
1427    mCaches.resetTexCoordsVertexPointer();
1428    mCaches.unbindIndicesBuffer();
1429
1430    widthSlot = mCaches.currentProgram->getAttrib("vtxWidth");
1431    glEnableVertexAttribArray(widthSlot);
1432    glVertexAttribPointer(widthSlot, 1, GL_FLOAT, GL_FALSE, gAAVertexStride, widthCoords);
1433
1434    lengthSlot = mCaches.currentProgram->getAttrib("vtxLength");
1435    glEnableVertexAttribArray(lengthSlot);
1436    glVertexAttribPointer(lengthSlot, 1, GL_FLOAT, GL_FALSE, gAAVertexStride, lengthCoords);
1437
1438    int boundaryWidthSlot = mCaches.currentProgram->getUniform("boundaryWidth");
1439    glUniform1f(boundaryWidthSlot, boundaryWidthProportion);
1440}
1441
1442void OpenGLRenderer::finishDrawAALine(const int widthSlot, const int lengthSlot) {
1443    glDisableVertexAttribArray(widthSlot);
1444    glDisableVertexAttribArray(lengthSlot);
1445}
1446
1447void OpenGLRenderer::finishDrawTexture() {
1448}
1449
1450///////////////////////////////////////////////////////////////////////////////
1451// Drawing
1452///////////////////////////////////////////////////////////////////////////////
1453
1454status_t OpenGLRenderer::drawDisplayList(DisplayList* displayList,
1455        Rect& dirty, int32_t flags, uint32_t level) {
1456
1457    // All the usual checks and setup operations (quickReject, setupDraw, etc.)
1458    // will be performed by the display list itself
1459    if (displayList && displayList->isRenderable()) {
1460        return displayList->replay(*this, dirty, flags, level);
1461    }
1462
1463    return DrawGlInfo::kStatusDone;
1464}
1465
1466void OpenGLRenderer::outputDisplayList(DisplayList* displayList, uint32_t level) {
1467    if (displayList) {
1468        displayList->output(*this, level);
1469    }
1470}
1471
1472void OpenGLRenderer::drawAlphaBitmap(Texture* texture, float left, float top, SkPaint* paint) {
1473    int alpha;
1474    SkXfermode::Mode mode;
1475    getAlphaAndMode(paint, &alpha, &mode);
1476
1477    float x = left;
1478    float y = top;
1479
1480    GLenum filter = GL_LINEAR;
1481    bool ignoreTransform = false;
1482    if (mSnapshot->transform->isPureTranslate()) {
1483        x = (int) floorf(left + mSnapshot->transform->getTranslateX() + 0.5f);
1484        y = (int) floorf(top + mSnapshot->transform->getTranslateY() + 0.5f);
1485        ignoreTransform = true;
1486        filter = GL_NEAREST;
1487    } else {
1488        filter = FILTER(paint);
1489    }
1490
1491    setupDraw();
1492    setupDrawWithTexture(true);
1493    if (paint) {
1494        setupDrawAlpha8Color(paint->getColor(), alpha);
1495    }
1496    setupDrawColorFilter();
1497    setupDrawShader();
1498    setupDrawBlending(true, mode);
1499    setupDrawProgram();
1500    setupDrawModelView(x, y, x + texture->width, y + texture->height, ignoreTransform);
1501
1502    setupDrawTexture(texture->id);
1503    texture->setWrap(GL_CLAMP_TO_EDGE);
1504    texture->setFilter(filter);
1505
1506    setupDrawPureColorUniforms();
1507    setupDrawColorFilterUniforms();
1508    setupDrawShaderUniforms();
1509    setupDrawMesh(NULL, (GLvoid*) gMeshTextureOffset);
1510
1511    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
1512
1513    finishDrawTexture();
1514}
1515
1516status_t OpenGLRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint) {
1517    const float right = left + bitmap->width();
1518    const float bottom = top + bitmap->height();
1519
1520    if (quickReject(left, top, right, bottom)) {
1521        return DrawGlInfo::kStatusDone;
1522    }
1523
1524    mCaches.activeTexture(0);
1525    Texture* texture = mCaches.textureCache.get(bitmap);
1526    if (!texture) return DrawGlInfo::kStatusDone;
1527    const AutoTexture autoCleanup(texture);
1528
1529    if (CC_UNLIKELY(bitmap->getConfig() == SkBitmap::kA8_Config)) {
1530        drawAlphaBitmap(texture, left, top, paint);
1531    } else {
1532        drawTextureRect(left, top, right, bottom, texture, paint);
1533    }
1534
1535    return DrawGlInfo::kStatusDrew;
1536}
1537
1538status_t OpenGLRenderer::drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint) {
1539    Rect r(0.0f, 0.0f, bitmap->width(), bitmap->height());
1540    const mat4 transform(*matrix);
1541    transform.mapRect(r);
1542
1543    if (quickReject(r.left, r.top, r.right, r.bottom)) {
1544        return DrawGlInfo::kStatusDone;
1545    }
1546
1547    mCaches.activeTexture(0);
1548    Texture* texture = mCaches.textureCache.get(bitmap);
1549    if (!texture) return DrawGlInfo::kStatusDone;
1550    const AutoTexture autoCleanup(texture);
1551
1552    // This could be done in a cheaper way, all we need is pass the matrix
1553    // to the vertex shader. The save/restore is a bit overkill.
1554    save(SkCanvas::kMatrix_SaveFlag);
1555    concatMatrix(matrix);
1556    drawTextureRect(0.0f, 0.0f, bitmap->width(), bitmap->height(), texture, paint);
1557    restore();
1558
1559    return DrawGlInfo::kStatusDrew;
1560}
1561
1562status_t OpenGLRenderer::drawBitmapData(SkBitmap* bitmap, float left, float top, SkPaint* paint) {
1563    const float right = left + bitmap->width();
1564    const float bottom = top + bitmap->height();
1565
1566    if (quickReject(left, top, right, bottom)) {
1567        return DrawGlInfo::kStatusDone;
1568    }
1569
1570    mCaches.activeTexture(0);
1571    Texture* texture = mCaches.textureCache.getTransient(bitmap);
1572    const AutoTexture autoCleanup(texture);
1573
1574    drawTextureRect(left, top, right, bottom, texture, paint);
1575
1576    return DrawGlInfo::kStatusDrew;
1577}
1578
1579status_t OpenGLRenderer::drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight,
1580        float* vertices, int* colors, SkPaint* paint) {
1581    // TODO: Do a quickReject
1582    if (!vertices || mSnapshot->isIgnored()) {
1583        return DrawGlInfo::kStatusDone;
1584    }
1585
1586    mCaches.activeTexture(0);
1587    Texture* texture = mCaches.textureCache.get(bitmap);
1588    if (!texture) return DrawGlInfo::kStatusDone;
1589    const AutoTexture autoCleanup(texture);
1590
1591    texture->setWrap(GL_CLAMP_TO_EDGE, true);
1592    texture->setFilter(FILTER(paint), true);
1593
1594    int alpha;
1595    SkXfermode::Mode mode;
1596    getAlphaAndMode(paint, &alpha, &mode);
1597
1598    const uint32_t count = meshWidth * meshHeight * 6;
1599
1600    float left = FLT_MAX;
1601    float top = FLT_MAX;
1602    float right = FLT_MIN;
1603    float bottom = FLT_MIN;
1604
1605    const bool hasActiveLayer = hasLayer();
1606
1607    // TODO: Support the colors array
1608    TextureVertex mesh[count];
1609    TextureVertex* vertex = mesh;
1610    for (int32_t y = 0; y < meshHeight; y++) {
1611        for (int32_t x = 0; x < meshWidth; x++) {
1612            uint32_t i = (y * (meshWidth + 1) + x) * 2;
1613
1614            float u1 = float(x) / meshWidth;
1615            float u2 = float(x + 1) / meshWidth;
1616            float v1 = float(y) / meshHeight;
1617            float v2 = float(y + 1) / meshHeight;
1618
1619            int ax = i + (meshWidth + 1) * 2;
1620            int ay = ax + 1;
1621            int bx = i;
1622            int by = bx + 1;
1623            int cx = i + 2;
1624            int cy = cx + 1;
1625            int dx = i + (meshWidth + 1) * 2 + 2;
1626            int dy = dx + 1;
1627
1628            TextureVertex::set(vertex++, vertices[ax], vertices[ay], u1, v2);
1629            TextureVertex::set(vertex++, vertices[bx], vertices[by], u1, v1);
1630            TextureVertex::set(vertex++, vertices[cx], vertices[cy], u2, v1);
1631
1632            TextureVertex::set(vertex++, vertices[ax], vertices[ay], u1, v2);
1633            TextureVertex::set(vertex++, vertices[cx], vertices[cy], u2, v1);
1634            TextureVertex::set(vertex++, vertices[dx], vertices[dy], u2, v2);
1635
1636            if (hasActiveLayer) {
1637                // TODO: This could be optimized to avoid unnecessary ops
1638                left = fminf(left, fminf(vertices[ax], fminf(vertices[bx], vertices[cx])));
1639                top = fminf(top, fminf(vertices[ay], fminf(vertices[by], vertices[cy])));
1640                right = fmaxf(right, fmaxf(vertices[ax], fmaxf(vertices[bx], vertices[cx])));
1641                bottom = fmaxf(bottom, fmaxf(vertices[ay], fmaxf(vertices[by], vertices[cy])));
1642            }
1643        }
1644    }
1645
1646    if (hasActiveLayer) {
1647        dirtyLayer(left, top, right, bottom, *mSnapshot->transform);
1648    }
1649
1650    drawTextureMesh(0.0f, 0.0f, 1.0f, 1.0f, texture->id, alpha / 255.0f,
1651            mode, texture->blend, &mesh[0].position[0], &mesh[0].texture[0],
1652            GL_TRIANGLES, count, false, false, 0, false, false);
1653
1654    return DrawGlInfo::kStatusDrew;
1655}
1656
1657status_t OpenGLRenderer::drawBitmap(SkBitmap* bitmap,
1658         float srcLeft, float srcTop, float srcRight, float srcBottom,
1659         float dstLeft, float dstTop, float dstRight, float dstBottom,
1660         SkPaint* paint) {
1661    if (quickReject(dstLeft, dstTop, dstRight, dstBottom)) {
1662        return DrawGlInfo::kStatusDone;
1663    }
1664
1665    mCaches.activeTexture(0);
1666    Texture* texture = mCaches.textureCache.get(bitmap);
1667    if (!texture) return DrawGlInfo::kStatusDone;
1668    const AutoTexture autoCleanup(texture);
1669
1670    const float width = texture->width;
1671    const float height = texture->height;
1672
1673    const float u1 = fmax(0.0f, srcLeft / width);
1674    const float v1 = fmax(0.0f, srcTop / height);
1675    const float u2 = fmin(1.0f, srcRight / width);
1676    const float v2 = fmin(1.0f, srcBottom / height);
1677
1678    mCaches.unbindMeshBuffer();
1679    resetDrawTextureTexCoords(u1, v1, u2, v2);
1680
1681    int alpha;
1682    SkXfermode::Mode mode;
1683    getAlphaAndMode(paint, &alpha, &mode);
1684
1685    texture->setWrap(GL_CLAMP_TO_EDGE, true);
1686
1687    if (CC_LIKELY(mSnapshot->transform->isPureTranslate())) {
1688        const float x = (int) floorf(dstLeft + mSnapshot->transform->getTranslateX() + 0.5f);
1689        const float y = (int) floorf(dstTop + mSnapshot->transform->getTranslateY() + 0.5f);
1690
1691        GLenum filter = GL_NEAREST;
1692        // Enable linear filtering if the source rectangle is scaled
1693        if (srcRight - srcLeft != dstRight - dstLeft || srcBottom - srcTop != dstBottom - dstTop) {
1694            filter = FILTER(paint);
1695        }
1696
1697        texture->setFilter(filter, true);
1698        drawTextureMesh(x, y, x + (dstRight - dstLeft), y + (dstBottom - dstTop),
1699                texture->id, alpha / 255.0f, mode, texture->blend,
1700                &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0],
1701                GL_TRIANGLE_STRIP, gMeshCount, false, true);
1702    } else {
1703        texture->setFilter(FILTER(paint), true);
1704        drawTextureMesh(dstLeft, dstTop, dstRight, dstBottom, texture->id, alpha / 255.0f,
1705                mode, texture->blend, &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0],
1706                GL_TRIANGLE_STRIP, gMeshCount);
1707    }
1708
1709    resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
1710
1711    return DrawGlInfo::kStatusDrew;
1712}
1713
1714status_t OpenGLRenderer::drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
1715        const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
1716        float left, float top, float right, float bottom, SkPaint* paint) {
1717    int alpha;
1718    SkXfermode::Mode mode;
1719    getAlphaAndModeDirect(paint, &alpha, &mode);
1720
1721    return drawPatch(bitmap, xDivs, yDivs, colors, width, height, numColors,
1722            left, top, right, bottom, alpha, mode);
1723}
1724
1725status_t OpenGLRenderer::drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
1726        const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
1727        float left, float top, float right, float bottom, int alpha, SkXfermode::Mode mode) {
1728    if (quickReject(left, top, right, bottom)) {
1729        return DrawGlInfo::kStatusDone;
1730    }
1731
1732    alpha *= mSnapshot->alpha;
1733
1734    mCaches.activeTexture(0);
1735    Texture* texture = mCaches.textureCache.get(bitmap);
1736    if (!texture) return DrawGlInfo::kStatusDone;
1737    const AutoTexture autoCleanup(texture);
1738    texture->setWrap(GL_CLAMP_TO_EDGE, true);
1739    texture->setFilter(GL_LINEAR, true);
1740
1741    const Patch* mesh = mCaches.patchCache.get(bitmap->width(), bitmap->height(),
1742            right - left, bottom - top, xDivs, yDivs, colors, width, height, numColors);
1743
1744    if (CC_LIKELY(mesh && mesh->verticesCount > 0)) {
1745        const bool pureTranslate = mSnapshot->transform->isPureTranslate();
1746        // Mark the current layer dirty where we are going to draw the patch
1747        if (hasLayer() && mesh->hasEmptyQuads) {
1748            const float offsetX = left + mSnapshot->transform->getTranslateX();
1749            const float offsetY = top + mSnapshot->transform->getTranslateY();
1750            const size_t count = mesh->quads.size();
1751            for (size_t i = 0; i < count; i++) {
1752                const Rect& bounds = mesh->quads.itemAt(i);
1753                if (CC_LIKELY(pureTranslate)) {
1754                    const float x = (int) floorf(bounds.left + offsetX + 0.5f);
1755                    const float y = (int) floorf(bounds.top + offsetY + 0.5f);
1756                    dirtyLayer(x, y, x + bounds.getWidth(), y + bounds.getHeight());
1757                } else {
1758                    dirtyLayer(left + bounds.left, top + bounds.top,
1759                            left + bounds.right, top + bounds.bottom, *mSnapshot->transform);
1760                }
1761            }
1762        }
1763
1764        if (CC_LIKELY(pureTranslate)) {
1765            const float x = (int) floorf(left + mSnapshot->transform->getTranslateX() + 0.5f);
1766            const float y = (int) floorf(top + mSnapshot->transform->getTranslateY() + 0.5f);
1767
1768            drawTextureMesh(x, y, x + right - left, y + bottom - top, texture->id, alpha / 255.0f,
1769                    mode, texture->blend, (GLvoid*) 0, (GLvoid*) gMeshTextureOffset,
1770                    GL_TRIANGLES, mesh->verticesCount, false, true, mesh->meshBuffer,
1771                    true, !mesh->hasEmptyQuads);
1772        } else {
1773            drawTextureMesh(left, top, right, bottom, texture->id, alpha / 255.0f,
1774                    mode, texture->blend, (GLvoid*) 0, (GLvoid*) gMeshTextureOffset,
1775                    GL_TRIANGLES, mesh->verticesCount, false, false, mesh->meshBuffer,
1776                    true, !mesh->hasEmptyQuads);
1777        }
1778    }
1779
1780    return DrawGlInfo::kStatusDrew;
1781}
1782
1783/**
1784 * This function uses a similar approach to that of AA lines in the drawLines() function.
1785 * We expand the rectangle by a half pixel in screen space on all sides. However, instead of using
1786 * a fragment shader to compute the translucency of the color from its position, we simply use a
1787 * varying parameter to define how far a given pixel is into the region.
1788 */
1789void OpenGLRenderer::drawAARect(float left, float top, float right, float bottom,
1790        int color, SkXfermode::Mode mode) {
1791    float inverseScaleX = 1.0f;
1792    float inverseScaleY = 1.0f;
1793
1794    // The quad that we use needs to account for scaling.
1795    if (CC_UNLIKELY(!mSnapshot->transform->isPureTranslate())) {
1796        Matrix4 *mat = mSnapshot->transform;
1797        float m00 = mat->data[Matrix4::kScaleX];
1798        float m01 = mat->data[Matrix4::kSkewY];
1799        float m10 = mat->data[Matrix4::kSkewX];
1800        float m11 = mat->data[Matrix4::kScaleY];
1801        float scaleX = sqrt(m00 * m00 + m01 * m01);
1802        float scaleY = sqrt(m10 * m10 + m11 * m11);
1803        inverseScaleX = (scaleX != 0) ? (inverseScaleX / scaleX) : 0;
1804        inverseScaleY = (scaleY != 0) ? (inverseScaleY / scaleY) : 0;
1805    }
1806
1807    float boundarySizeX = .5 * inverseScaleX;
1808    float boundarySizeY = .5 * inverseScaleY;
1809
1810    float innerLeft = left + boundarySizeX;
1811    float innerRight = right - boundarySizeX;
1812    float innerTop = top + boundarySizeY;
1813    float innerBottom = bottom - boundarySizeY;
1814
1815    // Adjust the rect by the AA boundary padding
1816    left -= boundarySizeX;
1817    right += boundarySizeX;
1818    top -= boundarySizeY;
1819    bottom += boundarySizeY;
1820
1821    if (!quickReject(left, top, right, bottom)) {
1822        setupDraw();
1823        setupDrawNoTexture();
1824        setupDrawAARect();
1825        setupDrawColor(color, ((color >> 24) & 0xFF) * mSnapshot->alpha);
1826        setupDrawColorFilter();
1827        setupDrawShader();
1828        setupDrawBlending(true, mode);
1829        setupDrawProgram();
1830        setupDrawModelViewIdentity(true);
1831        setupDrawColorUniforms();
1832        setupDrawColorFilterUniforms();
1833        setupDrawShaderIdentityUniforms();
1834
1835        AlphaVertex rects[14];
1836        AlphaVertex* aVertices = &rects[0];
1837        void* alphaCoords = ((GLbyte*) aVertices) + gVertexAlphaOffset;
1838
1839        bool force = mCaches.unbindMeshBuffer();
1840        mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position,
1841                aVertices, gAlphaVertexStride);
1842        mCaches.resetTexCoordsVertexPointer();
1843        mCaches.unbindIndicesBuffer();
1844
1845        int alphaSlot = mCaches.currentProgram->getAttrib("vtxAlpha");
1846        glEnableVertexAttribArray(alphaSlot);
1847        glVertexAttribPointer(alphaSlot, 1, GL_FLOAT, GL_FALSE, gAlphaVertexStride, alphaCoords);
1848
1849        // draw left
1850        AlphaVertex::set(aVertices++, left, bottom, 0);
1851        AlphaVertex::set(aVertices++, innerLeft, innerBottom, 1);
1852        AlphaVertex::set(aVertices++, left, top, 0);
1853        AlphaVertex::set(aVertices++, innerLeft, innerTop, 1);
1854
1855        // draw top
1856        AlphaVertex::set(aVertices++, right, top, 0);
1857        AlphaVertex::set(aVertices++, innerRight, innerTop, 1);
1858
1859        // draw right
1860        AlphaVertex::set(aVertices++, right, bottom, 0);
1861        AlphaVertex::set(aVertices++, innerRight, innerBottom, 1);
1862
1863        // draw bottom
1864        AlphaVertex::set(aVertices++, left, bottom, 0);
1865        AlphaVertex::set(aVertices++, innerLeft, innerBottom, 1);
1866
1867        // draw inner rect (repeating last vertex to create degenerate bridge triangles)
1868        // TODO: also consider drawing the inner rect without the blending-forced shader, if
1869        // blending is expensive. Note: can't use drawColorRect() since it doesn't use vertex
1870        // buffers like below, resulting in slightly different transformed coordinates.
1871        AlphaVertex::set(aVertices++, innerLeft, innerBottom, 1);
1872        AlphaVertex::set(aVertices++, innerLeft, innerTop, 1);
1873        AlphaVertex::set(aVertices++, innerRight, innerBottom, 1);
1874        AlphaVertex::set(aVertices++, innerRight, innerTop, 1);
1875
1876        dirtyLayer(left, top, right, bottom, *mSnapshot->transform);
1877
1878        glDrawArrays(GL_TRIANGLE_STRIP, 0, 14);
1879
1880        glDisableVertexAttribArray(alphaSlot);
1881    }
1882}
1883
1884/**
1885 * We draw lines as quads (tristrips). Using GL_LINES can be difficult because the rasterization
1886 * rules for those lines produces some unexpected results, and may vary between hardware devices.
1887 * The basics of lines-as-quads is easy; we simply find the normal to the line and position the
1888 * corners of the quads on either side of each line endpoint, separated by the strokeWidth
1889 * of the line. Hairlines are more involved because we need to account for transform scaling
1890 * to end up with a one-pixel-wide line in screen space..
1891 * Anti-aliased lines add another factor to the approach. We use a specialized fragment shader
1892 * in combination with values that we calculate and pass down in this method. The basic approach
1893 * is that the quad we create contains both the core line area plus a bounding area in which
1894 * the translucent/AA pixels are drawn. The values we calculate tell the shader what
1895 * proportion of the width and the length of a given segment is represented by the boundary
1896 * region. The quad ends up being exactly .5 pixel larger in all directions than the non-AA quad.
1897 * The bounding region is actually 1 pixel wide on all sides (half pixel on the outside, half pixel
1898 * on the inside). This ends up giving the result we want, with pixels that are completely
1899 * 'inside' the line area being filled opaquely and the other pixels being filled according to
1900 * how far into the boundary region they are, which is determined by shader interpolation.
1901 */
1902status_t OpenGLRenderer::drawLines(float* points, int count, SkPaint* paint) {
1903    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
1904
1905    const bool isAA = paint->isAntiAlias();
1906    // We use half the stroke width here because we're going to position the quad
1907    // corner vertices half of the width away from the line endpoints
1908    float halfStrokeWidth = paint->getStrokeWidth() * 0.5f;
1909    // A stroke width of 0 has a special meaning in Skia:
1910    // it draws a line 1 px wide regardless of current transform
1911    bool isHairLine = paint->getStrokeWidth() == 0.0f;
1912
1913    float inverseScaleX = 1.0f;
1914    float inverseScaleY = 1.0f;
1915    bool scaled = false;
1916
1917    int alpha;
1918    SkXfermode::Mode mode;
1919
1920    int generatedVerticesCount = 0;
1921    int verticesCount = count;
1922    if (count > 4) {
1923        // Polyline: account for extra vertices needed for continuous tri-strip
1924        verticesCount += (count - 4);
1925    }
1926
1927    if (isHairLine || isAA) {
1928        // The quad that we use for AA and hairlines needs to account for scaling. For hairlines
1929        // the line on the screen should always be one pixel wide regardless of scale. For
1930        // AA lines, we only want one pixel of translucent boundary around the quad.
1931        if (CC_UNLIKELY(!mSnapshot->transform->isPureTranslate())) {
1932            Matrix4 *mat = mSnapshot->transform;
1933            float m00 = mat->data[Matrix4::kScaleX];
1934            float m01 = mat->data[Matrix4::kSkewY];
1935            float m10 = mat->data[Matrix4::kSkewX];
1936            float m11 = mat->data[Matrix4::kScaleY];
1937
1938            float scaleX = sqrtf(m00 * m00 + m01 * m01);
1939            float scaleY = sqrtf(m10 * m10 + m11 * m11);
1940
1941            inverseScaleX = (scaleX != 0) ? (inverseScaleX / scaleX) : 0;
1942            inverseScaleY = (scaleY != 0) ? (inverseScaleY / scaleY) : 0;
1943
1944            if (inverseScaleX != 1.0f || inverseScaleY != 1.0f) {
1945                scaled = true;
1946            }
1947        }
1948    }
1949
1950    getAlphaAndMode(paint, &alpha, &mode);
1951
1952    mCaches.enableScissor();
1953
1954    setupDraw();
1955    setupDrawNoTexture();
1956    if (isAA) {
1957        setupDrawAALine();
1958    }
1959    setupDrawColor(paint->getColor(), alpha);
1960    setupDrawColorFilter();
1961    setupDrawShader();
1962    setupDrawBlending(isAA, mode);
1963    setupDrawProgram();
1964    setupDrawModelViewIdentity(true);
1965    setupDrawColorUniforms();
1966    setupDrawColorFilterUniforms();
1967    setupDrawShaderIdentityUniforms();
1968
1969    if (isHairLine) {
1970        // Set a real stroke width to be used in quad construction
1971        halfStrokeWidth = isAA? 1 : .5;
1972    } else if (isAA && !scaled) {
1973        // Expand boundary to enable AA calculations on the quad border
1974        halfStrokeWidth += .5f;
1975    }
1976
1977    int widthSlot;
1978    int lengthSlot;
1979
1980    Vertex lines[verticesCount];
1981    Vertex* vertices = &lines[0];
1982
1983    AAVertex wLines[verticesCount];
1984    AAVertex* aaVertices = &wLines[0];
1985
1986    if (CC_UNLIKELY(!isAA)) {
1987        setupDrawVertices(vertices);
1988    } else {
1989        void* widthCoords = ((GLbyte*) aaVertices) + gVertexAAWidthOffset;
1990        void* lengthCoords = ((GLbyte*) aaVertices) + gVertexAALengthOffset;
1991        // innerProportion is the ratio of the inner (non-AA) part of the line to the total
1992        // AA stroke width (the base stroke width expanded by a half pixel on either side).
1993        // This value is used in the fragment shader to determine how to fill fragments.
1994        // We will need to calculate the actual width proportion on each segment for
1995        // scaled non-hairlines, since the boundary proportion may differ per-axis when scaled.
1996        float boundaryWidthProportion = .5 - 1 / (2 * halfStrokeWidth);
1997        setupDrawAALine((void*) aaVertices, widthCoords, lengthCoords,
1998                boundaryWidthProportion, widthSlot, lengthSlot);
1999    }
2000
2001    AAVertex* prevAAVertex = NULL;
2002    Vertex* prevVertex = NULL;
2003
2004    int boundaryLengthSlot = -1;
2005    int boundaryWidthSlot = -1;
2006
2007    for (int i = 0; i < count; i += 4) {
2008        // a = start point, b = end point
2009        vec2 a(points[i], points[i + 1]);
2010        vec2 b(points[i + 2], points[i + 3]);
2011
2012        float length = 0;
2013        float boundaryLengthProportion = 0;
2014        float boundaryWidthProportion = 0;
2015
2016        // Find the normal to the line
2017        vec2 n = (b - a).copyNormalized() * halfStrokeWidth;
2018        float x = n.x;
2019        n.x = -n.y;
2020        n.y = x;
2021
2022        if (isHairLine) {
2023            if (isAA) {
2024                float wideningFactor;
2025                if (fabs(n.x) >= fabs(n.y)) {
2026                    wideningFactor = fabs(1.0f / n.x);
2027                } else {
2028                    wideningFactor = fabs(1.0f / n.y);
2029                }
2030                n *= wideningFactor;
2031            }
2032
2033            if (scaled) {
2034                n.x *= inverseScaleX;
2035                n.y *= inverseScaleY;
2036            }
2037        } else if (scaled) {
2038            // Extend n by .5 pixel on each side, post-transform
2039            vec2 extendedN = n.copyNormalized();
2040            extendedN /= 2;
2041            extendedN.x *= inverseScaleX;
2042            extendedN.y *= inverseScaleY;
2043
2044            float extendedNLength = extendedN.length();
2045            // We need to set this value on the shader prior to drawing
2046            boundaryWidthProportion = .5 - extendedNLength / (halfStrokeWidth + extendedNLength);
2047            n += extendedN;
2048        }
2049
2050        // aa lines expand the endpoint vertices to encompass the AA boundary
2051        if (isAA) {
2052            vec2 abVector = (b - a);
2053            length = abVector.length();
2054            abVector.normalize();
2055
2056            if (scaled) {
2057                abVector.x *= inverseScaleX;
2058                abVector.y *= inverseScaleY;
2059                float abLength = abVector.length();
2060                boundaryLengthProportion = .5 - abLength / (length + abLength);
2061            } else {
2062                boundaryLengthProportion = .5 - .5 / (length + 1);
2063            }
2064
2065            abVector /= 2;
2066            a -= abVector;
2067            b += abVector;
2068        }
2069
2070        // Four corners of the rectangle defining a thick line
2071        vec2 p1 = a - n;
2072        vec2 p2 = a + n;
2073        vec2 p3 = b + n;
2074        vec2 p4 = b - n;
2075
2076
2077        const float left = fmin(p1.x, fmin(p2.x, fmin(p3.x, p4.x)));
2078        const float right = fmax(p1.x, fmax(p2.x, fmax(p3.x, p4.x)));
2079        const float top = fmin(p1.y, fmin(p2.y, fmin(p3.y, p4.y)));
2080        const float bottom = fmax(p1.y, fmax(p2.y, fmax(p3.y, p4.y)));
2081
2082        if (!quickRejectNoScissor(left, top, right, bottom)) {
2083            if (!isAA) {
2084                if (prevVertex != NULL) {
2085                    // Issue two repeat vertices to create degenerate triangles to bridge
2086                    // between the previous line and the new one. This is necessary because
2087                    // we are creating a single triangle_strip which will contain
2088                    // potentially discontinuous line segments.
2089                    Vertex::set(vertices++, prevVertex->position[0], prevVertex->position[1]);
2090                    Vertex::set(vertices++, p1.x, p1.y);
2091                    generatedVerticesCount += 2;
2092                }
2093
2094                Vertex::set(vertices++, p1.x, p1.y);
2095                Vertex::set(vertices++, p2.x, p2.y);
2096                Vertex::set(vertices++, p4.x, p4.y);
2097                Vertex::set(vertices++, p3.x, p3.y);
2098
2099                prevVertex = vertices - 1;
2100                generatedVerticesCount += 4;
2101            } else {
2102                if (!isHairLine && scaled) {
2103                    // Must set width proportions per-segment for scaled non-hairlines to use the
2104                    // correct AA boundary dimensions
2105                    if (boundaryWidthSlot < 0) {
2106                        boundaryWidthSlot =
2107                                mCaches.currentProgram->getUniform("boundaryWidth");
2108                    }
2109
2110                    glUniform1f(boundaryWidthSlot, boundaryWidthProportion);
2111                }
2112
2113                if (boundaryLengthSlot < 0) {
2114                    boundaryLengthSlot = mCaches.currentProgram->getUniform("boundaryLength");
2115                }
2116
2117                glUniform1f(boundaryLengthSlot, boundaryLengthProportion);
2118
2119                if (prevAAVertex != NULL) {
2120                    // Issue two repeat vertices to create degenerate triangles to bridge
2121                    // between the previous line and the new one. This is necessary because
2122                    // we are creating a single triangle_strip which will contain
2123                    // potentially discontinuous line segments.
2124                    AAVertex::set(aaVertices++,prevAAVertex->position[0],
2125                            prevAAVertex->position[1], prevAAVertex->width, prevAAVertex->length);
2126                    AAVertex::set(aaVertices++, p4.x, p4.y, 1, 1);
2127                    generatedVerticesCount += 2;
2128                }
2129
2130                AAVertex::set(aaVertices++, p4.x, p4.y, 1, 1);
2131                AAVertex::set(aaVertices++, p1.x, p1.y, 1, 0);
2132                AAVertex::set(aaVertices++, p3.x, p3.y, 0, 1);
2133                AAVertex::set(aaVertices++, p2.x, p2.y, 0, 0);
2134
2135                prevAAVertex = aaVertices - 1;
2136                generatedVerticesCount += 4;
2137            }
2138
2139            dirtyLayer(a.x == b.x ? left - 1 : left, a.y == b.y ? top - 1 : top,
2140                    a.x == b.x ? right: right, a.y == b.y ? bottom: bottom,
2141                    *mSnapshot->transform);
2142        }
2143    }
2144
2145    if (generatedVerticesCount > 0) {
2146       glDrawArrays(GL_TRIANGLE_STRIP, 0, generatedVerticesCount);
2147    }
2148
2149    if (isAA) {
2150        finishDrawAALine(widthSlot, lengthSlot);
2151    }
2152
2153    return DrawGlInfo::kStatusDrew;
2154}
2155
2156status_t OpenGLRenderer::drawPoints(float* points, int count, SkPaint* paint) {
2157    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
2158
2159    // TODO: The paint's cap style defines whether the points are square or circular
2160    // TODO: Handle AA for round points
2161
2162    // A stroke width of 0 has a special meaning in Skia:
2163    // it draws an unscaled 1px point
2164    float strokeWidth = paint->getStrokeWidth();
2165    const bool isHairLine = paint->getStrokeWidth() == 0.0f;
2166    if (isHairLine) {
2167        // Now that we know it's hairline, we can set the effective width, to be used later
2168        strokeWidth = 1.0f;
2169    }
2170    const float halfWidth = strokeWidth / 2;
2171    int alpha;
2172    SkXfermode::Mode mode;
2173    getAlphaAndMode(paint, &alpha, &mode);
2174
2175    int verticesCount = count >> 1;
2176    int generatedVerticesCount = 0;
2177
2178    TextureVertex pointsData[verticesCount];
2179    TextureVertex* vertex = &pointsData[0];
2180
2181    // TODO: We should optimize this method to not generate vertices for points
2182    // that lie outside of the clip.
2183    mCaches.enableScissor();
2184
2185    setupDraw();
2186    setupDrawNoTexture();
2187    setupDrawPoint(strokeWidth);
2188    setupDrawColor(paint->getColor(), alpha);
2189    setupDrawColorFilter();
2190    setupDrawShader();
2191    setupDrawBlending(mode);
2192    setupDrawProgram();
2193    setupDrawModelViewIdentity(true);
2194    setupDrawColorUniforms();
2195    setupDrawColorFilterUniforms();
2196    setupDrawPointUniforms();
2197    setupDrawShaderIdentityUniforms();
2198    setupDrawMesh(vertex);
2199
2200    for (int i = 0; i < count; i += 2) {
2201        TextureVertex::set(vertex++, points[i], points[i + 1], 0.0f, 0.0f);
2202        generatedVerticesCount++;
2203
2204        float left = points[i] - halfWidth;
2205        float right = points[i] + halfWidth;
2206        float top = points[i + 1] - halfWidth;
2207        float bottom = points [i + 1] + halfWidth;
2208
2209        dirtyLayer(left, top, right, bottom, *mSnapshot->transform);
2210    }
2211
2212    glDrawArrays(GL_POINTS, 0, generatedVerticesCount);
2213
2214    return DrawGlInfo::kStatusDrew;
2215}
2216
2217status_t OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) {
2218    // No need to check against the clip, we fill the clip region
2219    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
2220
2221    Rect& clip(*mSnapshot->clipRect);
2222    clip.snapToPixelBoundaries();
2223
2224    drawColorRect(clip.left, clip.top, clip.right, clip.bottom, color, mode, true);
2225
2226    return DrawGlInfo::kStatusDrew;
2227}
2228
2229status_t OpenGLRenderer::drawShape(float left, float top, const PathTexture* texture,
2230        SkPaint* paint) {
2231    if (!texture) return DrawGlInfo::kStatusDone;
2232    const AutoTexture autoCleanup(texture);
2233
2234    const float x = left + texture->left - texture->offset;
2235    const float y = top + texture->top - texture->offset;
2236
2237    drawPathTexture(texture, x, y, paint);
2238
2239    return DrawGlInfo::kStatusDrew;
2240}
2241
2242status_t OpenGLRenderer::drawRoundRect(float left, float top, float right, float bottom,
2243        float rx, float ry, SkPaint* paint) {
2244    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
2245
2246    mCaches.activeTexture(0);
2247    const PathTexture* texture = mCaches.roundRectShapeCache.getRoundRect(
2248            right - left, bottom - top, rx, ry, paint);
2249    return drawShape(left, top, texture, paint);
2250}
2251
2252status_t OpenGLRenderer::drawCircle(float x, float y, float radius, SkPaint* paint) {
2253    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
2254
2255    mCaches.activeTexture(0);
2256    const PathTexture* texture = mCaches.circleShapeCache.getCircle(radius, paint);
2257    return drawShape(x - radius, y - radius, texture, paint);
2258}
2259
2260status_t OpenGLRenderer::drawOval(float left, float top, float right, float bottom,
2261        SkPaint* paint) {
2262    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
2263
2264    mCaches.activeTexture(0);
2265    const PathTexture* texture = mCaches.ovalShapeCache.getOval(right - left, bottom - top, paint);
2266    return drawShape(left, top, texture, paint);
2267}
2268
2269status_t OpenGLRenderer::drawArc(float left, float top, float right, float bottom,
2270        float startAngle, float sweepAngle, bool useCenter, SkPaint* paint) {
2271    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
2272
2273    if (fabs(sweepAngle) >= 360.0f) {
2274        return drawOval(left, top, right, bottom, paint);
2275    }
2276
2277    mCaches.activeTexture(0);
2278    const PathTexture* texture = mCaches.arcShapeCache.getArc(right - left, bottom - top,
2279            startAngle, sweepAngle, useCenter, paint);
2280    return drawShape(left, top, texture, paint);
2281}
2282
2283status_t OpenGLRenderer::drawRectAsShape(float left, float top, float right, float bottom,
2284        SkPaint* paint) {
2285    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
2286
2287    mCaches.activeTexture(0);
2288    const PathTexture* texture = mCaches.rectShapeCache.getRect(right - left, bottom - top, paint);
2289    return drawShape(left, top, texture, paint);
2290}
2291
2292status_t OpenGLRenderer::drawRect(float left, float top, float right, float bottom, SkPaint* p) {
2293    if (p->getStyle() != SkPaint::kFill_Style) {
2294        return drawRectAsShape(left, top, right, bottom, p);
2295    }
2296
2297    if (quickReject(left, top, right, bottom)) {
2298        return DrawGlInfo::kStatusDone;
2299    }
2300
2301    SkXfermode::Mode mode;
2302    if (!mCaches.extensions.hasFramebufferFetch()) {
2303        const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode);
2304        if (!isMode) {
2305            // Assume SRC_OVER
2306            mode = SkXfermode::kSrcOver_Mode;
2307        }
2308    } else {
2309        mode = getXfermode(p->getXfermode());
2310    }
2311
2312    int color = p->getColor();
2313    if (p->isAntiAlias() && !mSnapshot->transform->isSimple()) {
2314        drawAARect(left, top, right, bottom, color, mode);
2315    } else {
2316        drawColorRect(left, top, right, bottom, color, mode);
2317    }
2318
2319    return DrawGlInfo::kStatusDrew;
2320}
2321
2322void OpenGLRenderer::drawTextShadow(SkPaint* paint, const char* text, int bytesCount, int count,
2323        const float* positions, FontRenderer& fontRenderer, int alpha, SkXfermode::Mode mode,
2324        float x, float y) {
2325    mCaches.activeTexture(0);
2326
2327    // NOTE: The drop shadow will not perform gamma correction
2328    //       if shader-based correction is enabled
2329    mCaches.dropShadowCache.setFontRenderer(fontRenderer);
2330    const ShadowTexture* shadow = mCaches.dropShadowCache.get(
2331            paint, text, bytesCount, count, mShadowRadius, positions);
2332    const AutoTexture autoCleanup(shadow);
2333
2334    const float sx = x - shadow->left + mShadowDx;
2335    const float sy = y - shadow->top + mShadowDy;
2336
2337    const int shadowAlpha = ((mShadowColor >> 24) & 0xFF) * mSnapshot->alpha;
2338    int shadowColor = mShadowColor;
2339    if (mShader) {
2340        shadowColor = 0xffffffff;
2341    }
2342
2343    setupDraw();
2344    setupDrawWithTexture(true);
2345    setupDrawAlpha8Color(shadowColor, shadowAlpha < 255 ? shadowAlpha : alpha);
2346    setupDrawColorFilter();
2347    setupDrawShader();
2348    setupDrawBlending(true, mode);
2349    setupDrawProgram();
2350    setupDrawModelView(sx, sy, sx + shadow->width, sy + shadow->height);
2351    setupDrawTexture(shadow->id);
2352    setupDrawPureColorUniforms();
2353    setupDrawColorFilterUniforms();
2354    setupDrawShaderUniforms();
2355    setupDrawMesh(NULL, (GLvoid*) gMeshTextureOffset);
2356
2357    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
2358}
2359
2360status_t OpenGLRenderer::drawPosText(const char* text, int bytesCount, int count,
2361        const float* positions, SkPaint* paint) {
2362    if (text == NULL || count == 0 || mSnapshot->isIgnored() ||
2363            (paint->getAlpha() * mSnapshot->alpha == 0 && paint->getXfermode() == NULL)) {
2364        return DrawGlInfo::kStatusDone;
2365    }
2366
2367    // NOTE: Skia does not support perspective transform on drawPosText yet
2368    if (!mSnapshot->transform->isSimple()) {
2369        return DrawGlInfo::kStatusDone;
2370    }
2371
2372    float x = 0.0f;
2373    float y = 0.0f;
2374    const bool pureTranslate = mSnapshot->transform->isPureTranslate();
2375    if (pureTranslate) {
2376        x = (int) floorf(x + mSnapshot->transform->getTranslateX() + 0.5f);
2377        y = (int) floorf(y + mSnapshot->transform->getTranslateY() + 0.5f);
2378    }
2379
2380    FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
2381    fontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()),
2382            paint->getTextSize());
2383
2384    int alpha;
2385    SkXfermode::Mode mode;
2386    getAlphaAndMode(paint, &alpha, &mode);
2387
2388    if (CC_UNLIKELY(mHasShadow)) {
2389        drawTextShadow(paint, text, bytesCount, count, positions, fontRenderer, alpha, mode,
2390                0.0f, 0.0f);
2391    }
2392
2393    // Pick the appropriate texture filtering
2394    bool linearFilter = mSnapshot->transform->changesBounds();
2395    if (pureTranslate && !linearFilter) {
2396        linearFilter = fabs(y - (int) y) > 0.0f || fabs(x - (int) x) > 0.0f;
2397    }
2398
2399    mCaches.activeTexture(0);
2400    setupDraw();
2401    setupDrawTextGamma(paint);
2402    setupDrawDirtyRegionsDisabled();
2403    setupDrawWithTexture(true);
2404    setupDrawAlpha8Color(paint->getColor(), alpha);
2405    setupDrawColorFilter();
2406    setupDrawShader();
2407    setupDrawBlending(true, mode);
2408    setupDrawProgram();
2409    setupDrawModelView(x, y, x, y, pureTranslate, true);
2410    setupDrawTexture(fontRenderer.getTexture(linearFilter));
2411    setupDrawPureColorUniforms();
2412    setupDrawColorFilterUniforms();
2413    setupDrawShaderUniforms(pureTranslate);
2414    setupDrawTextGammaUniforms();
2415
2416    const Rect* clip = pureTranslate ? mSnapshot->clipRect : &mSnapshot->getLocalClip();
2417    Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
2418
2419    const bool hasActiveLayer = hasLayer();
2420
2421    if (fontRenderer.renderPosText(paint, clip, text, 0, bytesCount, count, x, y,
2422            positions, hasActiveLayer ? &bounds : NULL)) {
2423        if (hasActiveLayer) {
2424            if (!pureTranslate) {
2425                mSnapshot->transform->mapRect(bounds);
2426            }
2427            dirtyLayerUnchecked(bounds, getRegion());
2428        }
2429    }
2430
2431    return DrawGlInfo::kStatusDrew;
2432}
2433
2434status_t OpenGLRenderer::drawText(const char* text, int bytesCount, int count,
2435        float x, float y, const float* positions, SkPaint* paint, float length) {
2436    if (text == NULL || count == 0 || mSnapshot->isIgnored() ||
2437            (paint->getAlpha() * mSnapshot->alpha == 0 && paint->getXfermode() == NULL)) {
2438        return DrawGlInfo::kStatusDone;
2439    }
2440
2441    if (length < 0.0f) length = paint->measureText(text, bytesCount);
2442    switch (paint->getTextAlign()) {
2443        case SkPaint::kCenter_Align:
2444            x -= length / 2.0f;
2445            break;
2446        case SkPaint::kRight_Align:
2447            x -= length;
2448            break;
2449        default:
2450            break;
2451    }
2452
2453    SkPaint::FontMetrics metrics;
2454    paint->getFontMetrics(&metrics, 0.0f);
2455    if (quickReject(x, y + metrics.fTop, x + length, y + metrics.fBottom)) {
2456        return DrawGlInfo::kStatusDone;
2457    }
2458
2459    const float oldX = x;
2460    const float oldY = y;
2461    const bool pureTranslate = mSnapshot->transform->isPureTranslate();
2462    if (CC_LIKELY(pureTranslate)) {
2463        x = (int) floorf(x + mSnapshot->transform->getTranslateX() + 0.5f);
2464        y = (int) floorf(y + mSnapshot->transform->getTranslateY() + 0.5f);
2465    }
2466
2467#if DEBUG_GLYPHS
2468    ALOGD("OpenGLRenderer drawText() with FontID=%d",
2469            SkTypeface::UniqueID(paint->getTypeface()));
2470#endif
2471
2472    FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
2473    fontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()),
2474            paint->getTextSize());
2475
2476    int alpha;
2477    SkXfermode::Mode mode;
2478    getAlphaAndMode(paint, &alpha, &mode);
2479
2480    if (CC_UNLIKELY(mHasShadow)) {
2481        drawTextShadow(paint, text, bytesCount, count, positions, fontRenderer, alpha, mode,
2482                oldX, oldY);
2483    }
2484
2485    // Pick the appropriate texture filtering
2486    bool linearFilter = mSnapshot->transform->changesBounds();
2487    if (pureTranslate && !linearFilter) {
2488        linearFilter = fabs(y - (int) y) > 0.0f || fabs(x - (int) x) > 0.0f;
2489    }
2490
2491    // The font renderer will always use texture unit 0
2492    mCaches.activeTexture(0);
2493    setupDraw();
2494    setupDrawTextGamma(paint);
2495    setupDrawDirtyRegionsDisabled();
2496    setupDrawWithTexture(true);
2497    setupDrawAlpha8Color(paint->getColor(), alpha);
2498    setupDrawColorFilter();
2499    setupDrawShader();
2500    setupDrawBlending(true, mode);
2501    setupDrawProgram();
2502    setupDrawModelView(x, y, x, y, pureTranslate, true);
2503    // See comment above; the font renderer must use texture unit 0
2504    // assert(mTextureUnit == 0)
2505    setupDrawTexture(fontRenderer.getTexture(linearFilter));
2506    setupDrawPureColorUniforms();
2507    setupDrawColorFilterUniforms();
2508    setupDrawShaderUniforms(pureTranslate);
2509    setupDrawTextGammaUniforms();
2510
2511    const Rect* clip = pureTranslate ? mSnapshot->clipRect : &mSnapshot->getLocalClip();
2512    Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
2513
2514    const bool hasActiveLayer = hasLayer();
2515
2516    bool status;
2517    if (paint->getTextAlign() != SkPaint::kLeft_Align) {
2518        SkPaint paintCopy(*paint);
2519        paintCopy.setTextAlign(SkPaint::kLeft_Align);
2520        status = fontRenderer.renderPosText(&paintCopy, clip, text, 0, bytesCount, count, x, y,
2521            positions, hasActiveLayer ? &bounds : NULL);
2522    } else {
2523        status = fontRenderer.renderPosText(paint, clip, text, 0, bytesCount, count, x, y,
2524            positions, hasActiveLayer ? &bounds : NULL);
2525    }
2526
2527    if (status && hasActiveLayer) {
2528        if (!pureTranslate) {
2529            mSnapshot->transform->mapRect(bounds);
2530        }
2531        dirtyLayerUnchecked(bounds, getRegion());
2532    }
2533
2534    drawTextDecorations(text, bytesCount, length, oldX, oldY, paint);
2535
2536    return DrawGlInfo::kStatusDrew;
2537}
2538
2539status_t OpenGLRenderer::drawTextOnPath(const char* text, int bytesCount, int count, SkPath* path,
2540        float hOffset, float vOffset, SkPaint* paint) {
2541    if (text == NULL || count == 0 || mSnapshot->isIgnored() ||
2542            (paint->getAlpha() == 0 && paint->getXfermode() == NULL)) {
2543        return DrawGlInfo::kStatusDone;
2544    }
2545
2546    FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
2547    fontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()),
2548            paint->getTextSize());
2549
2550    int alpha;
2551    SkXfermode::Mode mode;
2552    getAlphaAndMode(paint, &alpha, &mode);
2553
2554    mCaches.activeTexture(0);
2555    setupDraw();
2556    setupDrawTextGamma(paint);
2557    setupDrawDirtyRegionsDisabled();
2558    setupDrawWithTexture(true);
2559    setupDrawAlpha8Color(paint->getColor(), alpha);
2560    setupDrawColorFilter();
2561    setupDrawShader();
2562    setupDrawBlending(true, mode);
2563    setupDrawProgram();
2564    setupDrawModelView(0.0f, 0.0f, 0.0f, 0.0f, false, true);
2565    setupDrawTexture(fontRenderer.getTexture(true));
2566    setupDrawPureColorUniforms();
2567    setupDrawColorFilterUniforms();
2568    setupDrawShaderUniforms(false);
2569    setupDrawTextGammaUniforms();
2570
2571    const Rect* clip = &mSnapshot->getLocalClip();
2572    Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
2573
2574    const bool hasActiveLayer = hasLayer();
2575
2576    if (fontRenderer.renderTextOnPath(paint, clip, text, 0, bytesCount, count, path,
2577            hOffset, vOffset, hasActiveLayer ? &bounds : NULL)) {
2578        if (hasActiveLayer) {
2579            mSnapshot->transform->mapRect(bounds);
2580            dirtyLayerUnchecked(bounds, getRegion());
2581        }
2582    }
2583
2584    return DrawGlInfo::kStatusDrew;
2585}
2586
2587status_t OpenGLRenderer::drawPath(SkPath* path, SkPaint* paint) {
2588    if (mSnapshot->isIgnored()) return DrawGlInfo::kStatusDone;
2589
2590    mCaches.activeTexture(0);
2591
2592    // TODO: Perform early clip test before we rasterize the path
2593    const PathTexture* texture = mCaches.pathCache.get(path, paint);
2594    if (!texture) return DrawGlInfo::kStatusDone;
2595    const AutoTexture autoCleanup(texture);
2596
2597    const float x = texture->left - texture->offset;
2598    const float y = texture->top - texture->offset;
2599
2600    drawPathTexture(texture, x, y, paint);
2601
2602    return DrawGlInfo::kStatusDrew;
2603}
2604
2605status_t OpenGLRenderer::drawLayer(Layer* layer, float x, float y, SkPaint* paint) {
2606    if (!layer) {
2607        return DrawGlInfo::kStatusDone;
2608    }
2609
2610    Rect transformed;
2611    Rect clip;
2612    const bool rejected = quickRejectNoScissor(x, y,
2613            x + layer->layer.getWidth(), y + layer->layer.getHeight(), transformed, clip);
2614
2615    if (rejected) {
2616        return DrawGlInfo::kStatusDone;
2617    }
2618
2619    bool debugLayerUpdate = false;
2620    if (layer->deferredUpdateScheduled && layer->renderer && layer->displayList) {
2621        OpenGLRenderer* renderer = layer->renderer;
2622        Rect& dirty = layer->dirtyRect;
2623
2624        renderer->setViewport(layer->layer.getWidth(), layer->layer.getHeight());
2625        renderer->prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, !layer->isBlend());
2626        renderer->drawDisplayList(layer->displayList, dirty, DisplayList::kReplayFlag_ClipChildren);
2627        renderer->finish();
2628
2629        resumeAfterLayer();
2630
2631        dirty.setEmpty();
2632        layer->deferredUpdateScheduled = false;
2633        layer->renderer = NULL;
2634        layer->displayList = NULL;
2635
2636        debugLayerUpdate = mCaches.debugLayersUpdates;
2637    }
2638
2639    mCaches.setScissorEnabled(!clip.contains(transformed));
2640    mCaches.activeTexture(0);
2641
2642    if (CC_LIKELY(!layer->region.isEmpty())) {
2643        if (layer->region.isRect()) {
2644            composeLayerRect(layer, layer->regionRect);
2645        } else if (layer->mesh) {
2646            const float a = layer->getAlpha() / 255.0f;
2647            SkiaColorFilter *oldFilter = mColorFilter;
2648            mColorFilter = layer->getColorFilter();
2649
2650            setupDraw();
2651            setupDrawWithTexture();
2652            setupDrawColor(a, a, a, a);
2653            setupDrawColorFilter();
2654            setupDrawBlending(layer->isBlend() || a < 1.0f, layer->getMode(), false);
2655            setupDrawProgram();
2656            setupDrawPureColorUniforms();
2657            setupDrawColorFilterUniforms();
2658            setupDrawTexture(layer->getTexture());
2659            if (CC_LIKELY(mSnapshot->transform->isPureTranslate())) {
2660                int tx = (int) floorf(x + mSnapshot->transform->getTranslateX() + 0.5f);
2661                int ty = (int) floorf(y + mSnapshot->transform->getTranslateY() + 0.5f);
2662
2663                layer->setFilter(GL_NEAREST);
2664                setupDrawModelViewTranslate(tx, ty,
2665                        tx + layer->layer.getWidth(), ty + layer->layer.getHeight(), true);
2666            } else {
2667                layer->setFilter(GL_LINEAR);
2668                setupDrawModelViewTranslate(x, y,
2669                        x + layer->layer.getWidth(), y + layer->layer.getHeight());
2670            }
2671            setupDrawMesh(&layer->mesh[0].position[0], &layer->mesh[0].texture[0]);
2672
2673            glDrawElements(GL_TRIANGLES, layer->meshElementCount,
2674                    GL_UNSIGNED_SHORT, layer->meshIndices);
2675
2676            finishDrawTexture();
2677
2678            mColorFilter = oldFilter;
2679
2680#if DEBUG_LAYERS_AS_REGIONS
2681            drawRegionRects(layer->region);
2682#endif
2683        }
2684
2685        if (debugLayerUpdate) {
2686            drawColorRect(x, y, x + layer->layer.getWidth(), y + layer->layer.getHeight(),
2687                    0x7f00ff00, SkXfermode::kSrcOver_Mode);
2688        }
2689    }
2690
2691    return DrawGlInfo::kStatusDrew;
2692}
2693
2694///////////////////////////////////////////////////////////////////////////////
2695// Shaders
2696///////////////////////////////////////////////////////////////////////////////
2697
2698void OpenGLRenderer::resetShader() {
2699    mShader = NULL;
2700}
2701
2702void OpenGLRenderer::setupShader(SkiaShader* shader) {
2703    mShader = shader;
2704    if (mShader) {
2705        mShader->set(&mCaches.textureCache, &mCaches.gradientCache);
2706    }
2707}
2708
2709///////////////////////////////////////////////////////////////////////////////
2710// Color filters
2711///////////////////////////////////////////////////////////////////////////////
2712
2713void OpenGLRenderer::resetColorFilter() {
2714    mColorFilter = NULL;
2715}
2716
2717void OpenGLRenderer::setupColorFilter(SkiaColorFilter* filter) {
2718    mColorFilter = filter;
2719}
2720
2721///////////////////////////////////////////////////////////////////////////////
2722// Drop shadow
2723///////////////////////////////////////////////////////////////////////////////
2724
2725void OpenGLRenderer::resetShadow() {
2726    mHasShadow = false;
2727}
2728
2729void OpenGLRenderer::setupShadow(float radius, float dx, float dy, int color) {
2730    mHasShadow = true;
2731    mShadowRadius = radius;
2732    mShadowDx = dx;
2733    mShadowDy = dy;
2734    mShadowColor = color;
2735}
2736
2737///////////////////////////////////////////////////////////////////////////////
2738// Draw filters
2739///////////////////////////////////////////////////////////////////////////////
2740
2741void OpenGLRenderer::resetPaintFilter() {
2742    mHasDrawFilter = false;
2743}
2744
2745void OpenGLRenderer::setupPaintFilter(int clearBits, int setBits) {
2746    mHasDrawFilter = true;
2747    mPaintFilterClearBits = clearBits & SkPaint::kAllFlags;
2748    mPaintFilterSetBits = setBits & SkPaint::kAllFlags;
2749}
2750
2751SkPaint* OpenGLRenderer::filterPaint(SkPaint* paint) {
2752    if (CC_LIKELY(!mHasDrawFilter || !paint)) return paint;
2753
2754    uint32_t flags = paint->getFlags();
2755
2756    mFilteredPaint = *paint;
2757    mFilteredPaint.setFlags((flags & ~mPaintFilterClearBits) | mPaintFilterSetBits);
2758
2759    return &mFilteredPaint;
2760}
2761
2762///////////////////////////////////////////////////////////////////////////////
2763// Drawing implementation
2764///////////////////////////////////////////////////////////////////////////////
2765
2766void OpenGLRenderer::drawPathTexture(const PathTexture* texture,
2767        float x, float y, SkPaint* paint) {
2768    if (quickReject(x, y, x + texture->width, y + texture->height)) {
2769        return;
2770    }
2771
2772    int alpha;
2773    SkXfermode::Mode mode;
2774    getAlphaAndMode(paint, &alpha, &mode);
2775
2776    setupDraw();
2777    setupDrawWithTexture(true);
2778    setupDrawAlpha8Color(paint->getColor(), alpha);
2779    setupDrawColorFilter();
2780    setupDrawShader();
2781    setupDrawBlending(true, mode);
2782    setupDrawProgram();
2783    setupDrawModelView(x, y, x + texture->width, y + texture->height);
2784    setupDrawTexture(texture->id);
2785    setupDrawPureColorUniforms();
2786    setupDrawColorFilterUniforms();
2787    setupDrawShaderUniforms();
2788    setupDrawMesh(NULL, (GLvoid*) gMeshTextureOffset);
2789
2790    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
2791
2792    finishDrawTexture();
2793}
2794
2795// Same values used by Skia
2796#define kStdStrikeThru_Offset   (-6.0f / 21.0f)
2797#define kStdUnderline_Offset    (1.0f / 9.0f)
2798#define kStdUnderline_Thickness (1.0f / 18.0f)
2799
2800void OpenGLRenderer::drawTextDecorations(const char* text, int bytesCount, float length,
2801        float x, float y, SkPaint* paint) {
2802    // Handle underline and strike-through
2803    uint32_t flags = paint->getFlags();
2804    if (flags & (SkPaint::kUnderlineText_Flag | SkPaint::kStrikeThruText_Flag)) {
2805        SkPaint paintCopy(*paint);
2806        float underlineWidth = length;
2807        // If length is > 0.0f, we already measured the text for the text alignment
2808        if (length <= 0.0f) {
2809            underlineWidth = paintCopy.measureText(text, bytesCount);
2810        }
2811
2812        if (CC_LIKELY(underlineWidth > 0.0f)) {
2813            const float textSize = paintCopy.getTextSize();
2814            const float strokeWidth = fmax(textSize * kStdUnderline_Thickness, 1.0f);
2815
2816            const float left = x;
2817            float top = 0.0f;
2818
2819            int linesCount = 0;
2820            if (flags & SkPaint::kUnderlineText_Flag) linesCount++;
2821            if (flags & SkPaint::kStrikeThruText_Flag) linesCount++;
2822
2823            const int pointsCount = 4 * linesCount;
2824            float points[pointsCount];
2825            int currentPoint = 0;
2826
2827            if (flags & SkPaint::kUnderlineText_Flag) {
2828                top = y + textSize * kStdUnderline_Offset;
2829                points[currentPoint++] = left;
2830                points[currentPoint++] = top;
2831                points[currentPoint++] = left + underlineWidth;
2832                points[currentPoint++] = top;
2833            }
2834
2835            if (flags & SkPaint::kStrikeThruText_Flag) {
2836                top = y + textSize * kStdStrikeThru_Offset;
2837                points[currentPoint++] = left;
2838                points[currentPoint++] = top;
2839                points[currentPoint++] = left + underlineWidth;
2840                points[currentPoint++] = top;
2841            }
2842
2843            paintCopy.setStrokeWidth(strokeWidth);
2844
2845            drawLines(&points[0], pointsCount, &paintCopy);
2846        }
2847    }
2848}
2849
2850void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom,
2851        int color, SkXfermode::Mode mode, bool ignoreTransform) {
2852    // If a shader is set, preserve only the alpha
2853    if (mShader) {
2854        color |= 0x00ffffff;
2855    }
2856
2857    setupDraw();
2858    setupDrawNoTexture();
2859    setupDrawColor(color, ((color >> 24) & 0xFF) * mSnapshot->alpha);
2860    setupDrawShader();
2861    setupDrawColorFilter();
2862    setupDrawBlending(mode);
2863    setupDrawProgram();
2864    setupDrawModelView(left, top, right, bottom, ignoreTransform);
2865    setupDrawColorUniforms();
2866    setupDrawShaderUniforms(ignoreTransform);
2867    setupDrawColorFilterUniforms();
2868    setupDrawSimpleMesh();
2869
2870    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
2871}
2872
2873void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
2874        Texture* texture, SkPaint* paint) {
2875    int alpha;
2876    SkXfermode::Mode mode;
2877    getAlphaAndMode(paint, &alpha, &mode);
2878
2879    texture->setWrap(GL_CLAMP_TO_EDGE, true);
2880
2881    if (CC_LIKELY(mSnapshot->transform->isPureTranslate())) {
2882        const float x = (int) floorf(left + mSnapshot->transform->getTranslateX() + 0.5f);
2883        const float y = (int) floorf(top + mSnapshot->transform->getTranslateY() + 0.5f);
2884
2885        texture->setFilter(GL_NEAREST, true);
2886        drawTextureMesh(x, y, x + texture->width, y + texture->height, texture->id,
2887                alpha / 255.0f, mode, texture->blend, (GLvoid*) NULL,
2888                (GLvoid*) gMeshTextureOffset, GL_TRIANGLE_STRIP, gMeshCount, false, true);
2889    } else {
2890        texture->setFilter(FILTER(paint), true);
2891        drawTextureMesh(left, top, right, bottom, texture->id, alpha / 255.0f, mode,
2892                texture->blend, (GLvoid*) NULL, (GLvoid*) gMeshTextureOffset,
2893                GL_TRIANGLE_STRIP, gMeshCount);
2894    }
2895}
2896
2897void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
2898        GLuint texture, float alpha, SkXfermode::Mode mode, bool blend) {
2899    drawTextureMesh(left, top, right, bottom, texture, alpha, mode, blend,
2900            (GLvoid*) NULL, (GLvoid*) gMeshTextureOffset, GL_TRIANGLE_STRIP, gMeshCount);
2901}
2902
2903void OpenGLRenderer::drawTextureMesh(float left, float top, float right, float bottom,
2904        GLuint texture, float alpha, SkXfermode::Mode mode, bool blend,
2905        GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,
2906        bool swapSrcDst, bool ignoreTransform, GLuint vbo, bool ignoreScale, bool dirty) {
2907
2908    setupDraw();
2909    setupDrawWithTexture();
2910    setupDrawColor(alpha, alpha, alpha, alpha);
2911    setupDrawColorFilter();
2912    setupDrawBlending(blend, mode, swapSrcDst);
2913    setupDrawProgram();
2914    if (!dirty) {
2915        setupDrawDirtyRegionsDisabled();
2916    }
2917    if (!ignoreScale) {
2918        setupDrawModelView(left, top, right, bottom, ignoreTransform);
2919    } else {
2920        setupDrawModelViewTranslate(left, top, right, bottom, ignoreTransform);
2921    }
2922    setupDrawPureColorUniforms();
2923    setupDrawColorFilterUniforms();
2924    setupDrawTexture(texture);
2925    setupDrawMesh(vertices, texCoords, vbo);
2926
2927    glDrawArrays(drawMode, 0, elementsCount);
2928
2929    finishDrawTexture();
2930}
2931
2932void OpenGLRenderer::chooseBlending(bool blend, SkXfermode::Mode mode,
2933        ProgramDescription& description, bool swapSrcDst) {
2934    blend = blend || mode != SkXfermode::kSrcOver_Mode;
2935
2936    if (blend) {
2937        // These blend modes are not supported by OpenGL directly and have
2938        // to be implemented using shaders. Since the shader will perform
2939        // the blending, turn blending off here
2940        // If the blend mode cannot be implemented using shaders, fall
2941        // back to the default SrcOver blend mode instead
2942        if (CC_UNLIKELY(mode > SkXfermode::kScreen_Mode)) {
2943            if (CC_UNLIKELY(mCaches.extensions.hasFramebufferFetch())) {
2944                description.framebufferMode = mode;
2945                description.swapSrcDst = swapSrcDst;
2946
2947                if (mCaches.blend) {
2948                    glDisable(GL_BLEND);
2949                    mCaches.blend = false;
2950                }
2951
2952                return;
2953            } else {
2954                mode = SkXfermode::kSrcOver_Mode;
2955            }
2956        }
2957
2958        if (!mCaches.blend) {
2959            glEnable(GL_BLEND);
2960        }
2961
2962        GLenum sourceMode = swapSrcDst ? gBlendsSwap[mode].src : gBlends[mode].src;
2963        GLenum destMode = swapSrcDst ? gBlendsSwap[mode].dst : gBlends[mode].dst;
2964
2965        if (sourceMode != mCaches.lastSrcMode || destMode != mCaches.lastDstMode) {
2966            glBlendFunc(sourceMode, destMode);
2967            mCaches.lastSrcMode = sourceMode;
2968            mCaches.lastDstMode = destMode;
2969        }
2970    } else if (mCaches.blend) {
2971        glDisable(GL_BLEND);
2972    }
2973    mCaches.blend = blend;
2974}
2975
2976bool OpenGLRenderer::useProgram(Program* program) {
2977    if (!program->isInUse()) {
2978        if (mCaches.currentProgram != NULL) mCaches.currentProgram->remove();
2979        program->use();
2980        mCaches.currentProgram = program;
2981        return false;
2982    }
2983    return true;
2984}
2985
2986void OpenGLRenderer::resetDrawTextureTexCoords(float u1, float v1, float u2, float v2) {
2987    TextureVertex* v = &mMeshVertices[0];
2988    TextureVertex::setUV(v++, u1, v1);
2989    TextureVertex::setUV(v++, u2, v1);
2990    TextureVertex::setUV(v++, u1, v2);
2991    TextureVertex::setUV(v++, u2, v2);
2992}
2993
2994void OpenGLRenderer::getAlphaAndMode(SkPaint* paint, int* alpha, SkXfermode::Mode* mode) {
2995    getAlphaAndModeDirect(paint, alpha,  mode);
2996    *alpha *= mSnapshot->alpha;
2997}
2998
2999}; // namespace uirenderer
3000}; // namespace android
3001