OpenGLRenderer.cpp revision 1e45aae5de003657e5d18f74d34998f5de5db5b7 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "OpenGLRenderer"
18
19#include <stdlib.h>
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <SkCanvas.h>
24#include <SkTypeface.h>
25
26#include <cutils/properties.h>
27#include <utils/Log.h>
28
29#include "OpenGLRenderer.h"
30#include "Properties.h"
31
32namespace android {
33namespace uirenderer {
34
35///////////////////////////////////////////////////////////////////////////////
36// Defines
37///////////////////////////////////////////////////////////////////////////////
38
39#define DEFAULT_TEXTURE_CACHE_SIZE 20.0f
40#define DEFAULT_LAYER_CACHE_SIZE 6.0f
41#define DEFAULT_PATH_CACHE_SIZE 6.0f
42#define DEFAULT_PATCH_CACHE_SIZE 100
43#define DEFAULT_GRADIENT_CACHE_SIZE 0.5f
44#define DEFAULT_DROP_SHADOW_CACHE_SIZE 1.0f
45
46#define REQUIRED_TEXTURE_UNITS_COUNT 3
47
48// Converts a number of mega-bytes into bytes
49#define MB(s) s * 1024 * 1024
50
51// Generates simple and textured vertices
52#define FV(x, y, u, v) { { x, y }, { u, v } }
53
54///////////////////////////////////////////////////////////////////////////////
55// Globals
56///////////////////////////////////////////////////////////////////////////////
57
58// This array is never used directly but used as a memcpy source in the
59// OpenGLRenderer constructor
60static const TextureVertex gMeshVertices[] = {
61        FV(0.0f, 0.0f, 0.0f, 0.0f),
62        FV(1.0f, 0.0f, 1.0f, 0.0f),
63        FV(0.0f, 1.0f, 0.0f, 1.0f),
64        FV(1.0f, 1.0f, 1.0f, 1.0f)
65};
66static const GLsizei gMeshStride = sizeof(TextureVertex);
67static const GLsizei gMeshCount = 4;
68
69/**
70 * Structure mapping Skia xfermodes to OpenGL blending factors.
71 */
72struct Blender {
73    SkXfermode::Mode mode;
74    GLenum src;
75    GLenum dst;
76}; // struct Blender
77
78// In this array, the index of each Blender equals the value of the first
79// entry. For instance, gBlends[1] == gBlends[SkXfermode::kSrc_Mode]
80static const Blender gBlends[] = {
81        { SkXfermode::kClear_Mode,   GL_ZERO,                 GL_ZERO },
82        { SkXfermode::kSrc_Mode,     GL_ONE,                  GL_ZERO },
83        { SkXfermode::kDst_Mode,     GL_ZERO,                 GL_ONE },
84        { SkXfermode::kSrcOver_Mode, GL_ONE,                  GL_ONE_MINUS_SRC_ALPHA },
85        { SkXfermode::kDstOver_Mode, GL_ONE_MINUS_DST_ALPHA,  GL_ONE },
86        { SkXfermode::kSrcIn_Mode,   GL_DST_ALPHA,            GL_ZERO },
87        { SkXfermode::kDstIn_Mode,   GL_ZERO,                 GL_SRC_ALPHA },
88        { SkXfermode::kSrcOut_Mode,  GL_ONE_MINUS_DST_ALPHA,  GL_ZERO },
89        { SkXfermode::kDstOut_Mode,  GL_ZERO,                 GL_ONE_MINUS_SRC_ALPHA },
90        { SkXfermode::kSrcATop_Mode, GL_DST_ALPHA,            GL_ONE_MINUS_SRC_ALPHA },
91        { SkXfermode::kDstATop_Mode, GL_ONE_MINUS_DST_ALPHA,  GL_SRC_ALPHA },
92        { SkXfermode::kXor_Mode,     GL_ONE_MINUS_DST_ALPHA,  GL_ONE_MINUS_SRC_ALPHA }
93};
94
95static const GLenum gTextureUnits[] = {
96        GL_TEXTURE0,
97        GL_TEXTURE1,
98        GL_TEXTURE2
99};
100
101///////////////////////////////////////////////////////////////////////////////
102// Constructors/destructor
103///////////////////////////////////////////////////////////////////////////////
104
105OpenGLRenderer::OpenGLRenderer():
106        mBlend(false), mLastSrcMode(GL_ZERO), mLastDstMode(GL_ZERO),
107        mTextureCache(MB(DEFAULT_TEXTURE_CACHE_SIZE)),
108        mLayerCache(MB(DEFAULT_LAYER_CACHE_SIZE)),
109        mGradientCache(MB(DEFAULT_GRADIENT_CACHE_SIZE)),
110        mPathCache(MB(DEFAULT_PATH_CACHE_SIZE)),
111        mPatchCache(DEFAULT_PATCH_CACHE_SIZE),
112        mDropShadowCache(MB(DEFAULT_DROP_SHADOW_CACHE_SIZE)) {
113    LOGD("Create OpenGLRenderer");
114
115    char property[PROPERTY_VALUE_MAX];
116    if (property_get(PROPERTY_TEXTURE_CACHE_SIZE, property, NULL) > 0) {
117        LOGD("  Setting texture cache size to %sMB", property);
118        mTextureCache.setMaxSize(MB(atof(property)));
119    } else {
120        LOGD("  Using default texture cache size of %.2fMB", DEFAULT_TEXTURE_CACHE_SIZE);
121    }
122
123    if (property_get(PROPERTY_LAYER_CACHE_SIZE, property, NULL) > 0) {
124        LOGD("  Setting layer cache size to %sMB", property);
125        mLayerCache.setMaxSize(MB(atof(property)));
126    } else {
127        LOGD("  Using default layer cache size of %.2fMB", DEFAULT_LAYER_CACHE_SIZE);
128    }
129
130    if (property_get(PROPERTY_GRADIENT_CACHE_SIZE, property, NULL) > 0) {
131        LOGD("  Setting gradient cache size to %sMB", property);
132        mGradientCache.setMaxSize(MB(atof(property)));
133    } else {
134        LOGD("  Using default gradient cache size of %.2fMB", DEFAULT_GRADIENT_CACHE_SIZE);
135    }
136
137    if (property_get(PROPERTY_PATH_CACHE_SIZE, property, NULL) > 0) {
138        LOGD("  Setting path cache size to %sMB", property);
139        mPathCache.setMaxSize(MB(atof(property)));
140    } else {
141        LOGD("  Using default path cache size of %.2fMB", DEFAULT_PATH_CACHE_SIZE);
142    }
143
144    if (property_get(PROPERTY_DROP_SHADOW_CACHE_SIZE, property, NULL) > 0) {
145        LOGD("  Setting drop shadow cache size to %sMB", property);
146        mDropShadowCache.setMaxSize(MB(atof(property)));
147    } else {
148        LOGD("  Using default drop shadow cache size of %.2fMB", DEFAULT_DROP_SHADOW_CACHE_SIZE);
149    }
150    mDropShadowCache.setFontRenderer(mFontRenderer);
151
152    mCurrentProgram = NULL;
153    mShader = NULL;
154    mColorFilter = NULL;
155    mHasShadow = false;
156
157    memcpy(mMeshVertices, gMeshVertices, sizeof(gMeshVertices));
158
159    mFirstSnapshot = new Snapshot;
160
161    GLint maxTextureUnits;
162    glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
163    if (maxTextureUnits < REQUIRED_TEXTURE_UNITS_COUNT) {
164        LOGW("At least %d texture units are required!", REQUIRED_TEXTURE_UNITS_COUNT);
165    }
166}
167
168OpenGLRenderer::~OpenGLRenderer() {
169    LOGD("Destroy OpenGLRenderer");
170
171    mTextureCache.clear();
172    mLayerCache.clear();
173    mGradientCache.clear();
174    mPathCache.clear();
175    mPatchCache.clear();
176    mProgramCache.clear();
177    mDropShadowCache.clear();
178}
179
180///////////////////////////////////////////////////////////////////////////////
181// Setup
182///////////////////////////////////////////////////////////////////////////////
183
184void OpenGLRenderer::setViewport(int width, int height) {
185    glViewport(0, 0, width, height);
186
187    mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1);
188
189    mWidth = width;
190    mHeight = height;
191    mFirstSnapshot->height = height;
192}
193
194void OpenGLRenderer::prepare() {
195    mSnapshot = new Snapshot(mFirstSnapshot);
196    mSaveCount = 0;
197
198    glDisable(GL_SCISSOR_TEST);
199
200    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
201    glClear(GL_COLOR_BUFFER_BIT);
202
203    glEnable(GL_SCISSOR_TEST);
204    glScissor(0, 0, mWidth, mHeight);
205
206    mSnapshot->setClip(0.0f, 0.0f, mWidth, mHeight);
207}
208
209///////////////////////////////////////////////////////////////////////////////
210// State management
211///////////////////////////////////////////////////////////////////////////////
212
213int OpenGLRenderer::getSaveCount() const {
214    return mSaveCount;
215}
216
217int OpenGLRenderer::save(int flags) {
218    return saveSnapshot();
219}
220
221void OpenGLRenderer::restore() {
222    if (mSaveCount == 0) return;
223
224    if (restoreSnapshot()) {
225        setScissorFromClip();
226    }
227}
228
229void OpenGLRenderer::restoreToCount(int saveCount) {
230    if (saveCount <= 0 || saveCount > mSaveCount) return;
231
232    bool restoreClip = false;
233
234    while (mSaveCount != saveCount - 1) {
235        restoreClip |= restoreSnapshot();
236    }
237
238    if (restoreClip) {
239        setScissorFromClip();
240    }
241}
242
243int OpenGLRenderer::saveSnapshot() {
244    mSnapshot = new Snapshot(mSnapshot);
245    return ++mSaveCount;
246}
247
248bool OpenGLRenderer::restoreSnapshot() {
249    bool restoreClip = mSnapshot->flags & Snapshot::kFlagClipSet;
250    bool restoreLayer = mSnapshot->flags & Snapshot::kFlagIsLayer;
251    bool restoreOrtho = mSnapshot->flags & Snapshot::kFlagDirtyOrtho;
252
253    sp<Snapshot> current = mSnapshot;
254    sp<Snapshot> previous = mSnapshot->previous;
255
256    if (restoreOrtho) {
257        mOrthoMatrix.load(current->orthoMatrix);
258    }
259
260    if (restoreLayer) {
261        composeLayer(current, previous);
262    }
263
264    mSnapshot = previous;
265    mSaveCount--;
266
267    return restoreClip;
268}
269
270void OpenGLRenderer::composeLayer(sp<Snapshot> current, sp<Snapshot> previous) {
271    if (!current->layer) {
272        LOGE("Attempting to compose a layer that does not exist");
273        return;
274    }
275
276    // Unbind current FBO and restore previous one
277    // Most of the time, previous->fbo will be 0 to bind the default buffer
278    glBindFramebuffer(GL_FRAMEBUFFER, previous->fbo);
279
280    // Restore the clip from the previous snapshot
281    const Rect& clip = previous->clipRect;
282    glScissor(clip.left, mHeight - clip.bottom, clip.getWidth(), clip.getHeight());
283
284    Layer* layer = current->layer;
285    const Rect& rect = layer->layer;
286
287    drawTextureRect(rect.left, rect.top, rect.right, rect.bottom,
288            layer->texture, layer->alpha, layer->mode, layer->blend);
289
290    LayerSize size(rect.getWidth(), rect.getHeight());
291    // Failing to add the layer to the cache should happen only if the
292    // layer is too large
293    if (!mLayerCache.put(size, layer)) {
294        LAYER_LOGD("Deleting layer");
295
296        glDeleteFramebuffers(1, &layer->fbo);
297        glDeleteTextures(1, &layer->texture);
298
299        delete layer;
300    }
301}
302
303///////////////////////////////////////////////////////////////////////////////
304// Layers
305///////////////////////////////////////////////////////////////////////////////
306
307int OpenGLRenderer::saveLayer(float left, float top, float right, float bottom,
308        const SkPaint* p, int flags) {
309    int count = saveSnapshot();
310
311    int alpha = 255;
312    SkXfermode::Mode mode;
313
314    if (p) {
315        alpha = p->getAlpha();
316        const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode);
317        if (!isMode) {
318            // Assume SRC_OVER
319            mode = SkXfermode::kSrcOver_Mode;
320        }
321    } else {
322        mode = SkXfermode::kSrcOver_Mode;
323    }
324
325    createLayer(mSnapshot, left, top, right, bottom, alpha, mode, flags);
326
327    return count;
328}
329
330int OpenGLRenderer::saveLayerAlpha(float left, float top, float right, float bottom,
331        int alpha, int flags) {
332    int count = saveSnapshot();
333    createLayer(mSnapshot, left, top, right, bottom, alpha, SkXfermode::kSrcOver_Mode, flags);
334    return count;
335}
336
337bool OpenGLRenderer::createLayer(sp<Snapshot> snapshot, float left, float top,
338        float right, float bottom, int alpha, SkXfermode::Mode mode,int flags) {
339    LAYER_LOGD("Requesting layer %fx%f", right - left, bottom - top);
340    LAYER_LOGD("Layer cache size = %d", mLayerCache.getSize());
341
342    GLuint previousFbo = snapshot->previous.get() ? snapshot->previous->fbo : 0;
343    LayerSize size(right - left, bottom - top);
344
345    Layer* layer = mLayerCache.get(size, previousFbo);
346    if (!layer) {
347        return false;
348    }
349
350    glBindFramebuffer(GL_FRAMEBUFFER, layer->fbo);
351
352    // Clear the FBO
353    glDisable(GL_SCISSOR_TEST);
354    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
355    glClear(GL_COLOR_BUFFER_BIT);
356    glEnable(GL_SCISSOR_TEST);
357
358    // Save the layer in the snapshot
359    snapshot->flags |= Snapshot::kFlagIsLayer;
360    layer->mode = mode;
361    layer->alpha = alpha / 255.0f;
362    layer->layer.set(left, top, right, bottom);
363
364    snapshot->layer = layer;
365    snapshot->fbo = layer->fbo;
366
367    // Creates a new snapshot to draw into the FBO
368    saveSnapshot();
369    // TODO: This doesn't preserve other transformations (check Skia first)
370    mSnapshot->transform.loadTranslate(-left, -top, 0.0f);
371    mSnapshot->setClip(0.0f, 0.0f, right - left, bottom - top);
372    mSnapshot->height = bottom - top;
373    setScissorFromClip();
374
375    mSnapshot->flags = Snapshot::kFlagDirtyOrtho | Snapshot::kFlagClipSet;
376    mSnapshot->orthoMatrix.load(mOrthoMatrix);
377
378    // Change the ortho projection
379    mOrthoMatrix.loadOrtho(0.0f, right - left, bottom - top, 0.0f, 0.0f, 1.0f);
380
381    return true;
382}
383
384///////////////////////////////////////////////////////////////////////////////
385// Transforms
386///////////////////////////////////////////////////////////////////////////////
387
388void OpenGLRenderer::translate(float dx, float dy) {
389    mSnapshot->transform.translate(dx, dy, 0.0f);
390}
391
392void OpenGLRenderer::rotate(float degrees) {
393    mSnapshot->transform.rotate(degrees, 0.0f, 0.0f, 1.0f);
394}
395
396void OpenGLRenderer::scale(float sx, float sy) {
397    mSnapshot->transform.scale(sx, sy, 1.0f);
398}
399
400void OpenGLRenderer::setMatrix(SkMatrix* matrix) {
401    mSnapshot->transform.load(*matrix);
402}
403
404void OpenGLRenderer::getMatrix(SkMatrix* matrix) {
405    mSnapshot->transform.copyTo(*matrix);
406}
407
408void OpenGLRenderer::concatMatrix(SkMatrix* matrix) {
409    mat4 m(*matrix);
410    mSnapshot->transform.multiply(m);
411}
412
413///////////////////////////////////////////////////////////////////////////////
414// Clipping
415///////////////////////////////////////////////////////////////////////////////
416
417void OpenGLRenderer::setScissorFromClip() {
418    const Rect& clip = mSnapshot->clipRect;
419    glScissor(clip.left, mSnapshot->height - clip.bottom, clip.getWidth(), clip.getHeight());
420}
421
422const Rect& OpenGLRenderer::getClipBounds() {
423    return mSnapshot->getLocalClip();
424}
425
426bool OpenGLRenderer::quickReject(float left, float top, float right, float bottom) {
427    SkRect sr;
428    sr.set(left, top, right, bottom);
429
430    SkMatrix m;
431    mSnapshot->transform.copyTo(m);
432    m.mapRect(&sr);
433
434    Rect r(sr.fLeft, sr.fTop, sr.fRight, sr.fBottom);
435    return !mSnapshot->clipRect.intersects(r);
436}
437
438bool OpenGLRenderer::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {
439    bool clipped = mSnapshot->clip(left, top, right, bottom, op);
440    if (clipped) {
441        setScissorFromClip();
442    }
443    return !mSnapshot->clipRect.isEmpty();
444}
445
446///////////////////////////////////////////////////////////////////////////////
447// Drawing
448///////////////////////////////////////////////////////////////////////////////
449
450void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, const SkPaint* paint) {
451    const float right = left + bitmap->width();
452    const float bottom = top + bitmap->height();
453
454    if (quickReject(left, top, right, bottom)) {
455        return;
456    }
457
458    glActiveTexture(GL_TEXTURE0);
459    const Texture* texture = mTextureCache.get(bitmap);
460    if (!texture) return;
461    const AutoTexture autoCleanup(texture);
462
463    drawTextureRect(left, top, right, bottom, texture, paint);
464}
465
466void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, const SkMatrix* matrix, const SkPaint* paint) {
467    Rect r(0.0f, 0.0f, bitmap->width(), bitmap->height());
468    const mat4 transform(*matrix);
469    transform.mapRect(r);
470
471    if (quickReject(r.left, r.top, r.right, r.bottom)) {
472        return;
473    }
474
475    glActiveTexture(GL_TEXTURE0);
476    const Texture* texture = mTextureCache.get(bitmap);
477    if (!texture) return;
478    const AutoTexture autoCleanup(texture);
479
480    drawTextureRect(r.left, r.top, r.right, r.bottom, texture, paint);
481}
482
483void OpenGLRenderer::drawBitmap(SkBitmap* bitmap,
484         float srcLeft, float srcTop, float srcRight, float srcBottom,
485         float dstLeft, float dstTop, float dstRight, float dstBottom,
486         const SkPaint* paint) {
487    if (quickReject(dstLeft, dstTop, dstRight, dstBottom)) {
488        return;
489    }
490
491    glActiveTexture(GL_TEXTURE0);
492    const Texture* texture = mTextureCache.get(bitmap);
493    if (!texture) return;
494    const AutoTexture autoCleanup(texture);
495
496    const float width = texture->width;
497    const float height = texture->height;
498
499    const float u1 = srcLeft / width;
500    const float v1 = srcTop / height;
501    const float u2 = srcRight / width;
502    const float v2 = srcBottom / height;
503
504    resetDrawTextureTexCoords(u1, v1, u2, v2);
505
506    drawTextureRect(dstLeft, dstTop, dstRight, dstBottom, texture, paint);
507
508    resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
509}
510
511void OpenGLRenderer::drawPatch(SkBitmap* bitmap, Res_png_9patch* patch,
512        float left, float top, float right, float bottom, const SkPaint* paint) {
513    if (quickReject(left, top, right, bottom)) {
514        return;
515    }
516
517    glActiveTexture(GL_TEXTURE0);
518    const Texture* texture = mTextureCache.get(bitmap);
519    if (!texture) return;
520    const AutoTexture autoCleanup(texture);
521
522    int alpha;
523    SkXfermode::Mode mode;
524    getAlphaAndMode(paint, &alpha, &mode);
525
526    Patch* mesh = mPatchCache.get(patch);
527    mesh->updateVertices(bitmap, left, top, right, bottom,
528            &patch->xDivs[0], &patch->yDivs[0], patch->numXDivs, patch->numYDivs);
529
530    // Specify right and bottom as +1.0f from left/top to prevent scaling since the
531    // patch mesh already defines the final size
532    drawTextureMesh(left, top, left + 1.0f, top + 1.0f, texture->id, alpha / 255.0f,
533            mode, texture->blend, &mesh->vertices[0].position[0],
534            &mesh->vertices[0].texture[0], mesh->indices, mesh->indicesCount);
535}
536
537void OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) {
538    const Rect& clip = mSnapshot->clipRect;
539    drawColorRect(clip.left, clip.top, clip.right, clip.bottom, color, mode, true);
540}
541
542void OpenGLRenderer::drawRect(float left, float top, float right, float bottom, const SkPaint* p) {
543    if (quickReject(left, top, right, bottom)) {
544        return;
545    }
546
547    SkXfermode::Mode mode;
548
549    const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode);
550    if (!isMode) {
551        // Assume SRC_OVER
552        mode = SkXfermode::kSrcOver_Mode;
553    }
554
555    // Skia draws using the color's alpha channel if < 255
556    // Otherwise, it uses the paint's alpha
557    int color = p->getColor();
558    if (((color >> 24) & 0xff) == 255) {
559        color |= p->getAlpha() << 24;
560    }
561
562    drawColorRect(left, top, right, bottom, color, mode);
563}
564
565void OpenGLRenderer::renderShadow(const ShadowTexture* texture, float x, float y,
566        SkXfermode::Mode mode) {
567    const float sx = x - texture->left + mShadowDx;
568    const float sy = y - texture->top + mShadowDy;
569
570    const GLfloat a = ((mShadowColor >> 24) & 0xFF) / 255.0f;
571    const GLfloat r = a * ((mShadowColor >> 16) & 0xFF) / 255.0f;
572    const GLfloat g = a * ((mShadowColor >>  8) & 0xFF) / 255.0f;
573    const GLfloat b = a * ((mShadowColor      ) & 0xFF) / 255.0f;
574
575    GLuint textureUnit = 0;
576    renderTextureAlpha8(texture, textureUnit, sx, sy, r, g, b, a, mode, false);
577}
578
579void OpenGLRenderer::renderTextureAlpha8(const Texture* texture, GLuint& textureUnit,
580        float x, float y, float r, float g, float b, float a, SkXfermode::Mode mode,
581        bool applyFilters) {
582     // Describe the required shaders
583     ProgramDescription description;
584     description.hasTexture = true;
585     description.hasAlpha8Texture = true;
586
587     if (applyFilters) {
588         if (mShader) {
589             mShader->describe(description, mExtensions);
590         }
591         if (mColorFilter) {
592             mColorFilter->describe(description, mExtensions);
593         }
594     }
595
596     // Build and use the appropriate shader
597     useProgram(mProgramCache.get(description));
598
599     // Setup the blending mode
600     chooseBlending(true, mode);
601     bindTexture(texture->id, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, textureUnit);
602     glUniform1i(mCurrentProgram->getUniform("sampler"), textureUnit);
603
604     int texCoordsSlot = mCurrentProgram->getAttrib("texCoords");
605     glEnableVertexAttribArray(texCoordsSlot);
606
607     // Setup attributes
608     glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,
609             gMeshStride, &mMeshVertices[0].position[0]);
610     glVertexAttribPointer(texCoordsSlot, 2, GL_FLOAT, GL_FALSE,
611             gMeshStride, &mMeshVertices[0].texture[0]);
612
613     // Setup uniforms
614     mModelView.loadTranslate(x, y, 0.0f);
615     mModelView.scale(texture->width, texture->height, 1.0f);
616     mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
617
618     glUniform4f(mCurrentProgram->color, r, g, b, a);
619
620     textureUnit++;
621     if (applyFilters) {
622         // Setup attributes and uniforms required by the shaders
623         if (mShader) {
624             mShader->setupProgram(mCurrentProgram, mModelView, *mSnapshot, &textureUnit);
625         }
626         if (mColorFilter) {
627             mColorFilter->setupProgram(mCurrentProgram);
628         }
629     }
630
631     // Draw the mesh
632     glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
633
634     glDisableVertexAttribArray(texCoordsSlot);
635}
636
637#define kStdStrikeThru_Offset   (-6.0f / 21.0f)
638#define kStdUnderline_Offset    (1.0f / 9.0f)
639#define kStdUnderline_Thickness (1.0f / 18.0f)
640
641void OpenGLRenderer::drawText(const char* text, int bytesCount, int count,
642        float x, float y, SkPaint* paint) {
643    if (text == NULL || count == 0 || (paint->getAlpha() == 0 && paint->getXfermode() == NULL)) {
644        return;
645    }
646
647    float length = -1.0f;
648    switch (paint->getTextAlign()) {
649        case SkPaint::kCenter_Align:
650            length = paint->measureText(text, bytesCount);
651            x -= length / 2.0f;
652            break;
653        case SkPaint::kRight_Align:
654            length = paint->measureText(text, bytesCount);
655            x -= length;
656            break;
657        default:
658            break;
659    }
660
661    int alpha;
662    SkXfermode::Mode mode;
663    getAlphaAndMode(paint, &alpha, &mode);
664
665    mFontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()), paint->getTextSize());
666    if (mHasShadow) {
667        glActiveTexture(gTextureUnits[0]);
668        const ShadowTexture* shadow = mDropShadowCache.get(paint, text, bytesCount,
669                count, mShadowRadius);
670        const AutoTexture autoCleanup(shadow);
671        renderShadow(shadow, x, y, mode);
672    }
673
674    uint32_t color = paint->getColor();
675    const GLfloat a = alpha / 255.0f;
676    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;
677    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;
678    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;
679
680    mModelView.loadIdentity();
681
682    GLuint textureUnit = 0;
683    // Needs to be set prior to calling FontRenderer::getTexture()
684    glActiveTexture(gTextureUnits[textureUnit]);
685
686    ProgramDescription description;
687    description.hasTexture = true;
688    description.hasAlpha8Texture = true;
689    if (mShader) {
690        mShader->describe(description, mExtensions);
691    }
692    if (mColorFilter) {
693        mColorFilter->describe(description, mExtensions);
694    }
695
696    useProgram(mProgramCache.get(description));
697    mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
698
699    // Text is always blended, no need to check the shader
700    chooseBlending(true, mode);
701    bindTexture(mFontRenderer.getTexture(), GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, textureUnit);
702    glUniform1i(mCurrentProgram->getUniform("sampler"), textureUnit);
703
704    int texCoordsSlot = mCurrentProgram->getAttrib("texCoords");
705    glEnableVertexAttribArray(texCoordsSlot);
706
707    // Always premultiplied
708    glUniform4f(mCurrentProgram->color, r, g, b, a);
709
710    textureUnit++;
711    // Setup attributes and uniforms required by the shaders
712    if (mShader) {
713        mShader->setupProgram(mCurrentProgram, mModelView, *mSnapshot, &textureUnit);
714    }
715    if (mColorFilter) {
716        mColorFilter->setupProgram(mCurrentProgram);
717    }
718
719    const Rect& clip = mSnapshot->getLocalClip();
720    mFontRenderer.renderText(paint, &clip, text, 0, bytesCount, count, x, y);
721
722    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
723    glDisableVertexAttribArray(texCoordsSlot);
724
725    // Handle underline and strike-through
726    uint32_t flags = paint->getFlags();
727    if (flags & (SkPaint::kUnderlineText_Flag | SkPaint::kStrikeThruText_Flag)) {
728        float underlineWidth = length;
729        // If length is > 0.0f, we already measured the text for the text alignment
730        if (length <= 0.0f) {
731            underlineWidth = paint->measureText(text, bytesCount);
732        }
733
734        float offsetX = 0;
735        switch (paint->getTextAlign()) {
736            case SkPaint::kCenter_Align:
737                offsetX = underlineWidth * 0.5f;
738                break;
739            case SkPaint::kRight_Align:
740                offsetX = underlineWidth;
741                break;
742            default:
743                break;
744        }
745
746        if (underlineWidth > 0.0f) {
747            float textSize = paint->getTextSize();
748            float height = textSize * kStdUnderline_Thickness;
749
750            float left = x - offsetX;
751            float top = 0.0f;
752            float right = left + underlineWidth;
753            float bottom = 0.0f;
754
755            if (flags & SkPaint::kUnderlineText_Flag) {
756                top = y + textSize * kStdUnderline_Offset;
757                bottom = top + height;
758                drawRect(left, top, right, bottom, paint);
759            }
760
761            if (flags & SkPaint::kStrikeThruText_Flag) {
762                top = y + textSize * kStdStrikeThru_Offset;
763                bottom = top + height;
764                drawRect(left, top, right, bottom, paint);
765            }
766        }
767    }
768}
769
770void OpenGLRenderer::drawPath(SkPath* path, SkPaint* paint) {
771    GLuint textureUnit = 0;
772    glActiveTexture(gTextureUnits[textureUnit]);
773
774    const PathTexture* texture = mPathCache.get(path, paint);
775    if (!texture) return;
776    const AutoTexture autoCleanup(texture);
777
778    int alpha;
779    SkXfermode::Mode mode;
780    getAlphaAndMode(paint, &alpha, &mode);
781
782    uint32_t color = paint->getColor();
783    const GLfloat a = alpha / 255.0f;
784    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;
785    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;
786    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;
787
788    const float x = texture->left - texture->offset;
789    const float y = texture->top - texture->offset;
790    renderTextureAlpha8(texture, textureUnit, x, y, r, g, b, a, mode, true);
791}
792
793///////////////////////////////////////////////////////////////////////////////
794// Shaders
795///////////////////////////////////////////////////////////////////////////////
796
797void OpenGLRenderer::resetShader() {
798    mShader = NULL;
799}
800
801void OpenGLRenderer::setupShader(SkiaShader* shader) {
802    mShader = shader;
803    if (mShader) {
804        mShader->set(&mTextureCache, &mGradientCache);
805    }
806}
807
808///////////////////////////////////////////////////////////////////////////////
809// Color filters
810///////////////////////////////////////////////////////////////////////////////
811
812void OpenGLRenderer::resetColorFilter() {
813    mColorFilter = NULL;
814}
815
816void OpenGLRenderer::setupColorFilter(SkiaColorFilter* filter) {
817    mColorFilter = filter;
818}
819
820///////////////////////////////////////////////////////////////////////////////
821// Drop shadow
822///////////////////////////////////////////////////////////////////////////////
823
824void OpenGLRenderer::resetShadow() {
825    mHasShadow = false;
826}
827
828void OpenGLRenderer::setupShadow(float radius, float dx, float dy, int color) {
829    mHasShadow = true;
830    mShadowRadius = radius;
831    mShadowDx = dx;
832    mShadowDy = dy;
833    mShadowColor = color;
834}
835
836///////////////////////////////////////////////////////////////////////////////
837// Drawing implementation
838///////////////////////////////////////////////////////////////////////////////
839
840void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom,
841        int color, SkXfermode::Mode mode, bool ignoreTransform) {
842    // If a shader is set, preserve only the alpha
843    if (mShader) {
844        color |= 0x00ffffff;
845    }
846
847    // Render using pre-multiplied alpha
848    const int alpha = (color >> 24) & 0xFF;
849    const GLfloat a = alpha / 255.0f;
850    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;
851    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;
852    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;
853
854    GLuint textureUnit = 0;
855
856    // Setup the blending mode
857    chooseBlending(alpha < 255 || (mShader && mShader->blend()), mode);
858
859    // Describe the required shaders
860    ProgramDescription description;
861    if (mShader) {
862        mShader->describe(description, mExtensions);
863    }
864    if (mColorFilter) {
865        mColorFilter->describe(description, mExtensions);
866    }
867
868    // Build and use the appropriate shader
869    useProgram(mProgramCache.get(description));
870
871    // Setup attributes
872    glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,
873            gMeshStride, &mMeshVertices[0].position[0]);
874
875    // Setup uniforms
876    mModelView.loadTranslate(left, top, 0.0f);
877    mModelView.scale(right - left, bottom - top, 1.0f);
878    if (!ignoreTransform) {
879        mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
880    } else {
881        mat4 identity;
882        mCurrentProgram->set(mOrthoMatrix, mModelView, identity);
883    }
884    glUniform4f(mCurrentProgram->color, r, g, b, a);
885
886    // Setup attributes and uniforms required by the shaders
887    if (mShader) {
888        mShader->setupProgram(mCurrentProgram, mModelView, *mSnapshot, &textureUnit);
889    }
890    if (mColorFilter) {
891        mColorFilter->setupProgram(mCurrentProgram);
892    }
893
894    // Draw the mesh
895    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
896}
897
898void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
899        const Texture* texture, const SkPaint* paint) {
900    int alpha;
901    SkXfermode::Mode mode;
902    getAlphaAndMode(paint, &alpha, &mode);
903
904    drawTextureMesh(left, top, right, bottom, texture->id, alpha / 255.0f, mode, texture->blend,
905            &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0], NULL);
906}
907
908void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
909        GLuint texture, float alpha, SkXfermode::Mode mode, bool blend) {
910    drawTextureMesh(left, top, right, bottom, texture, alpha, mode, blend,
911            &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0], NULL);
912}
913
914void OpenGLRenderer::drawTextureMesh(float left, float top, float right, float bottom,
915        GLuint texture, float alpha, SkXfermode::Mode mode, bool blend,
916        GLvoid* vertices, GLvoid* texCoords, GLvoid* indices, GLsizei elementsCount) {
917    ProgramDescription description;
918    description.hasTexture = true;
919    if (mColorFilter) {
920        mColorFilter->describe(description, mExtensions);
921    }
922
923    mModelView.loadTranslate(left, top, 0.0f);
924    mModelView.scale(right - left, bottom - top, 1.0f);
925
926    useProgram(mProgramCache.get(description));
927    mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
928
929    chooseBlending(blend || alpha < 1.0f, mode);
930
931    // Texture
932    bindTexture(texture, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, 0);
933    glUniform1i(mCurrentProgram->getUniform("sampler"), 0);
934
935    // Always premultiplied
936    glUniform4f(mCurrentProgram->color, alpha, alpha, alpha, alpha);
937
938    // Mesh
939    int texCoordsSlot = mCurrentProgram->getAttrib("texCoords");
940    glEnableVertexAttribArray(texCoordsSlot);
941    glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,
942            gMeshStride, vertices);
943    glVertexAttribPointer(texCoordsSlot, 2, GL_FLOAT, GL_FALSE, gMeshStride, texCoords);
944
945    // Color filter
946    if (mColorFilter) {
947        mColorFilter->setupProgram(mCurrentProgram);
948    }
949
950    if (!indices) {
951        glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
952    } else {
953        glDrawElements(GL_TRIANGLES, elementsCount, GL_UNSIGNED_SHORT, indices);
954    }
955    glDisableVertexAttribArray(texCoordsSlot);
956}
957
958void OpenGLRenderer::chooseBlending(bool blend, SkXfermode::Mode mode, bool isPremultiplied) {
959    blend = blend || mode != SkXfermode::kSrcOver_Mode;
960    if (blend) {
961        if (!mBlend) {
962            glEnable(GL_BLEND);
963        }
964
965        GLenum sourceMode = gBlends[mode].src;
966        GLenum destMode = gBlends[mode].dst;
967        if (!isPremultiplied && sourceMode == GL_ONE) {
968            sourceMode = GL_SRC_ALPHA;
969        }
970
971        if (sourceMode != mLastSrcMode || destMode != mLastDstMode) {
972            glBlendFunc(sourceMode, destMode);
973            mLastSrcMode = sourceMode;
974            mLastDstMode = destMode;
975        }
976    } else if (mBlend) {
977        glDisable(GL_BLEND);
978    }
979    mBlend = blend;
980}
981
982bool OpenGLRenderer::useProgram(Program* program) {
983    if (!program->isInUse()) {
984        if (mCurrentProgram != NULL) mCurrentProgram->remove();
985        program->use();
986        mCurrentProgram = program;
987        return false;
988    }
989    return true;
990}
991
992void OpenGLRenderer::resetDrawTextureTexCoords(float u1, float v1, float u2, float v2) {
993    TextureVertex* v = &mMeshVertices[0];
994    TextureVertex::setUV(v++, u1, v1);
995    TextureVertex::setUV(v++, u2, v1);
996    TextureVertex::setUV(v++, u1, v2);
997    TextureVertex::setUV(v++, u2, v2);
998}
999
1000void OpenGLRenderer::getAlphaAndMode(const SkPaint* paint, int* alpha, SkXfermode::Mode* mode) {
1001    if (paint) {
1002        const bool isMode = SkXfermode::IsMode(paint->getXfermode(), mode);
1003        if (!isMode) {
1004            // Assume SRC_OVER
1005            *mode = SkXfermode::kSrcOver_Mode;
1006        }
1007
1008        // Skia draws using the color's alpha channel if < 255
1009        // Otherwise, it uses the paint's alpha
1010        int color = paint->getColor();
1011        *alpha = (color >> 24) & 0xFF;
1012        if (*alpha == 255) {
1013            *alpha = paint->getAlpha();
1014        }
1015    } else {
1016        *mode = SkXfermode::kSrcOver_Mode;
1017        *alpha = 255;
1018    }
1019}
1020
1021void OpenGLRenderer::bindTexture(GLuint texture, GLenum wrapS, GLenum wrapT, GLuint textureUnit) {
1022    glActiveTexture(gTextureUnits[textureUnit]);
1023    glBindTexture(GL_TEXTURE_2D, texture);
1024    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
1025    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);
1026}
1027
1028}; // namespace uirenderer
1029}; // namespace android
1030