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#include <GpuMemoryTracker.h>
18#include "OpenGLRenderer.h"
19
20#include "DeferredDisplayList.h"
21#include "GammaFontRenderer.h"
22#include "Glop.h"
23#include "GlopBuilder.h"
24#include "Patch.h"
25#include "PathTessellator.h"
26#include "Properties.h"
27#include "RenderNode.h"
28#include "renderstate/MeshState.h"
29#include "renderstate/RenderState.h"
30#include "ShadowTessellator.h"
31#include "SkiaShader.h"
32#include "Vector.h"
33#include "VertexBuffer.h"
34#include "hwui/Canvas.h"
35#include "utils/GLUtils.h"
36#include "utils/PaintUtils.h"
37#include "utils/TraceUtils.h"
38
39#include <stdlib.h>
40#include <stdint.h>
41#include <sys/types.h>
42
43#include <SkColor.h>
44#include <SkPaintDefaults.h>
45#include <SkPathOps.h>
46#include <SkShader.h>
47#include <SkTypeface.h>
48
49#include <utils/Log.h>
50#include <utils/StopWatch.h>
51
52#include <private/hwui/DrawGlInfo.h>
53
54#include <ui/Rect.h>
55
56#if DEBUG_DETAILED_EVENTS
57    #define EVENT_LOGD(...) eventMarkDEBUG(__VA_ARGS__)
58#else
59    #define EVENT_LOGD(...)
60#endif
61
62namespace android {
63namespace uirenderer {
64
65///////////////////////////////////////////////////////////////////////////////
66// Constructors/destructor
67///////////////////////////////////////////////////////////////////////////////
68
69OpenGLRenderer::OpenGLRenderer(RenderState& renderState)
70        : mState(*this)
71        , mCaches(Caches::getInstance())
72        , mRenderState(renderState)
73        , mFrameStarted(false)
74        , mScissorOptimizationDisabled(false)
75        , mDirty(false)
76        , mLightCenter((Vector3){FLT_MIN, FLT_MIN, FLT_MIN})
77        , mLightRadius(FLT_MIN)
78        , mAmbientShadowAlpha(0)
79        , mSpotShadowAlpha(0) {
80}
81
82OpenGLRenderer::~OpenGLRenderer() {
83    // The context has already been destroyed at this point, do not call
84    // GL APIs. All GL state should be kept in Caches.h
85}
86
87void OpenGLRenderer::initProperties() {
88    char property[PROPERTY_VALUE_MAX];
89    if (property_get(PROPERTY_DISABLE_SCISSOR_OPTIMIZATION, property, "false")) {
90        mScissorOptimizationDisabled = !strcasecmp(property, "true");
91        INIT_LOGD("  Scissor optimization %s",
92                mScissorOptimizationDisabled ? "disabled" : "enabled");
93    } else {
94        INIT_LOGD("  Scissor optimization enabled");
95    }
96}
97
98void OpenGLRenderer::initLight(float lightRadius, uint8_t ambientShadowAlpha,
99        uint8_t spotShadowAlpha) {
100    mLightRadius = lightRadius;
101    mAmbientShadowAlpha = ambientShadowAlpha;
102    mSpotShadowAlpha = spotShadowAlpha;
103}
104
105void OpenGLRenderer::setLightCenter(const Vector3& lightCenter) {
106    mLightCenter = lightCenter;
107}
108
109///////////////////////////////////////////////////////////////////////////////
110// Setup
111///////////////////////////////////////////////////////////////////////////////
112
113void OpenGLRenderer::onViewportInitialized() {
114    glDisable(GL_DITHER);
115    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
116}
117
118void OpenGLRenderer::setupFrameState(int viewportWidth, int viewportHeight,
119        float left, float top, float right, float bottom, bool opaque) {
120    mCaches.clearGarbage();
121    mState.initializeSaveStack(viewportWidth, viewportHeight,
122            left, top, right, bottom, mLightCenter);
123    mOpaque = opaque;
124    mTilingClip.set(left, top, right, bottom);
125}
126
127void OpenGLRenderer::startFrame() {
128    if (mFrameStarted) return;
129    mFrameStarted = true;
130
131    mState.setDirtyClip(true);
132
133    discardFramebuffer(mTilingClip.left, mTilingClip.top, mTilingClip.right, mTilingClip.bottom);
134
135    mRenderState.setViewport(mState.getWidth(), mState.getHeight());
136
137    debugOverdraw(true, true);
138
139    clear(mTilingClip.left, mTilingClip.top,
140            mTilingClip.right, mTilingClip.bottom, mOpaque);
141}
142
143void OpenGLRenderer::prepareDirty(int viewportWidth, int viewportHeight,
144        float left, float top, float right, float bottom, bool opaque) {
145
146    setupFrameState(viewportWidth, viewportHeight, left, top, right, bottom, opaque);
147
148    // Layer renderers will start the frame immediately
149    // The framebuffer renderer will first defer the display list
150    // for each layer and wait until the first drawing command
151    // to start the frame
152    if (currentSnapshot()->fbo == 0) {
153        mRenderState.blend().syncEnabled();
154        updateLayers();
155    } else {
156        startFrame();
157    }
158}
159
160void OpenGLRenderer::discardFramebuffer(float left, float top, float right, float bottom) {
161    // If we know that we are going to redraw the entire framebuffer,
162    // perform a discard to let the driver know we don't need to preserve
163    // the back buffer for this frame.
164    if (mCaches.extensions().hasDiscardFramebuffer() &&
165            left <= 0.0f && top <= 0.0f && right >= mState.getWidth() && bottom >= mState.getHeight()) {
166        const bool isFbo = getTargetFbo() == 0;
167        const GLenum attachments[] = {
168                isFbo ? (const GLenum) GL_COLOR_EXT : (const GLenum) GL_COLOR_ATTACHMENT0,
169                isFbo ? (const GLenum) GL_STENCIL_EXT : (const GLenum) GL_STENCIL_ATTACHMENT };
170        glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, attachments);
171    }
172}
173
174void OpenGLRenderer::clear(float left, float top, float right, float bottom, bool opaque) {
175    if (!opaque) {
176        mRenderState.scissor().setEnabled(true);
177        mRenderState.scissor().set(left, getViewportHeight() - bottom, right - left, bottom - top);
178        glClear(GL_COLOR_BUFFER_BIT);
179        mDirty = true;
180        return;
181    }
182
183    mRenderState.scissor().reset();
184}
185
186bool OpenGLRenderer::finish() {
187    renderOverdraw();
188    mTempPaths.clear();
189
190    // When finish() is invoked on FBO 0 we've reached the end
191    // of the current frame
192    if (getTargetFbo() == 0) {
193        mCaches.pathCache.trim();
194        mCaches.tessellationCache.trim();
195    }
196
197    if (!suppressErrorChecks()) {
198        GL_CHECKPOINT(MODERATE);
199
200#if DEBUG_MEMORY_USAGE
201        mCaches.dumpMemoryUsage();
202        GPUMemoryTracker::dump();
203#else
204        if (Properties::debugLevel & kDebugMemory) {
205            mCaches.dumpMemoryUsage();
206        }
207#endif
208    }
209
210    mFrameStarted = false;
211
212    return reportAndClearDirty();
213}
214
215void OpenGLRenderer::resumeAfterLayer() {
216    mRenderState.setViewport(getViewportWidth(), getViewportHeight());
217    mRenderState.bindFramebuffer(currentSnapshot()->fbo);
218    debugOverdraw(true, false);
219
220    mRenderState.scissor().reset();
221    dirtyClip();
222}
223
224void OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& dirty) {
225    if (mState.currentlyIgnored()) return;
226
227    Rect clip(mState.currentRenderTargetClip());
228    clip.snapToPixelBoundaries();
229
230    // Since we don't know what the functor will draw, let's dirty
231    // the entire clip region
232    if (hasLayer()) {
233        dirtyLayerUnchecked(clip, getRegion());
234    }
235
236    DrawGlInfo info;
237    info.clipLeft = clip.left;
238    info.clipTop = clip.top;
239    info.clipRight = clip.right;
240    info.clipBottom = clip.bottom;
241    info.isLayer = hasLayer();
242    info.width = getViewportWidth();
243    info.height = getViewportHeight();
244    currentTransform()->copyTo(&info.transform[0]);
245
246    bool prevDirtyClip = mState.getDirtyClip();
247    // setup GL state for functor
248    if (mState.getDirtyClip()) {
249        setStencilFromClip(); // can issue draws, so must precede enableScissor()/interrupt()
250    }
251    if (mRenderState.scissor().setEnabled(true) || prevDirtyClip) {
252        setScissorFromClip();
253    }
254
255    mRenderState.invokeFunctor(functor, DrawGlInfo::kModeDraw, &info);
256    // Scissor may have been modified, reset dirty clip
257    dirtyClip();
258
259    mDirty = true;
260}
261
262///////////////////////////////////////////////////////////////////////////////
263// Debug
264///////////////////////////////////////////////////////////////////////////////
265
266void OpenGLRenderer::eventMarkDEBUG(const char* fmt, ...) const {
267#if DEBUG_DETAILED_EVENTS
268    const int BUFFER_SIZE = 256;
269    va_list ap;
270    char buf[BUFFER_SIZE];
271
272    va_start(ap, fmt);
273    vsnprintf(buf, BUFFER_SIZE, fmt, ap);
274    va_end(ap);
275
276    eventMark(buf);
277#endif
278}
279
280
281void OpenGLRenderer::eventMark(const char* name) const {
282    mCaches.eventMark(0, name);
283}
284
285void OpenGLRenderer::startMark(const char* name) const {
286    mCaches.startMark(0, name);
287}
288
289void OpenGLRenderer::endMark() const {
290    mCaches.endMark();
291}
292
293void OpenGLRenderer::debugOverdraw(bool enable, bool clear) {
294    mRenderState.debugOverdraw(enable, clear);
295}
296
297void OpenGLRenderer::renderOverdraw() {
298    if (Properties::debugOverdraw && getTargetFbo() == 0) {
299        const Rect* clip = &mTilingClip;
300
301        mRenderState.scissor().setEnabled(true);
302        mRenderState.scissor().set(clip->left,
303                mState.firstSnapshot()->getViewportHeight() - clip->bottom,
304                clip->right - clip->left,
305                clip->bottom - clip->top);
306
307        // 1x overdraw
308        mRenderState.stencil().enableDebugTest(2);
309        drawColor(mCaches.getOverdrawColor(1), SkXfermode::kSrcOver_Mode);
310
311        // 2x overdraw
312        mRenderState.stencil().enableDebugTest(3);
313        drawColor(mCaches.getOverdrawColor(2), SkXfermode::kSrcOver_Mode);
314
315        // 3x overdraw
316        mRenderState.stencil().enableDebugTest(4);
317        drawColor(mCaches.getOverdrawColor(3), SkXfermode::kSrcOver_Mode);
318
319        // 4x overdraw and higher
320        mRenderState.stencil().enableDebugTest(4, true);
321        drawColor(mCaches.getOverdrawColor(4), SkXfermode::kSrcOver_Mode);
322
323        mRenderState.stencil().disable();
324    }
325}
326
327///////////////////////////////////////////////////////////////////////////////
328// Layers
329///////////////////////////////////////////////////////////////////////////////
330
331bool OpenGLRenderer::updateLayer(Layer* layer, bool inFrame) {
332    if (layer->deferredUpdateScheduled && layer->renderer
333            && layer->renderNode.get() && layer->renderNode->isRenderable()) {
334
335        if (inFrame) {
336            debugOverdraw(false, false);
337        }
338
339        if (CC_UNLIKELY(inFrame || Properties::drawDeferDisabled)) {
340            layer->render(*this);
341        } else {
342            layer->defer(*this);
343        }
344
345        if (inFrame) {
346            resumeAfterLayer();
347        }
348
349        layer->debugDrawUpdate = Properties::debugLayersUpdates;
350        layer->hasDrawnSinceUpdate = false;
351
352        return true;
353    }
354
355    return false;
356}
357
358void OpenGLRenderer::updateLayers() {
359    // If draw deferring is enabled this method will simply defer
360    // the display list of each individual layer. The layers remain
361    // in the layer updates list which will be cleared by flushLayers().
362    int count = mLayerUpdates.size();
363    if (count > 0) {
364        if (CC_UNLIKELY(Properties::drawDeferDisabled)) {
365            startMark("Layer Updates");
366        } else {
367            startMark("Defer Layer Updates");
368        }
369
370        // Note: it is very important to update the layers in order
371        for (int i = 0; i < count; i++) {
372            Layer* layer = mLayerUpdates[i].get();
373            updateLayer(layer, false);
374        }
375
376        if (CC_UNLIKELY(Properties::drawDeferDisabled)) {
377            mLayerUpdates.clear();
378            mRenderState.bindFramebuffer(getTargetFbo());
379        }
380        endMark();
381    }
382}
383
384void OpenGLRenderer::flushLayers() {
385    int count = mLayerUpdates.size();
386    if (count > 0) {
387        startMark("Apply Layer Updates");
388
389        // Note: it is very important to update the layers in order
390        for (int i = 0; i < count; i++) {
391            mLayerUpdates[i]->flush();
392        }
393
394        mLayerUpdates.clear();
395        mRenderState.bindFramebuffer(getTargetFbo());
396
397        endMark();
398    }
399}
400
401void OpenGLRenderer::pushLayerUpdate(Layer* layer) {
402    if (layer) {
403        // Make sure we don't introduce duplicates.
404        // SortedVector would do this automatically but we need to respect
405        // the insertion order. The linear search is not an issue since
406        // this list is usually very short (typically one item, at most a few)
407        for (int i = mLayerUpdates.size() - 1; i >= 0; i--) {
408            if (mLayerUpdates[i] == layer) {
409                return;
410            }
411        }
412        mLayerUpdates.push_back(layer);
413    }
414}
415
416void OpenGLRenderer::cancelLayerUpdate(Layer* layer) {
417    if (layer) {
418        for (int i = mLayerUpdates.size() - 1; i >= 0; i--) {
419            if (mLayerUpdates[i] == layer) {
420                mLayerUpdates.erase(mLayerUpdates.begin() + i);
421                break;
422            }
423        }
424    }
425}
426
427void OpenGLRenderer::flushLayerUpdates() {
428    ATRACE_NAME("Update HW Layers");
429    mRenderState.blend().syncEnabled();
430    updateLayers();
431    flushLayers();
432    // Wait for all the layer updates to be executed
433    glFinish();
434}
435
436void OpenGLRenderer::markLayersAsBuildLayers() {
437    for (size_t i = 0; i < mLayerUpdates.size(); i++) {
438        mLayerUpdates[i]->wasBuildLayered = true;
439    }
440}
441
442///////////////////////////////////////////////////////////////////////////////
443// State management
444///////////////////////////////////////////////////////////////////////////////
445
446void OpenGLRenderer::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {
447    bool restoreViewport = removed.flags & Snapshot::kFlagIsFboLayer;
448    bool restoreClip = removed.flags & Snapshot::kFlagClipSet;
449    bool restoreLayer = removed.flags & Snapshot::kFlagIsLayer;
450
451    if (restoreViewport) {
452        mRenderState.setViewport(getViewportWidth(), getViewportHeight());
453    }
454
455    if (restoreClip) {
456        dirtyClip();
457    }
458
459    if (restoreLayer) {
460        endMark(); // Savelayer
461        ATRACE_END(); // SaveLayer
462        startMark("ComposeLayer");
463        composeLayer(removed, restored);
464        endMark();
465    }
466}
467
468///////////////////////////////////////////////////////////////////////////////
469// Layers
470///////////////////////////////////////////////////////////////////////////////
471
472int OpenGLRenderer::saveLayer(float left, float top, float right, float bottom,
473        const SkPaint* paint, int flags, const SkPath* convexMask) {
474    // force matrix/clip isolation for layer
475    flags |= SaveFlags::MatrixClip;
476
477    const int count = mState.saveSnapshot(flags);
478
479    if (!mState.currentlyIgnored()) {
480        createLayer(left, top, right, bottom, paint, flags, convexMask);
481    }
482
483    return count;
484}
485
486void OpenGLRenderer::calculateLayerBoundsAndClip(Rect& bounds, Rect& clip, bool fboLayer) {
487    const Rect untransformedBounds(bounds);
488
489    currentTransform()->mapRect(bounds);
490
491    // Layers only make sense if they are in the framebuffer's bounds
492    bounds.doIntersect(mState.currentRenderTargetClip());
493    if (!bounds.isEmpty()) {
494        // We cannot work with sub-pixels in this case
495        bounds.snapToPixelBoundaries();
496
497        // When the layer is not an FBO, we may use glCopyTexImage so we
498        // need to make sure the layer does not extend outside the bounds
499        // of the framebuffer
500        const Snapshot& previous = *(currentSnapshot()->previous);
501        Rect previousViewport(0, 0, previous.getViewportWidth(), previous.getViewportHeight());
502
503        bounds.doIntersect(previousViewport);
504        if (!bounds.isEmpty() && fboLayer) {
505            clip.set(bounds);
506            mat4 inverse;
507            inverse.loadInverse(*currentTransform());
508            inverse.mapRect(clip);
509            clip.snapToPixelBoundaries();
510            clip.doIntersect(untransformedBounds);
511            if (!clip.isEmpty()) {
512                clip.translate(-untransformedBounds.left, -untransformedBounds.top);
513                bounds.set(untransformedBounds);
514            }
515        }
516    }
517}
518
519void OpenGLRenderer::updateSnapshotIgnoreForLayer(const Rect& bounds, const Rect& clip,
520        bool fboLayer, int alpha) {
521    if (bounds.isEmpty() || bounds.getWidth() > mCaches.maxTextureSize ||
522            bounds.getHeight() > mCaches.maxTextureSize ||
523            (fboLayer && clip.isEmpty())) {
524        writableSnapshot()->empty = fboLayer;
525    } else {
526        writableSnapshot()->invisible = writableSnapshot()->invisible || (alpha <= 0 && fboLayer);
527    }
528}
529
530int OpenGLRenderer::saveLayerDeferred(float left, float top, float right, float bottom,
531        const SkPaint* paint, int flags) {
532    const int count = mState.saveSnapshot(flags);
533
534    if (!mState.currentlyIgnored() && (flags & SaveFlags::ClipToLayer)) {
535        // initialize the snapshot as though it almost represents an FBO layer so deferred draw
536        // operations will be able to store and restore the current clip and transform info, and
537        // quick rejection will be correct (for display lists)
538
539        Rect bounds(left, top, right, bottom);
540        Rect clip;
541        calculateLayerBoundsAndClip(bounds, clip, true);
542        updateSnapshotIgnoreForLayer(bounds, clip, true, PaintUtils::getAlphaDirect(paint));
543
544        if (!mState.currentlyIgnored()) {
545            writableSnapshot()->resetTransform(-bounds.left, -bounds.top, 0.0f);
546            writableSnapshot()->resetClip(clip.left, clip.top, clip.right, clip.bottom);
547            writableSnapshot()->initializeViewport(bounds.getWidth(), bounds.getHeight());
548            writableSnapshot()->roundRectClipState = nullptr;
549        }
550    }
551
552    return count;
553}
554
555/**
556 * Layers are viewed by Skia are slightly different than layers in image editing
557 * programs (for instance.) When a layer is created, previously created layers
558 * and the frame buffer still receive every drawing command. For instance, if a
559 * layer is created and a shape intersecting the bounds of the layers and the
560 * framebuffer is draw, the shape will be drawn on both (unless the layer was
561 * created with the SaveFlags::ClipToLayer flag.)
562 *
563 * A way to implement layers is to create an FBO for each layer, backed by an RGBA
564 * texture. Unfortunately, this is inefficient as it requires every primitive to
565 * be drawn n + 1 times, where n is the number of active layers. In practice this
566 * means, for every primitive:
567 *   - Switch active frame buffer
568 *   - Change viewport, clip and projection matrix
569 *   - Issue the drawing
570 *
571 * Switching rendering target n + 1 times per drawn primitive is extremely costly.
572 * To avoid this, layers are implemented in a different way here, at least in the
573 * general case. FBOs are used, as an optimization, when the "clip to layer" flag
574 * is set. When this flag is set we can redirect all drawing operations into a
575 * single FBO.
576 *
577 * This implementation relies on the frame buffer being at least RGBA 8888. When
578 * a layer is created, only a texture is created, not an FBO. The content of the
579 * frame buffer contained within the layer's bounds is copied into this texture
580 * using glCopyTexImage2D(). The layer's region is then cleared(1) in the frame
581 * buffer and drawing continues as normal. This technique therefore treats the
582 * frame buffer as a scratch buffer for the layers.
583 *
584 * To compose the layers back onto the frame buffer, each layer texture
585 * (containing the original frame buffer data) is drawn as a simple quad over
586 * the frame buffer. The trick is that the quad is set as the composition
587 * destination in the blending equation, and the frame buffer becomes the source
588 * of the composition.
589 *
590 * Drawing layers with an alpha value requires an extra step before composition.
591 * An empty quad is drawn over the layer's region in the frame buffer. This quad
592 * is drawn with the rgba color (0,0,0,alpha). The alpha value offered by the
593 * quad is used to multiply the colors in the frame buffer. This is achieved by
594 * changing the GL blend functions for the GL_FUNC_ADD blend equation to
595 * GL_ZERO, GL_SRC_ALPHA.
596 *
597 * Because glCopyTexImage2D() can be slow, an alternative implementation might
598 * be use to draw a single clipped layer. The implementation described above
599 * is correct in every case.
600 *
601 * (1) The frame buffer is actually not cleared right away. To allow the GPU
602 *     to potentially optimize series of calls to glCopyTexImage2D, the frame
603 *     buffer is left untouched until the first drawing operation. Only when
604 *     something actually gets drawn are the layers regions cleared.
605 */
606bool OpenGLRenderer::createLayer(float left, float top, float right, float bottom,
607        const SkPaint* paint, int flags, const SkPath* convexMask) {
608    LAYER_LOGD("Requesting layer %.2fx%.2f", right - left, bottom - top);
609    LAYER_LOGD("Layer cache size = %d", mCaches.layerCache.getSize());
610
611    const bool fboLayer = flags & SaveFlags::ClipToLayer;
612
613    // Window coordinates of the layer
614    Rect clip;
615    Rect bounds(left, top, right, bottom);
616    calculateLayerBoundsAndClip(bounds, clip, fboLayer);
617    updateSnapshotIgnoreForLayer(bounds, clip, fboLayer, PaintUtils::getAlphaDirect(paint));
618
619    // Bail out if we won't draw in this snapshot
620    if (mState.currentlyIgnored()) {
621        return false;
622    }
623
624    mCaches.textureState().activateTexture(0);
625    Layer* layer = mCaches.layerCache.get(mRenderState, bounds.getWidth(), bounds.getHeight());
626    if (!layer) {
627        return false;
628    }
629
630    layer->setPaint(paint);
631    layer->layer.set(bounds);
632    layer->texCoords.set(0.0f, bounds.getHeight() / float(layer->getHeight()),
633            bounds.getWidth() / float(layer->getWidth()), 0.0f);
634
635    layer->setBlend(true);
636    layer->setDirty(false);
637    layer->setConvexMask(convexMask); // note: the mask must be cleared before returning to the cache
638
639    // Save the layer in the snapshot
640    writableSnapshot()->flags |= Snapshot::kFlagIsLayer;
641    writableSnapshot()->layer = layer;
642
643    ATRACE_FORMAT_BEGIN("%ssaveLayer %ux%u",
644            fboLayer ? "" : "unclipped ",
645            layer->getWidth(), layer->getHeight());
646    startMark("SaveLayer");
647    if (fboLayer) {
648        return createFboLayer(layer, bounds, clip);
649    } else {
650        // Copy the framebuffer into the layer
651        layer->bindTexture();
652        if (!bounds.isEmpty()) {
653            if (layer->isEmpty()) {
654                // Workaround for some GL drivers. When reading pixels lying outside
655                // of the window we should get undefined values for those pixels.
656                // Unfortunately some drivers will turn the entire target texture black
657                // when reading outside of the window.
658                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, layer->getWidth(), layer->getHeight(),
659                        0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
660                layer->setEmpty(false);
661            }
662
663            glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
664                    bounds.left, getViewportHeight() - bounds.bottom,
665                    bounds.getWidth(), bounds.getHeight());
666
667            // Enqueue the buffer coordinates to clear the corresponding region later
668            mLayers.push_back(Rect(bounds));
669        }
670    }
671
672    return true;
673}
674
675bool OpenGLRenderer::createFboLayer(Layer* layer, Rect& bounds, Rect& clip) {
676    layer->clipRect.set(clip);
677    layer->setFbo(mRenderState.createFramebuffer());
678
679    writableSnapshot()->region = &writableSnapshot()->layer->region;
680    writableSnapshot()->flags |= Snapshot::kFlagFboTarget | Snapshot::kFlagIsFboLayer;
681    writableSnapshot()->fbo = layer->getFbo();
682    writableSnapshot()->resetTransform(-bounds.left, -bounds.top, 0.0f);
683    writableSnapshot()->resetClip(clip.left, clip.top, clip.right, clip.bottom);
684    writableSnapshot()->initializeViewport(bounds.getWidth(), bounds.getHeight());
685    writableSnapshot()->roundRectClipState = nullptr;
686
687    debugOverdraw(false, false);
688    // Bind texture to FBO
689    mRenderState.bindFramebuffer(layer->getFbo());
690    layer->bindTexture();
691
692    // Initialize the texture if needed
693    if (layer->isEmpty()) {
694        layer->allocateTexture();
695        layer->setEmpty(false);
696    }
697
698    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
699            layer->getTextureId(), 0);
700
701    // Clear the FBO, expand the clear region by 1 to get nice bilinear filtering
702    mRenderState.scissor().setEnabled(true);
703    mRenderState.scissor().set(clip.left - 1.0f, bounds.getHeight() - clip.bottom - 1.0f,
704            clip.getWidth() + 2.0f, clip.getHeight() + 2.0f);
705    glClear(GL_COLOR_BUFFER_BIT);
706
707    dirtyClip();
708
709    // Change the ortho projection
710    mRenderState.setViewport(bounds.getWidth(), bounds.getHeight());
711    return true;
712}
713
714/**
715 * Read the documentation of createLayer() before doing anything in this method.
716 */
717void OpenGLRenderer::composeLayer(const Snapshot& removed, const Snapshot& restored) {
718    if (!removed.layer) {
719        ALOGE("Attempting to compose a layer that does not exist");
720        return;
721    }
722
723    Layer* layer = removed.layer;
724    const Rect& rect = layer->layer;
725    const bool fboLayer = removed.flags & Snapshot::kFlagIsFboLayer;
726
727    bool clipRequired = false;
728    mState.calculateQuickRejectForScissor(rect.left, rect.top, rect.right, rect.bottom,
729            &clipRequired, nullptr, false); // safely ignore return, should never be rejected
730    mRenderState.scissor().setEnabled(mScissorOptimizationDisabled || clipRequired);
731
732    if (fboLayer) {
733        // Detach the texture from the FBO
734        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
735
736        layer->removeFbo(false);
737
738        // Unbind current FBO and restore previous one
739        mRenderState.bindFramebuffer(restored.fbo);
740        debugOverdraw(true, false);
741    }
742
743    if (!fboLayer && layer->getAlpha() < 255) {
744        SkPaint layerPaint;
745        layerPaint.setAlpha(layer->getAlpha());
746        layerPaint.setXfermodeMode(SkXfermode::kDstIn_Mode);
747        layerPaint.setColorFilter(layer->getColorFilter());
748
749        drawColorRect(rect.left, rect.top, rect.right, rect.bottom, &layerPaint, true);
750        // Required below, composeLayerRect() will divide by 255
751        layer->setAlpha(255);
752    }
753
754    mRenderState.meshState().unbindMeshBuffer();
755
756    mCaches.textureState().activateTexture(0);
757
758    // When the layer is stored in an FBO, we can save a bit of fillrate by
759    // drawing only the dirty region
760    if (fboLayer) {
761        dirtyLayer(rect.left, rect.top, rect.right, rect.bottom, *restored.transform);
762        composeLayerRegion(layer, rect);
763    } else if (!rect.isEmpty()) {
764        dirtyLayer(rect.left, rect.top, rect.right, rect.bottom);
765
766        save(0);
767        // the layer contains screen buffer content that shouldn't be alpha modulated
768        // (and any necessary alpha modulation was handled drawing into the layer)
769        writableSnapshot()->alpha = 1.0f;
770        composeLayerRectSwapped(layer, rect);
771        restore();
772    }
773
774    dirtyClip();
775
776    // Failing to add the layer to the cache should happen only if the layer is too large
777    layer->setConvexMask(nullptr);
778    if (!mCaches.layerCache.put(layer)) {
779        LAYER_LOGD("Deleting layer");
780        layer->decStrong(nullptr);
781    }
782}
783
784void OpenGLRenderer::drawTextureLayer(Layer* layer, const Rect& rect) {
785    const bool tryToSnap = !layer->getForceFilter()
786            && layer->getWidth() == (uint32_t) rect.getWidth()
787            && layer->getHeight() == (uint32_t) rect.getHeight();
788    Glop glop;
789    GlopBuilder(mRenderState, mCaches, &glop)
790            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
791            .setMeshTexturedUvQuad(nullptr, Rect(0, 1, 1, 0)) // TODO: simplify with VBO
792            .setFillTextureLayer(*layer, getLayerAlpha(layer))
793            .setTransform(*currentSnapshot(), TransformFlags::None)
794            .setModelViewMapUnitToRectOptionalSnap(tryToSnap, rect)
795            .build();
796    renderGlop(glop);
797}
798
799void OpenGLRenderer::composeLayerRectSwapped(Layer* layer, const Rect& rect) {
800    Glop glop;
801    GlopBuilder(mRenderState, mCaches, &glop)
802            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
803            .setMeshTexturedUvQuad(nullptr, layer->texCoords)
804            .setFillLayer(layer->getTexture(), layer->getColorFilter(),
805                    getLayerAlpha(layer), layer->getMode(), Blend::ModeOrderSwap::Swap)
806            .setTransform(*currentSnapshot(), TransformFlags::MeshIgnoresCanvasTransform)
807            .setModelViewMapUnitToRect(rect)
808            .build();
809    renderGlop(glop);
810}
811
812void OpenGLRenderer::composeLayerRect(Layer* layer, const Rect& rect) {
813    if (layer->isTextureLayer()) {
814        EVENT_LOGD("composeTextureLayerRect");
815        drawTextureLayer(layer, rect);
816    } else {
817        EVENT_LOGD("composeHardwareLayerRect");
818
819        const bool tryToSnap = layer->getWidth() == static_cast<uint32_t>(rect.getWidth())
820                && layer->getHeight() == static_cast<uint32_t>(rect.getHeight());
821        Glop glop;
822        GlopBuilder(mRenderState, mCaches, &glop)
823                .setRoundRectClipState(currentSnapshot()->roundRectClipState)
824                .setMeshTexturedUvQuad(nullptr, layer->texCoords)
825                .setFillLayer(layer->getTexture(), layer->getColorFilter(), getLayerAlpha(layer), layer->getMode(), Blend::ModeOrderSwap::NoSwap)
826                .setTransform(*currentSnapshot(), TransformFlags::None)
827                .setModelViewMapUnitToRectOptionalSnap(tryToSnap, rect)
828                .build();
829        renderGlop(glop);
830    }
831}
832
833/**
834 * Issues the command X, and if we're composing a save layer to the fbo or drawing a newly updated
835 * hardware layer with overdraw debug on, draws again to the stencil only, so that these draw
836 * operations are correctly counted twice for overdraw. NOTE: assumes composeLayerRegion only used
837 * by saveLayer's restore
838 */
839#define DRAW_DOUBLE_STENCIL_IF(COND, DRAW_COMMAND) { \
840        DRAW_COMMAND; \
841        if (CC_UNLIKELY(Properties::debugOverdraw && getTargetFbo() == 0 && COND)) { \
842            glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); \
843            DRAW_COMMAND; \
844            glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); \
845        } \
846    }
847
848#define DRAW_DOUBLE_STENCIL(DRAW_COMMAND) DRAW_DOUBLE_STENCIL_IF(true, DRAW_COMMAND)
849
850// This class is purely for inspection. It inherits from SkShader, but Skia does not know how to
851// use it. The OpenGLRenderer will look at it to find its Layer and whether it is opaque.
852class LayerShader : public SkShader {
853public:
854    LayerShader(Layer* layer, const SkMatrix* localMatrix)
855    : INHERITED(localMatrix)
856    , mLayer(layer) {
857    }
858
859    virtual bool asACustomShader(void** data) const override {
860        if (data) {
861            *data = static_cast<void*>(mLayer);
862        }
863        return true;
864    }
865
866    virtual bool isOpaque() const override {
867        return !mLayer->isBlend();
868    }
869
870protected:
871    virtual void shadeSpan(int x, int y, SkPMColor[], int count) {
872        LOG_ALWAYS_FATAL("LayerShader should never be drawn with raster backend.");
873    }
874
875    virtual void flatten(SkWriteBuffer&) const override {
876        LOG_ALWAYS_FATAL("LayerShader should never be flattened.");
877    }
878
879    virtual Factory getFactory() const override {
880        LOG_ALWAYS_FATAL("LayerShader should never be created from a stream.");
881        return nullptr;
882    }
883private:
884    // Unowned.
885    Layer* mLayer;
886    typedef SkShader INHERITED;
887};
888
889void OpenGLRenderer::composeLayerRegion(Layer* layer, const Rect& rect) {
890    if (CC_UNLIKELY(layer->region.isEmpty())) return; // nothing to draw
891
892    if (layer->getConvexMask()) {
893        save(SaveFlags::MatrixClip);
894
895        // clip to the area of the layer the mask can be larger
896        clipRect(rect.left, rect.top, rect.right, rect.bottom, SkRegion::kIntersect_Op);
897
898        SkPaint paint;
899        paint.setAntiAlias(true);
900        paint.setColor(SkColorSetARGB(int(getLayerAlpha(layer) * 255), 0, 0, 0));
901
902        // create LayerShader to map SaveLayer content into subsequent draw
903        SkMatrix shaderMatrix;
904        shaderMatrix.setTranslate(rect.left, rect.bottom);
905        shaderMatrix.preScale(1, -1);
906        LayerShader layerShader(layer, &shaderMatrix);
907        paint.setShader(&layerShader);
908
909        // Since the drawing primitive is defined in local drawing space,
910        // we don't need to modify the draw matrix
911        const SkPath* maskPath = layer->getConvexMask();
912        DRAW_DOUBLE_STENCIL(drawConvexPath(*maskPath, &paint));
913
914        paint.setShader(nullptr);
915        restore();
916
917        return;
918    }
919
920    if (layer->region.isRect()) {
921        layer->setRegionAsRect();
922
923        DRAW_DOUBLE_STENCIL(composeLayerRect(layer, layer->regionRect));
924
925        layer->region.clear();
926        return;
927    }
928
929    EVENT_LOGD("composeLayerRegion");
930    // standard Region based draw
931    size_t count;
932    const android::Rect* rects;
933    Region safeRegion;
934    if (CC_LIKELY(hasRectToRectTransform())) {
935        rects = layer->region.getArray(&count);
936    } else {
937        safeRegion = Region::createTJunctionFreeRegion(layer->region);
938        rects = safeRegion.getArray(&count);
939    }
940
941    const float texX = 1.0f / float(layer->getWidth());
942    const float texY = 1.0f / float(layer->getHeight());
943    const float height = rect.getHeight();
944
945    TextureVertex quadVertices[count * 4];
946    TextureVertex* mesh = &quadVertices[0];
947    for (size_t i = 0; i < count; i++) {
948        const android::Rect* r = &rects[i];
949
950        const float u1 = r->left * texX;
951        const float v1 = (height - r->top) * texY;
952        const float u2 = r->right * texX;
953        const float v2 = (height - r->bottom) * texY;
954
955        // TODO: Reject quads outside of the clip
956        TextureVertex::set(mesh++, r->left, r->top, u1, v1);
957        TextureVertex::set(mesh++, r->right, r->top, u2, v1);
958        TextureVertex::set(mesh++, r->left, r->bottom, u1, v2);
959        TextureVertex::set(mesh++, r->right, r->bottom, u2, v2);
960    }
961    Rect modelRect = Rect(rect.getWidth(), rect.getHeight());
962    Glop glop;
963    GlopBuilder(mRenderState, mCaches, &glop)
964            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
965            .setMeshTexturedIndexedQuads(&quadVertices[0], count * 6)
966            .setFillLayer(layer->getTexture(), layer->getColorFilter(), getLayerAlpha(layer), layer->getMode(), Blend::ModeOrderSwap::NoSwap)
967            .setTransform(*currentSnapshot(),  TransformFlags::None)
968            .setModelViewOffsetRectSnap(rect.left, rect.top, modelRect)
969            .build();
970    DRAW_DOUBLE_STENCIL_IF(!layer->hasDrawnSinceUpdate, renderGlop(glop));
971
972#if DEBUG_LAYERS_AS_REGIONS
973    drawRegionRectsDebug(layer->region);
974#endif
975
976    layer->region.clear();
977}
978
979#if DEBUG_LAYERS_AS_REGIONS
980void OpenGLRenderer::drawRegionRectsDebug(const Region& region) {
981    size_t count;
982    const android::Rect* rects = region.getArray(&count);
983
984    uint32_t colors[] = {
985            0x7fff0000, 0x7f00ff00,
986            0x7f0000ff, 0x7fff00ff,
987    };
988
989    int offset = 0;
990    int32_t top = rects[0].top;
991
992    for (size_t i = 0; i < count; i++) {
993        if (top != rects[i].top) {
994            offset ^= 0x2;
995            top = rects[i].top;
996        }
997
998        SkPaint paint;
999        paint.setColor(colors[offset + (i & 0x1)]);
1000        Rect r(rects[i].left, rects[i].top, rects[i].right, rects[i].bottom);
1001        drawColorRect(r.left, r.top, r.right, r.bottom, paint);
1002    }
1003}
1004#endif
1005
1006void OpenGLRenderer::drawRegionRects(const SkRegion& region, const SkPaint& paint, bool dirty) {
1007    Vector<float> rects;
1008
1009    SkRegion::Iterator it(region);
1010    while (!it.done()) {
1011        const SkIRect& r = it.rect();
1012        rects.push(r.fLeft);
1013        rects.push(r.fTop);
1014        rects.push(r.fRight);
1015        rects.push(r.fBottom);
1016        it.next();
1017    }
1018
1019    drawColorRects(rects.array(), rects.size(), &paint, true, dirty, false);
1020}
1021
1022void OpenGLRenderer::dirtyLayer(const float left, const float top,
1023        const float right, const float bottom, const Matrix4& transform) {
1024    if (hasLayer()) {
1025        Rect bounds(left, top, right, bottom);
1026        transform.mapRect(bounds);
1027        dirtyLayerUnchecked(bounds, getRegion());
1028    }
1029}
1030
1031void OpenGLRenderer::dirtyLayer(const float left, const float top,
1032        const float right, const float bottom) {
1033    if (hasLayer()) {
1034        Rect bounds(left, top, right, bottom);
1035        dirtyLayerUnchecked(bounds, getRegion());
1036    }
1037}
1038
1039void OpenGLRenderer::dirtyLayerUnchecked(Rect& bounds, Region* region) {
1040    bounds.doIntersect(mState.currentRenderTargetClip());
1041    if (!bounds.isEmpty()) {
1042        bounds.snapToPixelBoundaries();
1043        android::Rect dirty(bounds.left, bounds.top, bounds.right, bounds.bottom);
1044        if (!dirty.isEmpty()) {
1045            region->orSelf(dirty);
1046        }
1047    }
1048}
1049
1050void OpenGLRenderer::clearLayerRegions() {
1051    const size_t quadCount = mLayers.size();
1052    if (quadCount == 0) return;
1053
1054    if (!mState.currentlyIgnored()) {
1055        EVENT_LOGD("clearLayerRegions");
1056        // Doing several glScissor/glClear here can negatively impact
1057        // GPUs with a tiler architecture, instead we draw quads with
1058        // the Clear blending mode
1059
1060        // The list contains bounds that have already been clipped
1061        // against their initial clip rect, and the current clip
1062        // is likely different so we need to disable clipping here
1063        bool scissorChanged = mRenderState.scissor().setEnabled(false);
1064
1065        Vertex mesh[quadCount * 4];
1066        Vertex* vertex = mesh;
1067
1068        for (uint32_t i = 0; i < quadCount; i++) {
1069            const Rect& bounds = mLayers[i];
1070
1071            Vertex::set(vertex++, bounds.left, bounds.top);
1072            Vertex::set(vertex++, bounds.right, bounds.top);
1073            Vertex::set(vertex++, bounds.left, bounds.bottom);
1074            Vertex::set(vertex++, bounds.right, bounds.bottom);
1075        }
1076        // We must clear the list of dirty rects before we
1077        // call clearLayerRegions() in renderGlop to prevent
1078        // stencil setup from doing the same thing again
1079        mLayers.clear();
1080
1081        const int transformFlags = TransformFlags::MeshIgnoresCanvasTransform;
1082        Glop glop;
1083        GlopBuilder(mRenderState, mCaches, &glop)
1084                .setRoundRectClipState(nullptr) // clear ignores clip state
1085                .setMeshIndexedQuads(&mesh[0], quadCount)
1086                .setFillClear()
1087                .setTransform(*currentSnapshot(), transformFlags)
1088                .setModelViewOffsetRect(0, 0, Rect(currentSnapshot()->getRenderTargetClip()))
1089                .build();
1090        renderGlop(glop, GlopRenderType::LayerClear);
1091
1092        if (scissorChanged) mRenderState.scissor().setEnabled(true);
1093    } else {
1094        mLayers.clear();
1095    }
1096}
1097
1098///////////////////////////////////////////////////////////////////////////////
1099// State Deferral
1100///////////////////////////////////////////////////////////////////////////////
1101
1102bool OpenGLRenderer::storeDisplayState(DeferredDisplayState& state, int stateDeferFlags) {
1103    const Rect& currentClip = mState.currentRenderTargetClip();
1104    const mat4* currentMatrix = currentTransform();
1105
1106    if (stateDeferFlags & kStateDeferFlag_Draw) {
1107        // state has bounds initialized in local coordinates
1108        if (!state.mBounds.isEmpty()) {
1109            currentMatrix->mapRect(state.mBounds);
1110            Rect clippedBounds(state.mBounds);
1111            // NOTE: if we ever want to use this clipping info to drive whether the scissor
1112            // is used, it should more closely duplicate the quickReject logic (in how it uses
1113            // snapToPixelBoundaries)
1114
1115            clippedBounds.doIntersect(currentClip);
1116            if (clippedBounds.isEmpty()) {
1117                // quick rejected
1118                return true;
1119            }
1120
1121            state.mClipSideFlags = kClipSide_None;
1122            if (!currentClip.contains(state.mBounds)) {
1123                int& flags = state.mClipSideFlags;
1124                // op partially clipped, so record which sides are clipped for clip-aware merging
1125                if (currentClip.left > state.mBounds.left) flags |= kClipSide_Left;
1126                if (currentClip.top > state.mBounds.top) flags |= kClipSide_Top;
1127                if (currentClip.right < state.mBounds.right) flags |= kClipSide_Right;
1128                if (currentClip.bottom < state.mBounds.bottom) flags |= kClipSide_Bottom;
1129            }
1130            state.mBounds.set(clippedBounds);
1131        } else {
1132            // Empty bounds implies size unknown. Label op as conservatively clipped to disable
1133            // overdraw avoidance (since we don't know what it overlaps)
1134            state.mClipSideFlags = kClipSide_ConservativeFull;
1135            state.mBounds.set(currentClip);
1136        }
1137    }
1138
1139    state.mClipValid = (stateDeferFlags & kStateDeferFlag_Clip);
1140    if (state.mClipValid) {
1141        state.mClip.set(currentClip);
1142    }
1143
1144    // Transform and alpha always deferred, since they are used by state operations
1145    // (Note: saveLayer/restore use colorFilter and alpha, so we just save restore everything)
1146    state.mMatrix = *currentMatrix;
1147    state.mAlpha = currentSnapshot()->alpha;
1148
1149    // always store/restore, since these are just pointers
1150    state.mRoundRectClipState = currentSnapshot()->roundRectClipState;
1151#if !HWUI_NEW_OPS
1152    state.mProjectionPathMask = currentSnapshot()->projectionPathMask;
1153#endif
1154    return false;
1155}
1156
1157void OpenGLRenderer::restoreDisplayState(const DeferredDisplayState& state, bool skipClipRestore) {
1158    setGlobalMatrix(state.mMatrix);
1159    writableSnapshot()->alpha = state.mAlpha;
1160    writableSnapshot()->roundRectClipState = state.mRoundRectClipState;
1161#if !HWUI_NEW_OPS
1162    writableSnapshot()->projectionPathMask = state.mProjectionPathMask;
1163#endif
1164
1165    if (state.mClipValid && !skipClipRestore) {
1166        writableSnapshot()->setClip(state.mClip.left, state.mClip.top,
1167                state.mClip.right, state.mClip.bottom);
1168        dirtyClip();
1169    }
1170}
1171
1172/**
1173 * Merged multidraw (such as in drawText and drawBitmaps rely on the fact that no clipping is done
1174 * in the draw path. Instead, clipping is done ahead of time - either as a single clip rect (when at
1175 * least one op is clipped), or disabled entirely (because no merged op is clipped)
1176 *
1177 * This method should be called when restoreDisplayState() won't be restoring the clip
1178 */
1179void OpenGLRenderer::setupMergedMultiDraw(const Rect* clipRect) {
1180    if (clipRect != nullptr) {
1181        writableSnapshot()->setClip(clipRect->left, clipRect->top, clipRect->right, clipRect->bottom);
1182    } else {
1183        writableSnapshot()->setClip(0, 0, mState.getWidth(), mState.getHeight());
1184    }
1185    dirtyClip();
1186    bool enableScissor = (clipRect != nullptr) || mScissorOptimizationDisabled;
1187    mRenderState.scissor().setEnabled(enableScissor);
1188}
1189
1190///////////////////////////////////////////////////////////////////////////////
1191// Clipping
1192///////////////////////////////////////////////////////////////////////////////
1193
1194void OpenGLRenderer::setScissorFromClip() {
1195    Rect clip(mState.currentRenderTargetClip());
1196    clip.snapToPixelBoundaries();
1197
1198    if (mRenderState.scissor().set(clip.left, getViewportHeight() - clip.bottom,
1199            clip.getWidth(), clip.getHeight())) {
1200        mState.setDirtyClip(false);
1201    }
1202}
1203
1204void OpenGLRenderer::ensureStencilBuffer() {
1205    // Thanks to the mismatch between EGL and OpenGL ES FBO we
1206    // cannot attach a stencil buffer to fbo0 dynamically. Let's
1207    // just hope we have one when hasLayer() returns false.
1208    if (hasLayer()) {
1209        attachStencilBufferToLayer(currentSnapshot()->layer);
1210    }
1211}
1212
1213void OpenGLRenderer::attachStencilBufferToLayer(Layer* layer) {
1214    // The layer's FBO is already bound when we reach this stage
1215    if (!layer->getStencilRenderBuffer()) {
1216        RenderBuffer* buffer = mCaches.renderBufferCache.get(
1217                Stencil::getLayerStencilFormat(),
1218                layer->getWidth(), layer->getHeight());
1219        layer->setStencilRenderBuffer(buffer);
1220    }
1221}
1222
1223static void handlePoint(std::vector<Vertex>& rectangleVertices, const Matrix4& transform,
1224        float x, float y) {
1225    Vertex v;
1226    v.x = x;
1227    v.y = y;
1228    transform.mapPoint(v.x, v.y);
1229    rectangleVertices.push_back(v);
1230}
1231
1232static void handlePointNoTransform(std::vector<Vertex>& rectangleVertices, float x, float y) {
1233    Vertex v;
1234    v.x = x;
1235    v.y = y;
1236    rectangleVertices.push_back(v);
1237}
1238
1239void OpenGLRenderer::drawRectangleList(const RectangleList& rectangleList) {
1240    int quadCount = rectangleList.getTransformedRectanglesCount();
1241    std::vector<Vertex> rectangleVertices(quadCount * 4);
1242    Rect scissorBox = rectangleList.calculateBounds();
1243    scissorBox.snapToPixelBoundaries();
1244    for (int i = 0; i < quadCount; ++i) {
1245        const TransformedRectangle& tr(rectangleList.getTransformedRectangle(i));
1246        const Matrix4& transform = tr.getTransform();
1247        Rect bounds = tr.getBounds();
1248        if (transform.rectToRect()) {
1249            transform.mapRect(bounds);
1250            bounds.doIntersect(scissorBox);
1251            if (!bounds.isEmpty()) {
1252                handlePointNoTransform(rectangleVertices, bounds.left, bounds.top);
1253                handlePointNoTransform(rectangleVertices, bounds.right, bounds.top);
1254                handlePointNoTransform(rectangleVertices, bounds.left, bounds.bottom);
1255                handlePointNoTransform(rectangleVertices, bounds.right, bounds.bottom);
1256            }
1257        } else {
1258            handlePoint(rectangleVertices, transform, bounds.left, bounds.top);
1259            handlePoint(rectangleVertices, transform, bounds.right, bounds.top);
1260            handlePoint(rectangleVertices, transform, bounds.left, bounds.bottom);
1261            handlePoint(rectangleVertices, transform, bounds.right, bounds.bottom);
1262        }
1263    }
1264
1265    mRenderState.scissor().set(scissorBox.left, getViewportHeight() - scissorBox.bottom,
1266            scissorBox.getWidth(), scissorBox.getHeight());
1267    const int transformFlags = TransformFlags::MeshIgnoresCanvasTransform;
1268    Glop glop;
1269    Vertex* vertices = &rectangleVertices[0];
1270    GlopBuilder(mRenderState, mCaches, &glop)
1271            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1272            .setMeshIndexedQuads(vertices, rectangleVertices.size() / 4)
1273            .setFillBlack()
1274            .setTransform(*currentSnapshot(), transformFlags)
1275            .setModelViewOffsetRect(0, 0, scissorBox)
1276            .build();
1277    renderGlop(glop);
1278}
1279
1280void OpenGLRenderer::setStencilFromClip() {
1281    if (!Properties::debugOverdraw) {
1282        if (!currentSnapshot()->clipIsSimple()) {
1283            int incrementThreshold;
1284            EVENT_LOGD("setStencilFromClip - enabling");
1285
1286            // NOTE: The order here is important, we must set dirtyClip to false
1287            //       before any draw call to avoid calling back into this method
1288            mState.setDirtyClip(false);
1289
1290            ensureStencilBuffer();
1291
1292            const ClipArea& clipArea = currentSnapshot()->getClipArea();
1293
1294            bool isRectangleList = clipArea.isRectangleList();
1295            if (isRectangleList) {
1296                incrementThreshold = clipArea.getRectangleList().getTransformedRectanglesCount();
1297            } else {
1298                incrementThreshold = 0;
1299            }
1300
1301            mRenderState.stencil().enableWrite(incrementThreshold);
1302
1303            // Clean and update the stencil, but first make sure we restrict drawing
1304            // to the region's bounds
1305            bool resetScissor = mRenderState.scissor().setEnabled(true);
1306            if (resetScissor) {
1307                // The scissor was not set so we now need to update it
1308                setScissorFromClip();
1309            }
1310
1311            mRenderState.stencil().clear();
1312
1313            // stash and disable the outline clip state, since stencil doesn't account for outline
1314            bool storedSkipOutlineClip = mSkipOutlineClip;
1315            mSkipOutlineClip = true;
1316
1317            SkPaint paint;
1318            paint.setColor(SK_ColorBLACK);
1319            paint.setXfermodeMode(SkXfermode::kSrc_Mode);
1320
1321            if (isRectangleList) {
1322                drawRectangleList(clipArea.getRectangleList());
1323            } else {
1324                // NOTE: We could use the region contour path to generate a smaller mesh
1325                //       Since we are using the stencil we could use the red book path
1326                //       drawing technique. It might increase bandwidth usage though.
1327
1328                // The last parameter is important: we are not drawing in the color buffer
1329                // so we don't want to dirty the current layer, if any
1330                drawRegionRects(clipArea.getClipRegion(), paint, false);
1331            }
1332            if (resetScissor) mRenderState.scissor().setEnabled(false);
1333            mSkipOutlineClip = storedSkipOutlineClip;
1334
1335            mRenderState.stencil().enableTest(incrementThreshold);
1336
1337            // Draw the region used to generate the stencil if the appropriate debug
1338            // mode is enabled
1339            // TODO: Implement for rectangle list clip areas
1340            if (Properties::debugStencilClip == StencilClipDebug::ShowRegion
1341                    && !clipArea.isRectangleList()) {
1342                paint.setColor(0x7f0000ff);
1343                paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
1344                drawRegionRects(currentSnapshot()->getClipRegion(), paint);
1345            }
1346        } else {
1347            EVENT_LOGD("setStencilFromClip - disabling");
1348            mRenderState.stencil().disable();
1349        }
1350    }
1351}
1352
1353/**
1354 * Returns false and sets scissor enable based upon bounds if drawing won't be clipped out.
1355 *
1356 * @param paint if not null, the bounds will be expanded to account for stroke depending on paint
1357 *         style, and tessellated AA ramp
1358 */
1359bool OpenGLRenderer::quickRejectSetupScissor(float left, float top, float right, float bottom,
1360        const SkPaint* paint) {
1361    bool snapOut = paint && paint->isAntiAlias();
1362
1363    if (paint && paint->getStyle() != SkPaint::kFill_Style) {
1364        float outset = paint->getStrokeWidth() * 0.5f;
1365        left -= outset;
1366        top -= outset;
1367        right += outset;
1368        bottom += outset;
1369    }
1370
1371    bool clipRequired = false;
1372    bool roundRectClipRequired = false;
1373    if (mState.calculateQuickRejectForScissor(left, top, right, bottom,
1374            &clipRequired, &roundRectClipRequired, snapOut)) {
1375        return true;
1376    }
1377
1378    // not quick rejected, so enable the scissor if clipRequired
1379    mRenderState.scissor().setEnabled(mScissorOptimizationDisabled || clipRequired);
1380    mSkipOutlineClip = !roundRectClipRequired;
1381    return false;
1382}
1383
1384void OpenGLRenderer::debugClip() {
1385#if DEBUG_CLIP_REGIONS
1386    if (!currentSnapshot()->clipRegion->isEmpty()) {
1387        SkPaint paint;
1388        paint.setColor(0x7f00ff00);
1389        drawRegionRects(*(currentSnapshot()->clipRegion, paint);
1390
1391    }
1392#endif
1393}
1394
1395void OpenGLRenderer::renderGlop(const Glop& glop, GlopRenderType type) {
1396    // TODO: It would be best if we could do this before quickRejectSetupScissor()
1397    //       changes the scissor test state
1398    if (type != GlopRenderType::LayerClear) {
1399        // Regular draws need to clear the dirty area on the layer before they start drawing on top
1400        // of it. If this draw *is* a layer clear, it skips the clear step (since it would
1401        // infinitely recurse)
1402        clearLayerRegions();
1403    }
1404
1405    if (mState.getDirtyClip()) {
1406        if (mRenderState.scissor().isEnabled()) {
1407            setScissorFromClip();
1408        }
1409
1410        setStencilFromClip();
1411    }
1412    mRenderState.render(glop, currentSnapshot()->getOrthoMatrix());
1413    if (type == GlopRenderType::Standard && !mRenderState.stencil().isWriteEnabled()) {
1414        // TODO: specify more clearly when a draw should dirty the layer.
1415        // is writing to the stencil the only time we should ignore this?
1416#if !HWUI_NEW_OPS
1417        dirtyLayer(glop.bounds.left, glop.bounds.top, glop.bounds.right, glop.bounds.bottom);
1418#endif
1419        mDirty = true;
1420    }
1421}
1422
1423///////////////////////////////////////////////////////////////////////////////
1424// Drawing
1425///////////////////////////////////////////////////////////////////////////////
1426
1427void OpenGLRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t replayFlags) {
1428    // All the usual checks and setup operations (quickReject, setupDraw, etc.)
1429    // will be performed by the display list itself
1430    if (renderNode && renderNode->isRenderable()) {
1431        // compute 3d ordering
1432        renderNode->computeOrdering();
1433        if (CC_UNLIKELY(Properties::drawDeferDisabled)) {
1434            startFrame();
1435            ReplayStateStruct replayStruct(*this, dirty, replayFlags);
1436            renderNode->replay(replayStruct, 0);
1437            return;
1438        }
1439
1440        DeferredDisplayList deferredList(mState.currentRenderTargetClip());
1441        DeferStateStruct deferStruct(deferredList, *this, replayFlags);
1442        renderNode->defer(deferStruct, 0);
1443
1444        flushLayers();
1445        startFrame();
1446
1447        deferredList.flush(*this, dirty);
1448    } else {
1449        // Even if there is no drawing command(Ex: invisible),
1450        // it still needs startFrame to clear buffer and start tiling.
1451        startFrame();
1452    }
1453}
1454
1455/**
1456 * Important note: this method is intended to draw batches of bitmaps and
1457 * will not set the scissor enable or dirty the current layer, if any.
1458 * The caller is responsible for properly dirtying the current layer.
1459 */
1460void OpenGLRenderer::drawBitmaps(const SkBitmap* bitmap, AssetAtlas::Entry* entry,
1461        int bitmapCount, TextureVertex* vertices, bool pureTranslate,
1462        const Rect& bounds, const SkPaint* paint) {
1463    Texture* texture = entry ? entry->texture : mCaches.textureCache.get(bitmap);
1464    if (!texture) return;
1465
1466    const AutoTexture autoCleanup(texture);
1467
1468    // TODO: remove layer dirty in multi-draw callers
1469    // TODO: snap doesn't need to touch transform, only texture filter.
1470    bool snap = pureTranslate;
1471    const float x = floorf(bounds.left + 0.5f);
1472    const float y = floorf(bounds.top + 0.5f);
1473
1474    const int textureFillFlags = (bitmap->colorType() == kAlpha_8_SkColorType)
1475            ? TextureFillFlags::IsAlphaMaskTexture : TextureFillFlags::None;
1476    const int transformFlags = TransformFlags::MeshIgnoresCanvasTransform;
1477    Glop glop;
1478    GlopBuilder(mRenderState, mCaches, &glop)
1479            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1480            .setMeshTexturedMesh(vertices, bitmapCount * 6)
1481            .setFillTexturePaint(*texture, textureFillFlags, paint, currentSnapshot()->alpha)
1482            .setTransform(*currentSnapshot(), transformFlags)
1483            .setModelViewOffsetRectOptionalSnap(snap, x, y, Rect(bounds.getWidth(), bounds.getHeight()))
1484            .build();
1485    renderGlop(glop, GlopRenderType::Multi);
1486}
1487
1488void OpenGLRenderer::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) {
1489    if (quickRejectSetupScissor(0, 0, bitmap->width(), bitmap->height())) {
1490        return;
1491    }
1492
1493    mCaches.textureState().activateTexture(0);
1494    Texture* texture = getTexture(bitmap);
1495    if (!texture) return;
1496    const AutoTexture autoCleanup(texture);
1497
1498    const int textureFillFlags = (bitmap->colorType() == kAlpha_8_SkColorType)
1499            ? TextureFillFlags::IsAlphaMaskTexture : TextureFillFlags::None;
1500    Glop glop;
1501    GlopBuilder(mRenderState, mCaches, &glop)
1502            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1503            .setMeshTexturedUnitQuad(texture->uvMapper)
1504            .setFillTexturePaint(*texture, textureFillFlags, paint, currentSnapshot()->alpha)
1505            .setTransform(*currentSnapshot(),  TransformFlags::None)
1506            .setModelViewMapUnitToRectSnap(Rect(texture->width(), texture->height()))
1507            .build();
1508    renderGlop(glop);
1509}
1510
1511void OpenGLRenderer::drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
1512        const float* vertices, const int* colors, const SkPaint* paint) {
1513    if (!vertices || mState.currentlyIgnored()) {
1514        return;
1515    }
1516
1517    float left = FLT_MAX;
1518    float top = FLT_MAX;
1519    float right = FLT_MIN;
1520    float bottom = FLT_MIN;
1521
1522    const uint32_t elementCount = meshWidth * meshHeight * 6;
1523
1524    std::unique_ptr<ColorTextureVertex[]> mesh(new ColorTextureVertex[elementCount]);
1525    ColorTextureVertex* vertex = &mesh[0];
1526
1527    std::unique_ptr<int[]> tempColors;
1528    if (!colors) {
1529        uint32_t colorsCount = (meshWidth + 1) * (meshHeight + 1);
1530        tempColors.reset(new int[colorsCount]);
1531        memset(tempColors.get(), 0xff, colorsCount * sizeof(int));
1532        colors = tempColors.get();
1533    }
1534
1535    Texture* texture = mRenderState.assetAtlas().getEntryTexture(bitmap->pixelRef());
1536    const UvMapper& mapper(getMapper(texture));
1537
1538    for (int32_t y = 0; y < meshHeight; y++) {
1539        for (int32_t x = 0; x < meshWidth; x++) {
1540            uint32_t i = (y * (meshWidth + 1) + x) * 2;
1541
1542            float u1 = float(x) / meshWidth;
1543            float u2 = float(x + 1) / meshWidth;
1544            float v1 = float(y) / meshHeight;
1545            float v2 = float(y + 1) / meshHeight;
1546
1547            mapper.map(u1, v1, u2, v2);
1548
1549            int ax = i + (meshWidth + 1) * 2;
1550            int ay = ax + 1;
1551            int bx = i;
1552            int by = bx + 1;
1553            int cx = i + 2;
1554            int cy = cx + 1;
1555            int dx = i + (meshWidth + 1) * 2 + 2;
1556            int dy = dx + 1;
1557
1558            ColorTextureVertex::set(vertex++, vertices[dx], vertices[dy], u2, v2, colors[dx / 2]);
1559            ColorTextureVertex::set(vertex++, vertices[ax], vertices[ay], u1, v2, colors[ax / 2]);
1560            ColorTextureVertex::set(vertex++, vertices[bx], vertices[by], u1, v1, colors[bx / 2]);
1561
1562            ColorTextureVertex::set(vertex++, vertices[dx], vertices[dy], u2, v2, colors[dx / 2]);
1563            ColorTextureVertex::set(vertex++, vertices[bx], vertices[by], u1, v1, colors[bx / 2]);
1564            ColorTextureVertex::set(vertex++, vertices[cx], vertices[cy], u2, v1, colors[cx / 2]);
1565
1566            left = std::min(left, std::min(vertices[ax], std::min(vertices[bx], vertices[cx])));
1567            top = std::min(top, std::min(vertices[ay], std::min(vertices[by], vertices[cy])));
1568            right = std::max(right, std::max(vertices[ax], std::max(vertices[bx], vertices[cx])));
1569            bottom = std::max(bottom, std::max(vertices[ay], std::max(vertices[by], vertices[cy])));
1570        }
1571    }
1572
1573    if (quickRejectSetupScissor(left, top, right, bottom)) {
1574        return;
1575    }
1576
1577    if (!texture) {
1578        texture = mCaches.textureCache.get(bitmap);
1579        if (!texture) {
1580            return;
1581        }
1582    }
1583    const AutoTexture autoCleanup(texture);
1584
1585    /*
1586     * TODO: handle alpha_8 textures correctly by applying paint color, but *not*
1587     * shader in that case to mimic the behavior in SkiaCanvas::drawBitmapMesh.
1588     */
1589    const int textureFillFlags = TextureFillFlags::None;
1590    Glop glop;
1591    GlopBuilder(mRenderState, mCaches, &glop)
1592            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1593            .setMeshColoredTexturedMesh(mesh.get(), elementCount)
1594            .setFillTexturePaint(*texture, textureFillFlags, paint, currentSnapshot()->alpha)
1595            .setTransform(*currentSnapshot(),  TransformFlags::None)
1596            .setModelViewOffsetRect(0, 0, Rect(left, top, right, bottom))
1597            .build();
1598    renderGlop(glop);
1599}
1600
1601void OpenGLRenderer::drawBitmap(const SkBitmap* bitmap, Rect src, Rect dst, const SkPaint* paint) {
1602    if (quickRejectSetupScissor(dst)) {
1603        return;
1604    }
1605
1606    Texture* texture = getTexture(bitmap);
1607    if (!texture) return;
1608    const AutoTexture autoCleanup(texture);
1609
1610    Rect uv(std::max(0.0f, src.left / texture->width()),
1611            std::max(0.0f, src.top / texture->height()),
1612            std::min(1.0f, src.right / texture->width()),
1613            std::min(1.0f, src.bottom / texture->height()));
1614
1615    const int textureFillFlags = (bitmap->colorType() == kAlpha_8_SkColorType)
1616            ? TextureFillFlags::IsAlphaMaskTexture : TextureFillFlags::None;
1617    const bool tryToSnap = MathUtils::areEqual(src.getWidth(), dst.getWidth())
1618            && MathUtils::areEqual(src.getHeight(), dst.getHeight());
1619    Glop glop;
1620    GlopBuilder(mRenderState, mCaches, &glop)
1621            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1622            .setMeshTexturedUvQuad(texture->uvMapper, uv)
1623            .setFillTexturePaint(*texture, textureFillFlags, paint, currentSnapshot()->alpha)
1624            .setTransform(*currentSnapshot(),  TransformFlags::None)
1625            .setModelViewMapUnitToRectOptionalSnap(tryToSnap, dst)
1626            .build();
1627    renderGlop(glop);
1628}
1629
1630void OpenGLRenderer::drawPatch(const SkBitmap* bitmap, const Patch* mesh,
1631        AssetAtlas::Entry* entry, float left, float top, float right, float bottom,
1632        const SkPaint* paint) {
1633    if (!mesh || !mesh->verticesCount || quickRejectSetupScissor(left, top, right, bottom)) {
1634        return;
1635    }
1636
1637    Texture* texture = entry ? entry->texture : mCaches.textureCache.get(bitmap);
1638    if (!texture) return;
1639    const AutoTexture autoCleanup(texture);
1640
1641    // 9 patches are built for stretching - always filter
1642    int textureFillFlags = TextureFillFlags::ForceFilter;
1643    if (bitmap->colorType() == kAlpha_8_SkColorType) {
1644        textureFillFlags |= TextureFillFlags::IsAlphaMaskTexture;
1645    }
1646    Glop glop;
1647    GlopBuilder(mRenderState, mCaches, &glop)
1648            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1649            .setMeshPatchQuads(*mesh)
1650            .setFillTexturePaint(*texture, textureFillFlags, paint, currentSnapshot()->alpha)
1651            .setTransform(*currentSnapshot(),  TransformFlags::None)
1652            .setModelViewOffsetRectSnap(left, top, Rect(right - left, bottom - top)) // TODO: get minimal bounds from patch
1653            .build();
1654    renderGlop(glop);
1655}
1656
1657/**
1658 * Important note: this method is intended to draw batches of 9-patch objects and
1659 * will not set the scissor enable or dirty the current layer, if any.
1660 * The caller is responsible for properly dirtying the current layer.
1661 */
1662void OpenGLRenderer::drawPatches(const SkBitmap* bitmap, AssetAtlas::Entry* entry,
1663        TextureVertex* vertices, uint32_t elementCount, const SkPaint* paint) {
1664    mCaches.textureState().activateTexture(0);
1665    Texture* texture = entry ? entry->texture : mCaches.textureCache.get(bitmap);
1666    if (!texture) return;
1667    const AutoTexture autoCleanup(texture);
1668
1669    // TODO: get correct bounds from caller
1670    const int transformFlags = TransformFlags::MeshIgnoresCanvasTransform;
1671    // 9 patches are built for stretching - always filter
1672    int textureFillFlags = TextureFillFlags::ForceFilter;
1673    if (bitmap->colorType() == kAlpha_8_SkColorType) {
1674        textureFillFlags |= TextureFillFlags::IsAlphaMaskTexture;
1675    }
1676    Glop glop;
1677    GlopBuilder(mRenderState, mCaches, &glop)
1678            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1679            .setMeshTexturedIndexedQuads(vertices, elementCount)
1680            .setFillTexturePaint(*texture, textureFillFlags, paint, currentSnapshot()->alpha)
1681            .setTransform(*currentSnapshot(), transformFlags)
1682            .setModelViewOffsetRect(0, 0, Rect())
1683            .build();
1684    renderGlop(glop, GlopRenderType::Multi);
1685}
1686
1687void OpenGLRenderer::drawVertexBuffer(float translateX, float translateY,
1688        const VertexBuffer& vertexBuffer, const SkPaint* paint, int displayFlags) {
1689    // not missing call to quickReject/dirtyLayer, always done at a higher level
1690    if (!vertexBuffer.getVertexCount()) {
1691        // no vertices to draw
1692        return;
1693    }
1694
1695    bool shadowInterp = displayFlags & kVertexBuffer_ShadowInterp;
1696    const int transformFlags = TransformFlags::OffsetByFudgeFactor;
1697    Glop glop;
1698    GlopBuilder(mRenderState, mCaches, &glop)
1699            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1700            .setMeshVertexBuffer(vertexBuffer)
1701            .setFillPaint(*paint, currentSnapshot()->alpha, shadowInterp)
1702            .setTransform(*currentSnapshot(), transformFlags)
1703            .setModelViewOffsetRect(translateX, translateY, vertexBuffer.getBounds())
1704            .build();
1705    renderGlop(glop);
1706}
1707
1708/**
1709 * Renders a convex path via tessellation. For AA paths, this function uses a similar approach to
1710 * that of AA lines in the drawLines() function.  We expand the convex path by a half pixel in
1711 * screen space in all directions. However, instead of using a fragment shader to compute the
1712 * translucency of the color from its position, we simply use a varying parameter to define how far
1713 * a given pixel is from the edge. For non-AA paths, the expansion and alpha varying are not used.
1714 *
1715 * Doesn't yet support joins, caps, or path effects.
1716 */
1717void OpenGLRenderer::drawConvexPath(const SkPath& path, const SkPaint* paint) {
1718    VertexBuffer vertexBuffer;
1719    // TODO: try clipping large paths to viewport
1720
1721    PathTessellator::tessellatePath(path, paint, *currentTransform(), vertexBuffer);
1722    drawVertexBuffer(vertexBuffer, paint);
1723}
1724
1725/**
1726 * We create tristrips for the lines much like shape stroke tessellation, using a per-vertex alpha
1727 * and additional geometry for defining an alpha slope perimeter.
1728 *
1729 * Using GL_LINES can be difficult because the rasterization rules for those lines produces some
1730 * unexpected results, and may vary between hardware devices. Previously we used a varying-base
1731 * in-shader alpha region, but found it to be taxing on some GPUs.
1732 *
1733 * TODO: try using a fixed input buffer for non-capped lines as in text rendering. this may reduce
1734 * memory transfer by removing need for degenerate vertices.
1735 */
1736void OpenGLRenderer::drawLines(const float* points, int count, const SkPaint* paint) {
1737    if (mState.currentlyIgnored() || count < 4) return;
1738
1739    count &= ~0x3; // round down to nearest four
1740
1741    VertexBuffer buffer;
1742    PathTessellator::tessellateLines(points, count, paint, *currentTransform(), buffer);
1743    const Rect& bounds = buffer.getBounds();
1744
1745    if (quickRejectSetupScissor(bounds.left, bounds.top, bounds.right, bounds.bottom)) {
1746        return;
1747    }
1748
1749    int displayFlags = paint->isAntiAlias() ? 0 : kVertexBuffer_Offset;
1750    drawVertexBuffer(buffer, paint, displayFlags);
1751}
1752
1753void OpenGLRenderer::drawPoints(const float* points, int count, const SkPaint* paint) {
1754    if (mState.currentlyIgnored() || count < 2) return;
1755
1756    count &= ~0x1; // round down to nearest two
1757
1758    VertexBuffer buffer;
1759    PathTessellator::tessellatePoints(points, count, paint, *currentTransform(), buffer);
1760
1761    const Rect& bounds = buffer.getBounds();
1762    if (quickRejectSetupScissor(bounds.left, bounds.top, bounds.right, bounds.bottom)) {
1763        return;
1764    }
1765
1766    int displayFlags = paint->isAntiAlias() ? 0 : kVertexBuffer_Offset;
1767    drawVertexBuffer(buffer, paint, displayFlags);
1768
1769    mDirty = true;
1770}
1771
1772void OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) {
1773    // No need to check against the clip, we fill the clip region
1774    if (mState.currentlyIgnored()) return;
1775
1776    Rect clip(mState.currentRenderTargetClip());
1777    clip.snapToPixelBoundaries();
1778
1779    SkPaint paint;
1780    paint.setColor(color);
1781    paint.setXfermodeMode(mode);
1782
1783    drawColorRect(clip.left, clip.top, clip.right, clip.bottom, &paint, true);
1784
1785    mDirty = true;
1786}
1787
1788void OpenGLRenderer::drawShape(float left, float top, PathTexture* texture,
1789        const SkPaint* paint) {
1790    if (!texture) return;
1791    const AutoTexture autoCleanup(texture);
1792
1793    const float x = left + texture->left - texture->offset;
1794    const float y = top + texture->top - texture->offset;
1795
1796    drawPathTexture(texture, x, y, paint);
1797
1798    mDirty = true;
1799}
1800
1801void OpenGLRenderer::drawRoundRect(float left, float top, float right, float bottom,
1802        float rx, float ry, const SkPaint* p) {
1803    if (mState.currentlyIgnored()
1804            || quickRejectSetupScissor(left, top, right, bottom, p)
1805            || PaintUtils::paintWillNotDraw(*p)) {
1806        return;
1807    }
1808
1809    if (p->getPathEffect() != nullptr) {
1810        mCaches.textureState().activateTexture(0);
1811        PathTexture* texture = mCaches.pathCache.getRoundRect(
1812                right - left, bottom - top, rx, ry, p);
1813        drawShape(left, top, texture, p);
1814    } else {
1815        const VertexBuffer* vertexBuffer = mCaches.tessellationCache.getRoundRect(
1816                *currentTransform(), *p, right - left, bottom - top, rx, ry);
1817        drawVertexBuffer(left, top, *vertexBuffer, p);
1818    }
1819}
1820
1821void OpenGLRenderer::drawCircle(float x, float y, float radius, const SkPaint* p) {
1822    if (mState.currentlyIgnored()
1823            || quickRejectSetupScissor(x - radius, y - radius, x + radius, y + radius, p)
1824            || PaintUtils::paintWillNotDraw(*p)) {
1825        return;
1826    }
1827
1828    if (p->getPathEffect() != nullptr) {
1829        mCaches.textureState().activateTexture(0);
1830        PathTexture* texture = mCaches.pathCache.getCircle(radius, p);
1831        drawShape(x - radius, y - radius, texture, p);
1832        return;
1833    }
1834
1835    SkPath path;
1836    if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
1837        path.addCircle(x, y, radius + p->getStrokeWidth() / 2);
1838    } else {
1839        path.addCircle(x, y, radius);
1840    }
1841
1842#if !HWUI_NEW_OPS
1843    if (CC_UNLIKELY(currentSnapshot()->projectionPathMask != nullptr)) {
1844        // mask ripples with projection mask
1845        SkPath maskPath = *(currentSnapshot()->projectionPathMask->projectionMask);
1846
1847        Matrix4 screenSpaceTransform;
1848        currentSnapshot()->buildScreenSpaceTransform(&screenSpaceTransform);
1849
1850        Matrix4 totalTransform;
1851        totalTransform.loadInverse(screenSpaceTransform);
1852        totalTransform.multiply(currentSnapshot()->projectionPathMask->projectionMaskTransform);
1853
1854        SkMatrix skTotalTransform;
1855        totalTransform.copyTo(skTotalTransform);
1856        maskPath.transform(skTotalTransform);
1857
1858        // Mask the ripple path by the projection mask, now that it's
1859        // in local space. Note that this can create CCW paths.
1860        Op(path, maskPath, kIntersect_SkPathOp, &path);
1861    }
1862#endif
1863    drawConvexPath(path, p);
1864}
1865
1866void OpenGLRenderer::drawOval(float left, float top, float right, float bottom,
1867        const SkPaint* p) {
1868    if (mState.currentlyIgnored()
1869            || quickRejectSetupScissor(left, top, right, bottom, p)
1870            || PaintUtils::paintWillNotDraw(*p)) {
1871        return;
1872    }
1873
1874    if (p->getPathEffect() != nullptr) {
1875        mCaches.textureState().activateTexture(0);
1876        PathTexture* texture = mCaches.pathCache.getOval(right - left, bottom - top, p);
1877        drawShape(left, top, texture, p);
1878    } else {
1879        SkPath path;
1880        SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
1881        if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
1882            rect.outset(p->getStrokeWidth() / 2, p->getStrokeWidth() / 2);
1883        }
1884        path.addOval(rect);
1885        drawConvexPath(path, p);
1886    }
1887}
1888
1889void OpenGLRenderer::drawArc(float left, float top, float right, float bottom,
1890        float startAngle, float sweepAngle, bool useCenter, const SkPaint* p) {
1891    if (mState.currentlyIgnored()
1892            || quickRejectSetupScissor(left, top, right, bottom, p)
1893            || PaintUtils::paintWillNotDraw(*p)) {
1894        return;
1895    }
1896
1897    // TODO: support fills (accounting for concavity if useCenter && sweepAngle > 180)
1898    if (p->getStyle() != SkPaint::kStroke_Style || p->getPathEffect() != nullptr || useCenter) {
1899        mCaches.textureState().activateTexture(0);
1900        PathTexture* texture = mCaches.pathCache.getArc(right - left, bottom - top,
1901                startAngle, sweepAngle, useCenter, p);
1902        drawShape(left, top, texture, p);
1903        return;
1904    }
1905    SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
1906    if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
1907        rect.outset(p->getStrokeWidth() / 2, p->getStrokeWidth() / 2);
1908    }
1909
1910    SkPath path;
1911    if (useCenter) {
1912        path.moveTo(rect.centerX(), rect.centerY());
1913    }
1914    path.arcTo(rect, startAngle, sweepAngle, !useCenter);
1915    if (useCenter) {
1916        path.close();
1917    }
1918    drawConvexPath(path, p);
1919}
1920
1921void OpenGLRenderer::drawRect(float left, float top, float right, float bottom,
1922        const SkPaint* p) {
1923    if (mState.currentlyIgnored()
1924            || quickRejectSetupScissor(left, top, right, bottom, p)
1925            || PaintUtils::paintWillNotDraw(*p)) {
1926        return;
1927    }
1928
1929    if (p->getStyle() != SkPaint::kFill_Style) {
1930        // only fill style is supported by drawConvexPath, since others have to handle joins
1931        static_assert(SkPaintDefaults_MiterLimit == 4.0f, "Miter limit has changed");
1932        if (p->getPathEffect() != nullptr || p->getStrokeJoin() != SkPaint::kMiter_Join ||
1933                p->getStrokeMiter() != SkPaintDefaults_MiterLimit) {
1934            mCaches.textureState().activateTexture(0);
1935            PathTexture* texture =
1936                    mCaches.pathCache.getRect(right - left, bottom - top, p);
1937            drawShape(left, top, texture, p);
1938        } else {
1939            SkPath path;
1940            SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
1941            if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
1942                rect.outset(p->getStrokeWidth() / 2, p->getStrokeWidth() / 2);
1943            }
1944            path.addRect(rect);
1945            drawConvexPath(path, p);
1946        }
1947    } else {
1948        if (p->isAntiAlias() && !currentTransform()->isSimple()) {
1949            SkPath path;
1950            path.addRect(left, top, right, bottom);
1951            drawConvexPath(path, p);
1952        } else {
1953            drawColorRect(left, top, right, bottom, p);
1954
1955            mDirty = true;
1956        }
1957    }
1958}
1959
1960void OpenGLRenderer::drawTextShadow(const SkPaint* paint, const glyph_t* glyphs,
1961        int count, const float* positions,
1962        FontRenderer& fontRenderer, int alpha, float x, float y) {
1963    mCaches.textureState().activateTexture(0);
1964
1965    PaintUtils::TextShadow textShadow;
1966    if (!PaintUtils::getTextShadow(paint, &textShadow)) {
1967        LOG_ALWAYS_FATAL("failed to query shadow attributes");
1968    }
1969
1970    // NOTE: The drop shadow will not perform gamma correction
1971    //       if shader-based correction is enabled
1972    mCaches.dropShadowCache.setFontRenderer(fontRenderer);
1973    ShadowTexture* texture = mCaches.dropShadowCache.get(
1974            paint, glyphs, count, textShadow.radius, positions);
1975    // If the drop shadow exceeds the max texture size or couldn't be
1976    // allocated, skip drawing
1977    if (!texture) return;
1978    const AutoTexture autoCleanup(texture);
1979
1980    const float sx = x - texture->left + textShadow.dx;
1981    const float sy = y - texture->top + textShadow.dy;
1982
1983    Glop glop;
1984    GlopBuilder(mRenderState, mCaches, &glop)
1985            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
1986            .setMeshTexturedUnitQuad(nullptr)
1987            .setFillShadowTexturePaint(*texture, textShadow.color, *paint, currentSnapshot()->alpha)
1988            .setTransform(*currentSnapshot(),  TransformFlags::None)
1989            .setModelViewMapUnitToRect(Rect(sx, sy, sx + texture->width(), sy + texture->height()))
1990            .build();
1991    renderGlop(glop);
1992}
1993
1994// TODO: remove this, once mState.currentlyIgnored captures snapshot alpha
1995bool OpenGLRenderer::canSkipText(const SkPaint* paint) const {
1996    float alpha = (PaintUtils::hasTextShadow(paint)
1997            ? 1.0f : paint->getAlpha()) * currentSnapshot()->alpha;
1998    return MathUtils::isZero(alpha)
1999            && PaintUtils::getXfermode(paint->getXfermode()) == SkXfermode::kSrcOver_Mode;
2000}
2001
2002bool OpenGLRenderer::findBestFontTransform(const mat4& transform, SkMatrix* outMatrix) const {
2003    if (CC_LIKELY(transform.isPureTranslate())) {
2004        outMatrix->setIdentity();
2005        return false;
2006    } else if (CC_UNLIKELY(transform.isPerspective())) {
2007        outMatrix->setIdentity();
2008        return true;
2009    }
2010
2011    /**
2012     * Input is a non-perspective, scaling transform. Generate a scale-only transform,
2013     * with values rounded to the nearest int.
2014     */
2015    float sx, sy;
2016    transform.decomposeScale(sx, sy);
2017    outMatrix->setScale(
2018            roundf(std::max(1.0f, sx)),
2019            roundf(std::max(1.0f, sy)));
2020    return true;
2021}
2022
2023int OpenGLRenderer::getSaveCount() const {
2024    return mState.getSaveCount();
2025}
2026
2027int OpenGLRenderer::save(int flags) {
2028    return mState.save(flags);
2029}
2030
2031void OpenGLRenderer::restore() {
2032    mState.restore();
2033}
2034
2035void OpenGLRenderer::restoreToCount(int saveCount) {
2036    mState.restoreToCount(saveCount);
2037}
2038
2039
2040void OpenGLRenderer::translate(float dx, float dy, float dz) {
2041    mState.translate(dx, dy, dz);
2042}
2043
2044void OpenGLRenderer::rotate(float degrees) {
2045    mState.rotate(degrees);
2046}
2047
2048void OpenGLRenderer::scale(float sx, float sy) {
2049    mState.scale(sx, sy);
2050}
2051
2052void OpenGLRenderer::skew(float sx, float sy) {
2053    mState.skew(sx, sy);
2054}
2055
2056void OpenGLRenderer::setLocalMatrix(const Matrix4& matrix) {
2057    mState.setMatrix(mBaseTransform);
2058    mState.concatMatrix(matrix);
2059}
2060
2061void OpenGLRenderer::setLocalMatrix(const SkMatrix& matrix) {
2062    mState.setMatrix(mBaseTransform);
2063    mState.concatMatrix(matrix);
2064}
2065
2066void OpenGLRenderer::concatMatrix(const Matrix4& matrix) {
2067    mState.concatMatrix(matrix);
2068}
2069
2070bool OpenGLRenderer::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {
2071    return mState.clipRect(left, top, right, bottom, op);
2072}
2073
2074bool OpenGLRenderer::clipPath(const SkPath* path, SkRegion::Op op) {
2075    return mState.clipPath(path, op);
2076}
2077
2078bool OpenGLRenderer::clipRegion(const SkRegion* region, SkRegion::Op op) {
2079    return mState.clipRegion(region, op);
2080}
2081
2082void OpenGLRenderer::setClippingOutline(LinearAllocator& allocator, const Outline* outline) {
2083    mState.setClippingOutline(allocator, outline);
2084}
2085
2086void OpenGLRenderer::setClippingRoundRect(LinearAllocator& allocator,
2087        const Rect& rect, float radius, bool highPriority) {
2088    mState.setClippingRoundRect(allocator, rect, radius, highPriority);
2089}
2090
2091void OpenGLRenderer::setProjectionPathMask(LinearAllocator& allocator, const SkPath* path) {
2092    mState.setProjectionPathMask(allocator, path);
2093}
2094
2095void OpenGLRenderer::drawText(const glyph_t* glyphs, int bytesCount, int count, float x, float y,
2096        const float* positions, const SkPaint* paint, float totalAdvance, const Rect& bounds,
2097        DrawOpMode drawOpMode) {
2098
2099    if (drawOpMode == DrawOpMode::kImmediate) {
2100        // The checks for corner-case ignorable text and quick rejection is only done for immediate
2101        // drawing as ops from DeferredDisplayList are already filtered for these
2102        if (glyphs == nullptr || count == 0 || mState.currentlyIgnored() || canSkipText(paint) ||
2103                quickRejectSetupScissor(bounds)) {
2104            return;
2105        }
2106    }
2107
2108    const float oldX = x;
2109    const float oldY = y;
2110
2111    const mat4& transform = *currentTransform();
2112    const bool pureTranslate = transform.isPureTranslate();
2113
2114    if (CC_LIKELY(pureTranslate)) {
2115        x = floorf(x + transform.getTranslateX() + 0.5f);
2116        y = floorf(y + transform.getTranslateY() + 0.5f);
2117    }
2118
2119    int alpha = PaintUtils::getAlphaDirect(paint) * currentSnapshot()->alpha;
2120    SkXfermode::Mode mode = PaintUtils::getXfermodeDirect(paint);
2121
2122    FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
2123
2124    if (CC_UNLIKELY(PaintUtils::hasTextShadow(paint))) {
2125        fontRenderer.setFont(paint, SkMatrix::I());
2126        drawTextShadow(paint, glyphs, count, positions, fontRenderer,
2127                alpha, oldX, oldY);
2128    }
2129
2130    const bool hasActiveLayer = hasLayer();
2131
2132    // We only pass a partial transform to the font renderer. That partial
2133    // matrix defines how glyphs are rasterized. Typically we want glyphs
2134    // to be rasterized at their final size on screen, which means the partial
2135    // matrix needs to take the scale factor into account.
2136    // When a partial matrix is used to transform glyphs during rasterization,
2137    // the mesh is generated with the inverse transform (in the case of scale,
2138    // the mesh is generated at 1.0 / scale for instance.) This allows us to
2139    // apply the full transform matrix at draw time in the vertex shader.
2140    // Applying the full matrix in the shader is the easiest way to handle
2141    // rotation and perspective and allows us to always generated quads in the
2142    // font renderer which greatly simplifies the code, clipping in particular.
2143    SkMatrix fontTransform;
2144    bool linearFilter = findBestFontTransform(transform, &fontTransform)
2145            || fabs(y - (int) y) > 0.0f
2146            || fabs(x - (int) x) > 0.0f;
2147    fontRenderer.setFont(paint, fontTransform);
2148    fontRenderer.setTextureFiltering(linearFilter);
2149
2150    // TODO: Implement better clipping for scaled/rotated text
2151    const Rect* clip = !pureTranslate ? nullptr : &mState.currentRenderTargetClip();
2152    Rect layerBounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
2153
2154    bool status;
2155#if HWUI_NEW_OPS
2156    LOG_ALWAYS_FATAL("unsupported");
2157    TextDrawFunctor functor(nullptr, nullptr, nullptr, x, y, pureTranslate, alpha, mode, paint);
2158#else
2159    TextDrawFunctor functor(this, x, y, pureTranslate, alpha, mode, paint);
2160#endif
2161
2162    // don't call issuedrawcommand, do it at end of batch
2163    bool forceFinish = (drawOpMode != DrawOpMode::kDefer);
2164    if (CC_UNLIKELY(paint->getTextAlign() != SkPaint::kLeft_Align)) {
2165        SkPaint paintCopy(*paint);
2166        paintCopy.setTextAlign(SkPaint::kLeft_Align);
2167        status = fontRenderer.renderPosText(&paintCopy, clip, glyphs, count, x, y,
2168                positions, hasActiveLayer ? &layerBounds : nullptr, &functor, forceFinish);
2169    } else {
2170        status = fontRenderer.renderPosText(paint, clip, glyphs, count, x, y,
2171                positions, hasActiveLayer ? &layerBounds : nullptr, &functor, forceFinish);
2172    }
2173
2174    if ((status || drawOpMode != DrawOpMode::kImmediate) && hasActiveLayer) {
2175        if (!pureTranslate) {
2176            transform.mapRect(layerBounds);
2177        }
2178        dirtyLayerUnchecked(layerBounds, getRegion());
2179    }
2180
2181    mDirty = true;
2182}
2183
2184void OpenGLRenderer::drawTextOnPath(const glyph_t* glyphs, int bytesCount, int count,
2185        const SkPath* path, float hOffset, float vOffset, const SkPaint* paint) {
2186    if (glyphs == nullptr || count == 0 || mState.currentlyIgnored() || canSkipText(paint)) {
2187        return;
2188    }
2189
2190    // TODO: avoid scissor by calculating maximum bounds using path bounds + font metrics
2191    mRenderState.scissor().setEnabled(true);
2192
2193    FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
2194    fontRenderer.setFont(paint, SkMatrix::I());
2195    fontRenderer.setTextureFiltering(true);
2196
2197    int alpha = PaintUtils::getAlphaDirect(paint) * currentSnapshot()->alpha;
2198    SkXfermode::Mode mode = PaintUtils::getXfermodeDirect(paint);
2199#if HWUI_NEW_OPS
2200    LOG_ALWAYS_FATAL("unsupported");
2201    TextDrawFunctor functor(nullptr, nullptr, nullptr, 0.0f, 0.0f, false, alpha, mode, paint);
2202#else
2203    TextDrawFunctor functor(this, 0.0f, 0.0f, false, alpha, mode, paint);
2204#endif
2205
2206    const Rect* clip = &writableSnapshot()->getLocalClip();
2207    Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
2208
2209    if (fontRenderer.renderTextOnPath(paint, clip, glyphs, count, path,
2210            hOffset, vOffset, hasLayer() ? &bounds : nullptr, &functor)) {
2211        dirtyLayer(bounds.left, bounds.top, bounds.right, bounds.bottom, *currentTransform());
2212        mDirty = true;
2213    }
2214}
2215
2216void OpenGLRenderer::drawPath(const SkPath* path, const SkPaint* paint) {
2217    if (mState.currentlyIgnored()) return;
2218
2219    mCaches.textureState().activateTexture(0);
2220
2221    PathTexture* texture = mCaches.pathCache.get(path, paint);
2222    if (!texture) return;
2223
2224    const float x = texture->left - texture->offset;
2225    const float y = texture->top - texture->offset;
2226
2227    drawPathTexture(texture, x, y, paint);
2228
2229    if (texture->cleanup) {
2230        mCaches.pathCache.remove(path, paint);
2231    }
2232    mDirty = true;
2233}
2234
2235void OpenGLRenderer::drawLayer(Layer* layer) {
2236    if (!layer) {
2237        return;
2238    }
2239
2240    mat4* transform = nullptr;
2241    if (layer->isTextureLayer()) {
2242        transform = &layer->getTransform();
2243        if (!transform->isIdentity()) {
2244            save(SaveFlags::Matrix);
2245            concatMatrix(*transform);
2246        }
2247    }
2248
2249    bool clipRequired = false;
2250    const bool rejected = mState.calculateQuickRejectForScissor(
2251            0, 0, layer->layer.getWidth(), layer->layer.getHeight(),
2252            &clipRequired, nullptr, false);
2253
2254    if (rejected) {
2255        if (transform && !transform->isIdentity()) {
2256            restore();
2257        }
2258        return;
2259    }
2260
2261    EVENT_LOGD("drawLayer," RECT_STRING ", clipRequired %d", x, y,
2262            x + layer->layer.getWidth(), y + layer->layer.getHeight(), clipRequired);
2263
2264    updateLayer(layer, true);
2265
2266    mRenderState.scissor().setEnabled(mScissorOptimizationDisabled || clipRequired);
2267    mCaches.textureState().activateTexture(0);
2268
2269    if (CC_LIKELY(!layer->region.isEmpty())) {
2270        if (layer->region.isRect()) {
2271            DRAW_DOUBLE_STENCIL_IF(!layer->hasDrawnSinceUpdate,
2272                    composeLayerRect(layer, layer->regionRect));
2273        } else if (layer->mesh) {
2274            Glop glop;
2275            GlopBuilder(mRenderState, mCaches, &glop)
2276                    .setRoundRectClipState(currentSnapshot()->roundRectClipState)
2277                    .setMeshTexturedIndexedQuads(layer->mesh, layer->meshElementCount)
2278                    .setFillLayer(layer->getTexture(), layer->getColorFilter(), getLayerAlpha(layer), layer->getMode(), Blend::ModeOrderSwap::NoSwap)
2279                    .setTransform(*currentSnapshot(),  TransformFlags::None)
2280                    .setModelViewOffsetRectSnap(0, 0, Rect(layer->layer.getWidth(), layer->layer.getHeight()))
2281                    .build();
2282            DRAW_DOUBLE_STENCIL_IF(!layer->hasDrawnSinceUpdate, renderGlop(glop));
2283#if DEBUG_LAYERS_AS_REGIONS
2284            drawRegionRectsDebug(layer->region);
2285#endif
2286        }
2287
2288        if (layer->debugDrawUpdate) {
2289            layer->debugDrawUpdate = false;
2290
2291            SkPaint paint;
2292            paint.setColor(0x7f00ff00);
2293            drawColorRect(0, 0, layer->layer.getWidth(), layer->layer.getHeight(), &paint);
2294        }
2295    }
2296    layer->hasDrawnSinceUpdate = true;
2297
2298    if (transform && !transform->isIdentity()) {
2299        restore();
2300    }
2301
2302    mDirty = true;
2303}
2304
2305///////////////////////////////////////////////////////////////////////////////
2306// Draw filters
2307///////////////////////////////////////////////////////////////////////////////
2308void OpenGLRenderer::setDrawFilter(SkDrawFilter* filter) {
2309    // We should never get here since we apply the draw filter when stashing
2310    // the paints in the DisplayList.
2311    LOG_ALWAYS_FATAL("OpenGLRenderer does not directly support DrawFilters");
2312}
2313
2314///////////////////////////////////////////////////////////////////////////////
2315// Drawing implementation
2316///////////////////////////////////////////////////////////////////////////////
2317
2318Texture* OpenGLRenderer::getTexture(const SkBitmap* bitmap) {
2319    Texture* texture = mRenderState.assetAtlas().getEntryTexture(bitmap->pixelRef());
2320    if (!texture) {
2321        return mCaches.textureCache.get(bitmap);
2322    }
2323    return texture;
2324}
2325
2326void OpenGLRenderer::drawPathTexture(PathTexture* texture, float x, float y,
2327        const SkPaint* paint) {
2328    if (quickRejectSetupScissor(x, y, x + texture->width(), y + texture->height())) {
2329        return;
2330    }
2331
2332    Glop glop;
2333    GlopBuilder(mRenderState, mCaches, &glop)
2334            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
2335            .setMeshTexturedUnitQuad(nullptr)
2336            .setFillPathTexturePaint(*texture, *paint, currentSnapshot()->alpha)
2337            .setTransform(*currentSnapshot(),  TransformFlags::None)
2338            .setModelViewMapUnitToRect(Rect(x, y, x + texture->width(), y + texture->height()))
2339            .build();
2340    renderGlop(glop);
2341}
2342
2343void OpenGLRenderer::drawRects(const float* rects, int count, const SkPaint* paint) {
2344    if (mState.currentlyIgnored()) {
2345        return;
2346    }
2347
2348    drawColorRects(rects, count, paint, false, true, true);
2349}
2350
2351void OpenGLRenderer::drawShadow(float casterAlpha,
2352        const VertexBuffer* ambientShadowVertexBuffer, const VertexBuffer* spotShadowVertexBuffer) {
2353    if (mState.currentlyIgnored()) return;
2354
2355    // TODO: use quickRejectWithScissor. For now, always force enable scissor.
2356    mRenderState.scissor().setEnabled(true);
2357
2358    SkPaint paint;
2359    paint.setAntiAlias(true); // want to use AlphaVertex
2360
2361    // The caller has made sure casterAlpha > 0.
2362    float ambientShadowAlpha = mAmbientShadowAlpha;
2363    if (CC_UNLIKELY(Properties::overrideAmbientShadowStrength >= 0)) {
2364        ambientShadowAlpha = Properties::overrideAmbientShadowStrength;
2365    }
2366    if (ambientShadowVertexBuffer && ambientShadowAlpha > 0) {
2367        paint.setARGB(casterAlpha * ambientShadowAlpha, 0, 0, 0);
2368        drawVertexBuffer(*ambientShadowVertexBuffer, &paint, kVertexBuffer_ShadowInterp);
2369    }
2370
2371    float spotShadowAlpha = mSpotShadowAlpha;
2372    if (CC_UNLIKELY(Properties::overrideSpotShadowStrength >= 0)) {
2373        spotShadowAlpha = Properties::overrideSpotShadowStrength;
2374    }
2375    if (spotShadowVertexBuffer && spotShadowAlpha > 0) {
2376        paint.setARGB(casterAlpha * spotShadowAlpha, 0, 0, 0);
2377        drawVertexBuffer(*spotShadowVertexBuffer, &paint, kVertexBuffer_ShadowInterp);
2378    }
2379
2380    mDirty=true;
2381}
2382
2383void OpenGLRenderer::drawColorRects(const float* rects, int count, const SkPaint* paint,
2384        bool ignoreTransform, bool dirty, bool clip) {
2385    if (count == 0) {
2386        return;
2387    }
2388
2389    float left = FLT_MAX;
2390    float top = FLT_MAX;
2391    float right = FLT_MIN;
2392    float bottom = FLT_MIN;
2393
2394    Vertex mesh[count];
2395    Vertex* vertex = mesh;
2396
2397    for (int index = 0; index < count; index += 4) {
2398        float l = rects[index + 0];
2399        float t = rects[index + 1];
2400        float r = rects[index + 2];
2401        float b = rects[index + 3];
2402
2403        Vertex::set(vertex++, l, t);
2404        Vertex::set(vertex++, r, t);
2405        Vertex::set(vertex++, l, b);
2406        Vertex::set(vertex++, r, b);
2407
2408        left = std::min(left, l);
2409        top = std::min(top, t);
2410        right = std::max(right, r);
2411        bottom = std::max(bottom, b);
2412    }
2413
2414    if (clip && quickRejectSetupScissor(left, top, right, bottom)) {
2415        return;
2416    }
2417
2418    const int transformFlags = ignoreTransform
2419            ? TransformFlags::MeshIgnoresCanvasTransform : TransformFlags::None;
2420    Glop glop;
2421    GlopBuilder(mRenderState, mCaches, &glop)
2422            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
2423            .setMeshIndexedQuads(&mesh[0], count / 4)
2424            .setFillPaint(*paint, currentSnapshot()->alpha)
2425            .setTransform(*currentSnapshot(), transformFlags)
2426            .setModelViewOffsetRect(0, 0, Rect(left, top, right, bottom))
2427            .build();
2428    renderGlop(glop);
2429}
2430
2431void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom,
2432        const SkPaint* paint, bool ignoreTransform) {
2433    const int transformFlags = ignoreTransform
2434            ? TransformFlags::MeshIgnoresCanvasTransform : TransformFlags::None;
2435    Glop glop;
2436    GlopBuilder(mRenderState, mCaches, &glop)
2437            .setRoundRectClipState(currentSnapshot()->roundRectClipState)
2438            .setMeshUnitQuad()
2439            .setFillPaint(*paint, currentSnapshot()->alpha)
2440            .setTransform(*currentSnapshot(), transformFlags)
2441            .setModelViewMapUnitToRect(Rect(left, top, right, bottom))
2442            .build();
2443    renderGlop(glop);
2444}
2445
2446float OpenGLRenderer::getLayerAlpha(const Layer* layer) const {
2447    return (layer->getAlpha() / 255.0f) * currentSnapshot()->alpha;
2448}
2449
2450}; // namespace uirenderer
2451}; // namespace android
2452