BakedOpDispatcher.cpp revision b2e36d7939610de538a6ec95a821b61b365b3073 
1/*
2 * Copyright (C) 2015 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 "BakedOpDispatcher.h"
18
19#include "BakedOpRenderer.h"
20#include "Caches.h"
21#include "Glop.h"
22#include "GlopBuilder.h"
23#include "Patch.h"
24#include "PathTessellator.h"
25#include "renderstate/OffscreenBufferPool.h"
26#include "renderstate/RenderState.h"
27#include "utils/GLUtils.h"
28#include "VertexBuffer.h"
29
30#include <algorithm>
31#include <math.h>
32#include <SkPaintDefaults.h>
33#include <SkPathOps.h>
34
35namespace android {
36namespace uirenderer {
37
38static void storeTexturedRect(TextureVertex* vertices, const Rect& bounds, const Rect& texCoord) {
39    vertices[0] = { bounds.left, bounds.top, texCoord.left, texCoord.top };
40    vertices[1] = { bounds.right, bounds.top, texCoord.right, texCoord.top };
41    vertices[2] = { bounds.left, bounds.bottom, texCoord.left, texCoord.bottom };
42    vertices[3] = { bounds.right, bounds.bottom, texCoord.right, texCoord.bottom };
43}
44
45void BakedOpDispatcher::onMergedBitmapOps(BakedOpRenderer& renderer,
46        const MergedBakedOpList& opList) {
47
48    const BakedOpState& firstState = *(opList.states[0]);
49    const SkBitmap* bitmap = (static_cast<const BitmapOp*>(opList.states[0]->op))->bitmap;
50
51    AssetAtlas::Entry* entry = renderer.renderState().assetAtlas().getEntry(bitmap->pixelRef());
52    Texture* texture = entry ? entry->texture : renderer.caches().textureCache.get(bitmap);
53    if (!texture) return;
54    const AutoTexture autoCleanup(texture);
55
56    TextureVertex vertices[opList.count * 4];
57    Rect texCoords(0, 0, 1, 1);
58    if (entry) {
59        entry->uvMapper.map(texCoords);
60    }
61    for (size_t i = 0; i < opList.count; i++) {
62        const BakedOpState& state = *(opList.states[i]);
63        TextureVertex* rectVerts = &vertices[i * 4];
64
65        // calculate unclipped bounds, since they'll determine texture coordinates
66        Rect opBounds = state.op->unmappedBounds;
67        state.computedState.transform.mapRect(opBounds);
68        if (CC_LIKELY(state.computedState.transform.isPureTranslate())) {
69            // pure translate, so snap (same behavior as onBitmapOp)
70            opBounds.snapToPixelBoundaries();
71        }
72        storeTexturedRect(rectVerts, opBounds, texCoords);
73        renderer.dirtyRenderTarget(opBounds);
74    }
75
76    const int textureFillFlags = (bitmap->colorType() == kAlpha_8_SkColorType)
77            ? TextureFillFlags::IsAlphaMaskTexture : TextureFillFlags::None;
78    Glop glop;
79    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
80            .setRoundRectClipState(firstState.roundRectClipState)
81            .setMeshTexturedIndexedQuads(vertices, opList.count * 6)
82            .setFillTexturePaint(*texture, textureFillFlags, firstState.op->paint, firstState.alpha)
83            .setTransform(Matrix4::identity(), TransformFlags::None)
84            .setModelViewIdentityEmptyBounds()
85            .build();
86    ClipRect renderTargetClip(opList.clip);
87    const ClipBase* clip = opList.clipSideFlags ? &renderTargetClip : nullptr;
88    renderer.renderGlop(nullptr, clip, glop);
89}
90
91void BakedOpDispatcher::onMergedPatchOps(BakedOpRenderer& renderer,
92        const MergedBakedOpList& opList) {
93    const PatchOp& firstOp = *(static_cast<const PatchOp*>(opList.states[0]->op));
94    const BakedOpState& firstState = *(opList.states[0]);
95    AssetAtlas::Entry* entry = renderer.renderState().assetAtlas().getEntry(
96            firstOp.bitmap->pixelRef());
97
98    // Batches will usually contain a small number of items so it's
99    // worth performing a first iteration to count the exact number
100    // of vertices we need in the new mesh
101    uint32_t totalVertices = 0;
102
103    for (size_t i = 0; i < opList.count; i++) {
104        const PatchOp& op = *(static_cast<const PatchOp*>(opList.states[i]->op));
105
106        // TODO: cache mesh lookups
107        const Patch* opMesh = renderer.caches().patchCache.get(
108                entry, op.bitmap->width(), op.bitmap->height(),
109                op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.patch);
110        totalVertices += opMesh->verticesCount;
111    }
112
113    const bool dirtyRenderTarget = renderer.offscreenRenderTarget();
114
115    uint32_t indexCount = 0;
116
117    TextureVertex vertices[totalVertices];
118    TextureVertex* vertex = &vertices[0];
119    // Create a mesh that contains the transformed vertices for all the
120    // 9-patch objects that are part of the batch. Note that onDefer()
121    // enforces ops drawn by this function to have a pure translate or
122    // identity matrix
123    for (size_t i = 0; i < opList.count; i++) {
124        const PatchOp& op = *(static_cast<const PatchOp*>(opList.states[i]->op));
125        const BakedOpState& state = *opList.states[i];
126
127        // TODO: cache mesh lookups
128        const Patch* opMesh = renderer.caches().patchCache.get(
129                entry, op.bitmap->width(), op.bitmap->height(),
130                op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.patch);
131
132
133        uint32_t vertexCount = opMesh->verticesCount;
134        if (vertexCount == 0) continue;
135
136        // We use the bounds to know where to translate our vertices
137        // Using patchOp->state.mBounds wouldn't work because these
138        // bounds are clipped
139        const float tx = floorf(state.computedState.transform.getTranslateX()
140                + op.unmappedBounds.left + 0.5f);
141        const float ty = floorf(state.computedState.transform.getTranslateY()
142                + op.unmappedBounds.top + 0.5f);
143
144        // Copy & transform all the vertices for the current operation
145        TextureVertex* opVertices = opMesh->vertices.get();
146        for (uint32_t j = 0; j < vertexCount; j++, opVertices++) {
147            TextureVertex::set(vertex++,
148                    opVertices->x + tx, opVertices->y + ty,
149                    opVertices->u, opVertices->v);
150        }
151
152        // Dirty the current layer if possible. When the 9-patch does not
153        // contain empty quads we can take a shortcut and simply set the
154        // dirty rect to the object's bounds.
155        if (dirtyRenderTarget) {
156            if (!opMesh->hasEmptyQuads) {
157                renderer.dirtyRenderTarget(Rect(tx, ty,
158                        tx + op.unmappedBounds.getWidth(), ty + op.unmappedBounds.getHeight()));
159            } else {
160                const size_t count = opMesh->quads.size();
161                for (size_t i = 0; i < count; i++) {
162                    const Rect& quadBounds = opMesh->quads[i];
163                    const float x = tx + quadBounds.left;
164                    const float y = ty + quadBounds.top;
165                    renderer.dirtyRenderTarget(Rect(x, y,
166                            x + quadBounds.getWidth(), y + quadBounds.getHeight()));
167                }
168            }
169        }
170
171        indexCount += opMesh->indexCount;
172    }
173
174
175    Texture* texture = entry ? entry->texture : renderer.caches().textureCache.get(firstOp.bitmap);
176    if (!texture) return;
177    const AutoTexture autoCleanup(texture);
178
179    // 9 patches are built for stretching - always filter
180    int textureFillFlags = TextureFillFlags::ForceFilter;
181    if (firstOp.bitmap->colorType() == kAlpha_8_SkColorType) {
182        textureFillFlags |= TextureFillFlags::IsAlphaMaskTexture;
183    }
184    Glop glop;
185    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
186            .setRoundRectClipState(firstState.roundRectClipState)
187            .setMeshTexturedIndexedQuads(vertices, indexCount)
188            .setFillTexturePaint(*texture, textureFillFlags, firstOp.paint, firstState.alpha)
189            .setTransform(Matrix4::identity(), TransformFlags::None)
190            .setModelViewIdentityEmptyBounds()
191            .build();
192    ClipRect renderTargetClip(opList.clip);
193    const ClipBase* clip = opList.clipSideFlags ? &renderTargetClip : nullptr;
194    renderer.renderGlop(nullptr, clip, glop);
195}
196
197static void renderTextShadow(BakedOpRenderer& renderer, FontRenderer& fontRenderer,
198        const TextOp& op, const BakedOpState& textOpState) {
199    renderer.caches().textureState().activateTexture(0);
200
201    PaintUtils::TextShadow textShadow;
202    if (!PaintUtils::getTextShadow(op.paint, &textShadow)) {
203        LOG_ALWAYS_FATAL("failed to query shadow attributes");
204    }
205
206    renderer.caches().dropShadowCache.setFontRenderer(fontRenderer);
207    ShadowTexture* texture = renderer.caches().dropShadowCache.get(
208            op.paint, op.glyphs, op.glyphCount, textShadow.radius, op.positions);
209    // If the drop shadow exceeds the max texture size or couldn't be
210    // allocated, skip drawing
211    if (!texture) return;
212    const AutoTexture autoCleanup(texture);
213
214    const float sx = op.x - texture->left + textShadow.dx;
215    const float sy = op.y - texture->top + textShadow.dy;
216
217    Glop glop;
218    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
219            .setRoundRectClipState(textOpState.roundRectClipState)
220            .setMeshTexturedUnitQuad(nullptr)
221            .setFillShadowTexturePaint(*texture, textShadow.color, *op.paint, textOpState.alpha)
222            .setTransform(textOpState.computedState.transform, TransformFlags::None)
223            .setModelViewMapUnitToRect(Rect(sx, sy, sx + texture->width(), sy + texture->height()))
224            .build();
225
226    // Compute damage bounds and clip (since may differ from those in textOpState).
227    // Bounds should be same as text op, but with dx/dy offset and radius outset
228    // applied in local space.
229    auto& transform = textOpState.computedState.transform;
230    Rect shadowBounds = op.unmappedBounds; // STROKE
231    const bool expandForStroke = op.paint->getStyle() != SkPaint::kFill_Style;
232    if (expandForStroke) {
233        shadowBounds.outset(op.paint->getStrokeWidth() * 0.5f);
234    }
235    shadowBounds.translate(textShadow.dx, textShadow.dy);
236    shadowBounds.outset(textShadow.radius, textShadow.radius);
237    transform.mapRect(shadowBounds);
238    if (CC_UNLIKELY(expandForStroke &&
239            (!transform.isPureTranslate() || op.paint->getStrokeWidth() < 1.0f))) {
240        shadowBounds.outset(0.5f);
241    }
242
243    auto clipState = textOpState.computedState.clipState;
244    if (clipState->mode != ClipMode::Rectangle
245            || !clipState->rect.contains(shadowBounds)) {
246        // need clip, so pass it and clip bounds
247        shadowBounds.doIntersect(clipState->rect);
248    } else {
249        // don't need clip, ignore
250        clipState = nullptr;
251    }
252
253    renderer.renderGlop(&shadowBounds, clipState, glop);
254}
255
256enum class TextRenderType {
257    Defer,
258    Flush
259};
260
261static void renderTextOp(BakedOpRenderer& renderer, const TextOp& op, const BakedOpState& state,
262        const ClipBase* renderClip, TextRenderType renderType) {
263    FontRenderer& fontRenderer = renderer.caches().fontRenderer.getFontRenderer();
264
265    if (CC_UNLIKELY(PaintUtils::hasTextShadow(op.paint))) {
266        fontRenderer.setFont(op.paint, SkMatrix::I());
267        renderTextShadow(renderer, fontRenderer, op, state);
268    }
269
270    float x = op.x;
271    float y = op.y;
272    const Matrix4& transform = state.computedState.transform;
273    const bool pureTranslate = transform.isPureTranslate();
274    if (CC_LIKELY(pureTranslate)) {
275        x = floorf(x + transform.getTranslateX() + 0.5f);
276        y = floorf(y + transform.getTranslateY() + 0.5f);
277        fontRenderer.setFont(op.paint, SkMatrix::I());
278        fontRenderer.setTextureFiltering(false);
279    } else if (CC_UNLIKELY(transform.isPerspective())) {
280        fontRenderer.setFont(op.paint, SkMatrix::I());
281        fontRenderer.setTextureFiltering(true);
282    } else {
283        // We only pass a partial transform to the font renderer. That partial
284        // matrix defines how glyphs are rasterized. Typically we want glyphs
285        // to be rasterized at their final size on screen, which means the partial
286        // matrix needs to take the scale factor into account.
287        // When a partial matrix is used to transform glyphs during rasterization,
288        // the mesh is generated with the inverse transform (in the case of scale,
289        // the mesh is generated at 1.0 / scale for instance.) This allows us to
290        // apply the full transform matrix at draw time in the vertex shader.
291        // Applying the full matrix in the shader is the easiest way to handle
292        // rotation and perspective and allows us to always generated quads in the
293        // font renderer which greatly simplifies the code, clipping in particular.
294        float sx, sy;
295        transform.decomposeScale(sx, sy);
296        fontRenderer.setFont(op.paint, SkMatrix::MakeScale(
297                roundf(std::max(1.0f, sx)),
298                roundf(std::max(1.0f, sy))));
299        fontRenderer.setTextureFiltering(true);
300    }
301    Rect layerBounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
302
303    int alpha = PaintUtils::getAlphaDirect(op.paint) * state.alpha;
304    SkXfermode::Mode mode = PaintUtils::getXfermodeDirect(op.paint);
305    TextDrawFunctor functor(&renderer, &state, renderClip,
306            x, y, pureTranslate, alpha, mode, op.paint);
307
308    bool forceFinish = (renderType == TextRenderType::Flush);
309    bool mustDirtyRenderTarget = renderer.offscreenRenderTarget();
310    const Rect* localOpClip = pureTranslate ? &state.computedState.clipRect() : nullptr;
311    fontRenderer.renderPosText(op.paint, localOpClip, op.glyphs, op.glyphCount, x, y,
312            op.positions, mustDirtyRenderTarget ? &layerBounds : nullptr, &functor, forceFinish);
313
314    if (mustDirtyRenderTarget) {
315        if (!pureTranslate) {
316            transform.mapRect(layerBounds);
317        }
318        renderer.dirtyRenderTarget(layerBounds);
319    }
320}
321
322void BakedOpDispatcher::onMergedTextOps(BakedOpRenderer& renderer,
323        const MergedBakedOpList& opList) {
324    ClipRect renderTargetClip(opList.clip);
325    const ClipBase* clip = opList.clipSideFlags ? &renderTargetClip : nullptr;
326    for (size_t i = 0; i < opList.count; i++) {
327        const BakedOpState& state = *(opList.states[i]);
328        const TextOp& op = *(static_cast<const TextOp*>(state.op));
329        TextRenderType renderType = (i + 1 == opList.count)
330                ? TextRenderType::Flush : TextRenderType::Defer;
331        renderTextOp(renderer, op, state, clip, renderType);
332    }
333}
334
335namespace VertexBufferRenderFlags {
336    enum {
337        Offset = 0x1,
338        ShadowInterp = 0x2,
339    };
340}
341
342static void renderVertexBuffer(BakedOpRenderer& renderer, const BakedOpState& state,
343        const VertexBuffer& vertexBuffer, float translateX, float translateY,
344        const SkPaint& paint, int vertexBufferRenderFlags) {
345    if (CC_LIKELY(vertexBuffer.getVertexCount())) {
346        bool shadowInterp = vertexBufferRenderFlags & VertexBufferRenderFlags::ShadowInterp;
347        const int transformFlags = vertexBufferRenderFlags & VertexBufferRenderFlags::Offset
348                ? TransformFlags::OffsetByFudgeFactor : 0;
349
350        Glop glop;
351        GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
352                .setRoundRectClipState(state.roundRectClipState)
353                .setMeshVertexBuffer(vertexBuffer)
354                .setFillPaint(paint, state.alpha, shadowInterp)
355                .setTransform(state.computedState.transform, transformFlags)
356                .setModelViewOffsetRect(translateX, translateY, vertexBuffer.getBounds())
357                .build();
358        renderer.renderGlop(state, glop);
359    }
360}
361
362static void renderConvexPath(BakedOpRenderer& renderer, const BakedOpState& state,
363        const SkPath& path, const SkPaint& paint) {
364    VertexBuffer vertexBuffer;
365    // TODO: try clipping large paths to viewport
366    PathTessellator::tessellatePath(path, &paint, state.computedState.transform, vertexBuffer);
367    renderVertexBuffer(renderer, state, vertexBuffer, 0.0f, 0.0f, paint, 0);
368}
369
370static void renderPathTexture(BakedOpRenderer& renderer, const BakedOpState& state,
371        float xOffset, float yOffset, PathTexture& texture, const SkPaint& paint) {
372    Rect dest(texture.width(), texture.height());
373    dest.translate(xOffset + texture.left - texture.offset,
374            yOffset + texture.top - texture.offset);
375    Glop glop;
376    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
377            .setRoundRectClipState(state.roundRectClipState)
378            .setMeshTexturedUnitQuad(nullptr)
379            .setFillPathTexturePaint(texture, paint, state.alpha)
380            .setTransform(state.computedState.transform,  TransformFlags::None)
381            .setModelViewMapUnitToRect(dest)
382            .build();
383    renderer.renderGlop(state, glop);
384}
385
386SkRect getBoundsOfFill(const RecordedOp& op) {
387    SkRect bounds = op.unmappedBounds.toSkRect();
388    if (op.paint->getStyle() == SkPaint::kStrokeAndFill_Style) {
389        float outsetDistance = op.paint->getStrokeWidth() / 2;
390        bounds.outset(outsetDistance, outsetDistance);
391    }
392    return bounds;
393}
394
395void BakedOpDispatcher::onArcOp(BakedOpRenderer& renderer, const ArcOp& op, const BakedOpState& state) {
396    // TODO: support fills (accounting for concavity if useCenter && sweepAngle > 180)
397    if (op.paint->getStyle() != SkPaint::kStroke_Style
398            || op.paint->getPathEffect() != nullptr
399            || op.useCenter) {
400        PathTexture* texture = renderer.caches().pathCache.getArc(
401                op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(),
402                op.startAngle, op.sweepAngle, op.useCenter, op.paint);
403        const AutoTexture holder(texture);
404        if (CC_LIKELY(holder.texture)) {
405            renderPathTexture(renderer, state, op.unmappedBounds.left, op.unmappedBounds.top,
406                    *texture, *(op.paint));
407        }
408    } else {
409        SkRect rect = getBoundsOfFill(op);
410        SkPath path;
411        if (op.useCenter) {
412            path.moveTo(rect.centerX(), rect.centerY());
413        }
414        path.arcTo(rect, op.startAngle, op.sweepAngle, !op.useCenter);
415        if (op.useCenter) {
416            path.close();
417        }
418        renderConvexPath(renderer, state, path, *(op.paint));
419    }
420}
421
422void BakedOpDispatcher::onBitmapOp(BakedOpRenderer& renderer, const BitmapOp& op, const BakedOpState& state) {
423    Texture* texture = renderer.getTexture(op.bitmap);
424    if (!texture) return;
425    const AutoTexture autoCleanup(texture);
426
427    const int textureFillFlags = (op.bitmap->colorType() == kAlpha_8_SkColorType)
428            ? TextureFillFlags::IsAlphaMaskTexture : TextureFillFlags::None;
429    Glop glop;
430    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
431            .setRoundRectClipState(state.roundRectClipState)
432            .setMeshTexturedUnitQuad(texture->uvMapper)
433            .setFillTexturePaint(*texture, textureFillFlags, op.paint, state.alpha)
434            .setTransform(state.computedState.transform, TransformFlags::None)
435            .setModelViewMapUnitToRectSnap(Rect(texture->width(), texture->height()))
436            .build();
437    renderer.renderGlop(state, glop);
438}
439
440void BakedOpDispatcher::onBitmapMeshOp(BakedOpRenderer& renderer, const BitmapMeshOp& op, const BakedOpState& state) {
441    const static UvMapper defaultUvMapper;
442    const uint32_t elementCount = op.meshWidth * op.meshHeight * 6;
443
444    std::unique_ptr<ColorTextureVertex[]> mesh(new ColorTextureVertex[elementCount]);
445    ColorTextureVertex* vertex = &mesh[0];
446
447    const int* colors = op.colors;
448    std::unique_ptr<int[]> tempColors;
449    if (!colors) {
450        uint32_t colorsCount = (op.meshWidth + 1) * (op.meshHeight + 1);
451        tempColors.reset(new int[colorsCount]);
452        memset(tempColors.get(), 0xff, colorsCount * sizeof(int));
453        colors = tempColors.get();
454    }
455
456    Texture* texture = renderer.renderState().assetAtlas().getEntryTexture(op.bitmap->pixelRef());
457    const UvMapper& mapper(texture && texture->uvMapper ? *texture->uvMapper : defaultUvMapper);
458
459    for (int32_t y = 0; y < op.meshHeight; y++) {
460        for (int32_t x = 0; x < op.meshWidth; x++) {
461            uint32_t i = (y * (op.meshWidth + 1) + x) * 2;
462
463            float u1 = float(x) / op.meshWidth;
464            float u2 = float(x + 1) / op.meshWidth;
465            float v1 = float(y) / op.meshHeight;
466            float v2 = float(y + 1) / op.meshHeight;
467
468            mapper.map(u1, v1, u2, v2);
469
470            int ax = i + (op.meshWidth + 1) * 2;
471            int ay = ax + 1;
472            int bx = i;
473            int by = bx + 1;
474            int cx = i + 2;
475            int cy = cx + 1;
476            int dx = i + (op.meshWidth + 1) * 2 + 2;
477            int dy = dx + 1;
478
479            const float* vertices = op.vertices;
480            ColorTextureVertex::set(vertex++, vertices[dx], vertices[dy], u2, v2, colors[dx / 2]);
481            ColorTextureVertex::set(vertex++, vertices[ax], vertices[ay], u1, v2, colors[ax / 2]);
482            ColorTextureVertex::set(vertex++, vertices[bx], vertices[by], u1, v1, colors[bx / 2]);
483
484            ColorTextureVertex::set(vertex++, vertices[dx], vertices[dy], u2, v2, colors[dx / 2]);
485            ColorTextureVertex::set(vertex++, vertices[bx], vertices[by], u1, v1, colors[bx / 2]);
486            ColorTextureVertex::set(vertex++, vertices[cx], vertices[cy], u2, v1, colors[cx / 2]);
487        }
488    }
489
490    if (!texture) {
491        texture = renderer.caches().textureCache.get(op.bitmap);
492        if (!texture) {
493            return;
494        }
495    }
496    const AutoTexture autoCleanup(texture);
497
498    /*
499     * TODO: handle alpha_8 textures correctly by applying paint color, but *not*
500     * shader in that case to mimic the behavior in SkiaCanvas::drawBitmapMesh.
501     */
502    const int textureFillFlags = TextureFillFlags::None;
503    Glop glop;
504    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
505            .setRoundRectClipState(state.roundRectClipState)
506            .setMeshColoredTexturedMesh(mesh.get(), elementCount)
507            .setFillTexturePaint(*texture, textureFillFlags, op.paint, state.alpha)
508            .setTransform(state.computedState.transform,  TransformFlags::None)
509            .setModelViewOffsetRect(0, 0, op.unmappedBounds)
510            .build();
511    renderer.renderGlop(state, glop);
512}
513
514void BakedOpDispatcher::onBitmapRectOp(BakedOpRenderer& renderer, const BitmapRectOp& op, const BakedOpState& state) {
515    Texture* texture = renderer.getTexture(op.bitmap);
516    if (!texture) return;
517    const AutoTexture autoCleanup(texture);
518
519    Rect uv(std::max(0.0f, op.src.left / texture->width()),
520            std::max(0.0f, op.src.top / texture->height()),
521            std::min(1.0f, op.src.right / texture->width()),
522            std::min(1.0f, op.src.bottom / texture->height()));
523
524    const int textureFillFlags = (op.bitmap->colorType() == kAlpha_8_SkColorType)
525            ? TextureFillFlags::IsAlphaMaskTexture : TextureFillFlags::None;
526    const bool tryToSnap = MathUtils::areEqual(op.src.getWidth(), op.unmappedBounds.getWidth())
527            && MathUtils::areEqual(op.src.getHeight(), op.unmappedBounds.getHeight());
528    Glop glop;
529    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
530            .setRoundRectClipState(state.roundRectClipState)
531            .setMeshTexturedUvQuad(texture->uvMapper, uv)
532            .setFillTexturePaint(*texture, textureFillFlags, op.paint, state.alpha)
533            .setTransform(state.computedState.transform, TransformFlags::None)
534            .setModelViewMapUnitToRectOptionalSnap(tryToSnap, op.unmappedBounds)
535            .build();
536    renderer.renderGlop(state, glop);
537}
538
539void BakedOpDispatcher::onColorOp(BakedOpRenderer& renderer, const ColorOp& op, const BakedOpState& state) {
540    SkPaint paint;
541    paint.setColor(op.color);
542    paint.setXfermodeMode(op.mode);
543
544    Glop glop;
545    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
546            .setRoundRectClipState(state.roundRectClipState)
547            .setMeshUnitQuad()
548            .setFillPaint(paint, state.alpha)
549            .setTransform(Matrix4::identity(), TransformFlags::None)
550            .setModelViewMapUnitToRect(state.computedState.clipState->rect)
551            .build();
552    renderer.renderGlop(state, glop);
553}
554
555void BakedOpDispatcher::onFunctorOp(BakedOpRenderer& renderer, const FunctorOp& op, const BakedOpState& state) {
556    renderer.renderFunctor(op, state);
557}
558
559void BakedOpDispatcher::onLinesOp(BakedOpRenderer& renderer, const LinesOp& op, const BakedOpState& state) {
560    VertexBuffer buffer;
561    PathTessellator::tessellateLines(op.points, op.floatCount, op.paint,
562            state.computedState.transform, buffer);
563    int displayFlags = op.paint->isAntiAlias() ? 0 : VertexBufferRenderFlags::Offset;
564    renderVertexBuffer(renderer, state, buffer, 0, 0, *(op.paint), displayFlags);
565}
566
567void BakedOpDispatcher::onOvalOp(BakedOpRenderer& renderer, const OvalOp& op, const BakedOpState& state) {
568    if (op.paint->getPathEffect() != nullptr) {
569        PathTexture* texture = renderer.caches().pathCache.getOval(
570                op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.paint);
571        const AutoTexture holder(texture);
572        if (CC_LIKELY(holder.texture)) {
573            renderPathTexture(renderer, state, op.unmappedBounds.left, op.unmappedBounds.top,
574                    *texture, *(op.paint));
575        }
576    } else {
577        SkPath path;
578        SkRect rect = getBoundsOfFill(op);
579        path.addOval(rect);
580
581        if (state.computedState.localProjectionPathMask != nullptr) {
582            // Mask the ripple path by the local space projection mask in local space.
583            // Note that this can create CCW paths.
584            Op(path, *state.computedState.localProjectionPathMask, kIntersect_SkPathOp, &path);
585        }
586        renderConvexPath(renderer, state, path, *(op.paint));
587    }
588}
589
590void BakedOpDispatcher::onPatchOp(BakedOpRenderer& renderer, const PatchOp& op, const BakedOpState& state) {
591    // 9 patches are built for stretching - always filter
592    int textureFillFlags = TextureFillFlags::ForceFilter;
593    if (op.bitmap->colorType() == kAlpha_8_SkColorType) {
594        textureFillFlags |= TextureFillFlags::IsAlphaMaskTexture;
595    }
596
597    // TODO: avoid redoing the below work each frame:
598    AssetAtlas::Entry* entry = renderer.renderState().assetAtlas().getEntry(op.bitmap->pixelRef());
599    const Patch* mesh = renderer.caches().patchCache.get(
600            entry, op.bitmap->width(), op.bitmap->height(),
601            op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.patch);
602
603    Texture* texture = entry ? entry->texture : renderer.caches().textureCache.get(op.bitmap);
604    if (CC_LIKELY(texture)) {
605        const AutoTexture autoCleanup(texture);
606        Glop glop;
607        GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
608                .setRoundRectClipState(state.roundRectClipState)
609                .setMeshPatchQuads(*mesh)
610                .setFillTexturePaint(*texture, textureFillFlags, op.paint, state.alpha)
611                .setTransform(state.computedState.transform, TransformFlags::None)
612                .setModelViewOffsetRectSnap(op.unmappedBounds.left, op.unmappedBounds.top,
613                        Rect(op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight()))
614                .build();
615        renderer.renderGlop(state, glop);
616    }
617}
618
619void BakedOpDispatcher::onPathOp(BakedOpRenderer& renderer, const PathOp& op, const BakedOpState& state) {
620    PathTexture* texture = renderer.caches().pathCache.get(op.path, op.paint);
621    const AutoTexture holder(texture);
622    if (CC_LIKELY(holder.texture)) {
623        // Unlike other callers to renderPathTexture, no offsets are used because PathOp doesn't
624        // have any translate built in, other than what's in the SkPath itself
625        renderPathTexture(renderer, state, 0, 0, *texture, *(op.paint));
626    }
627}
628
629void BakedOpDispatcher::onPointsOp(BakedOpRenderer& renderer, const PointsOp& op, const BakedOpState& state) {
630    VertexBuffer buffer;
631    PathTessellator::tessellatePoints(op.points, op.floatCount, op.paint,
632            state.computedState.transform, buffer);
633    int displayFlags = op.paint->isAntiAlias() ? 0 : VertexBufferRenderFlags::Offset;
634    renderVertexBuffer(renderer, state, buffer, 0, 0, *(op.paint), displayFlags);
635}
636
637// See SkPaintDefaults.h
638#define SkPaintDefaults_MiterLimit SkIntToScalar(4)
639
640void BakedOpDispatcher::onRectOp(BakedOpRenderer& renderer, const RectOp& op, const BakedOpState& state) {
641    if (op.paint->getStyle() != SkPaint::kFill_Style) {
642        // only fill + default miter is supported by drawConvexPath, since others must handle joins
643        static_assert(SkPaintDefaults_MiterLimit == 4.0f, "Miter limit has changed");
644        if (CC_UNLIKELY(op.paint->getPathEffect() != nullptr
645                || op.paint->getStrokeJoin() != SkPaint::kMiter_Join
646                || op.paint->getStrokeMiter() != SkPaintDefaults_MiterLimit)) {
647             PathTexture* texture = renderer.caches().pathCache.getRect(
648                     op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.paint);
649             const AutoTexture holder(texture);
650             if (CC_LIKELY(holder.texture)) {
651                 renderPathTexture(renderer, state, op.unmappedBounds.left, op.unmappedBounds.top,
652                         *texture, *(op.paint));
653             }
654        } else {
655            SkPath path;
656            path.addRect(getBoundsOfFill(op));
657            renderConvexPath(renderer, state, path, *(op.paint));
658        }
659    } else {
660        if (op.paint->isAntiAlias() && !state.computedState.transform.isSimple()) {
661            SkPath path;
662            path.addRect(op.unmappedBounds.toSkRect());
663            renderConvexPath(renderer, state, path, *(op.paint));
664        } else {
665            // render simple unit quad, no tessellation required
666            Glop glop;
667            GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
668                    .setRoundRectClipState(state.roundRectClipState)
669                    .setMeshUnitQuad()
670                    .setFillPaint(*op.paint, state.alpha)
671                    .setTransform(state.computedState.transform, TransformFlags::None)
672                    .setModelViewMapUnitToRect(op.unmappedBounds)
673                    .build();
674            renderer.renderGlop(state, glop);
675        }
676    }
677}
678
679void BakedOpDispatcher::onRoundRectOp(BakedOpRenderer& renderer, const RoundRectOp& op, const BakedOpState& state) {
680    if (op.paint->getPathEffect() != nullptr) {
681        PathTexture* texture = renderer.caches().pathCache.getRoundRect(
682                op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(),
683                op.rx, op.ry, op.paint);
684        const AutoTexture holder(texture);
685        if (CC_LIKELY(holder.texture)) {
686            renderPathTexture(renderer, state, op.unmappedBounds.left, op.unmappedBounds.top,
687                    *texture, *(op.paint));
688        }
689    } else {
690        const VertexBuffer* buffer = renderer.caches().tessellationCache.getRoundRect(
691                state.computedState.transform, *(op.paint),
692                op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.rx, op.ry);
693        renderVertexBuffer(renderer, state, *buffer,
694                op.unmappedBounds.left, op.unmappedBounds.top, *(op.paint), 0);
695    }
696}
697
698static void renderShadow(BakedOpRenderer& renderer, const BakedOpState& state, float casterAlpha,
699        const VertexBuffer* ambientShadowVertexBuffer, const VertexBuffer* spotShadowVertexBuffer) {
700    SkPaint paint;
701    paint.setAntiAlias(true); // want to use AlphaVertex
702
703    // The caller has made sure casterAlpha > 0.
704    uint8_t ambientShadowAlpha = renderer.getLightInfo().ambientShadowAlpha;
705    if (CC_UNLIKELY(Properties::overrideAmbientShadowStrength >= 0)) {
706        ambientShadowAlpha = Properties::overrideAmbientShadowStrength;
707    }
708    if (ambientShadowVertexBuffer && ambientShadowAlpha > 0) {
709        paint.setAlpha((uint8_t)(casterAlpha * ambientShadowAlpha));
710        renderVertexBuffer(renderer, state, *ambientShadowVertexBuffer, 0, 0,
711                paint, VertexBufferRenderFlags::ShadowInterp);
712    }
713
714    uint8_t spotShadowAlpha = renderer.getLightInfo().spotShadowAlpha;
715    if (CC_UNLIKELY(Properties::overrideSpotShadowStrength >= 0)) {
716        spotShadowAlpha = Properties::overrideSpotShadowStrength;
717    }
718    if (spotShadowVertexBuffer && spotShadowAlpha > 0) {
719        paint.setAlpha((uint8_t)(casterAlpha * spotShadowAlpha));
720        renderVertexBuffer(renderer, state, *spotShadowVertexBuffer, 0, 0,
721                paint, VertexBufferRenderFlags::ShadowInterp);
722    }
723}
724
725void BakedOpDispatcher::onShadowOp(BakedOpRenderer& renderer, const ShadowOp& op, const BakedOpState& state) {
726    TessellationCache::vertexBuffer_pair_t buffers = op.shadowTask->getResult();
727    renderShadow(renderer, state, op.casterAlpha, buffers.first, buffers.second);
728}
729
730void BakedOpDispatcher::onSimpleRectsOp(BakedOpRenderer& renderer, const SimpleRectsOp& op, const BakedOpState& state) {
731    Glop glop;
732    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
733            .setRoundRectClipState(state.roundRectClipState)
734            .setMeshIndexedQuads(&op.vertices[0], op.vertexCount / 4)
735            .setFillPaint(*op.paint, state.alpha)
736            .setTransform(state.computedState.transform, TransformFlags::None)
737            .setModelViewOffsetRect(0, 0, op.unmappedBounds)
738            .build();
739    renderer.renderGlop(state, glop);
740}
741
742void BakedOpDispatcher::onTextOp(BakedOpRenderer& renderer, const TextOp& op, const BakedOpState& state) {
743    renderTextOp(renderer, op, state, state.computedState.getClipIfNeeded(), TextRenderType::Flush);
744}
745
746void BakedOpDispatcher::onTextOnPathOp(BakedOpRenderer& renderer, const TextOnPathOp& op, const BakedOpState& state) {
747    // Note: can't trust clipSideFlags since we record with unmappedBounds == clip.
748    // TODO: respect clipSideFlags, once we record with bounds
749    auto renderTargetClip = state.computedState.clipState;
750
751    FontRenderer& fontRenderer = renderer.caches().fontRenderer.getFontRenderer();
752    fontRenderer.setFont(op.paint, SkMatrix::I());
753    fontRenderer.setTextureFiltering(true);
754
755    Rect layerBounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
756
757    int alpha = PaintUtils::getAlphaDirect(op.paint) * state.alpha;
758    SkXfermode::Mode mode = PaintUtils::getXfermodeDirect(op.paint);
759    TextDrawFunctor functor(&renderer, &state, renderTargetClip,
760            0.0f, 0.0f, false, alpha, mode, op.paint);
761
762    bool mustDirtyRenderTarget = renderer.offscreenRenderTarget();
763    const Rect localSpaceClip = state.computedState.computeLocalSpaceClip();
764    if (fontRenderer.renderTextOnPath(op.paint, &localSpaceClip, op.glyphs, op.glyphCount,
765            op.path, op.hOffset, op.vOffset,
766            mustDirtyRenderTarget ? &layerBounds : nullptr, &functor)) {
767        if (mustDirtyRenderTarget) {
768            // manually dirty render target, since TextDrawFunctor won't
769            state.computedState.transform.mapRect(layerBounds);
770            renderer.dirtyRenderTarget(layerBounds);
771        }
772    }
773}
774
775void BakedOpDispatcher::onTextureLayerOp(BakedOpRenderer& renderer, const TextureLayerOp& op, const BakedOpState& state) {
776    const bool tryToSnap = !op.layer->getForceFilter();
777    float alpha = (op.layer->getAlpha() / 255.0f) * state.alpha;
778    Glop glop;
779    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
780            .setRoundRectClipState(state.roundRectClipState)
781            .setMeshTexturedUvQuad(nullptr, Rect(0, 1, 1, 0)) // TODO: simplify with VBO
782            .setFillTextureLayer(*(op.layer), alpha)
783            .setTransform(state.computedState.transform, TransformFlags::None)
784            .setModelViewMapUnitToRectOptionalSnap(tryToSnap, Rect(op.layer->getWidth(), op.layer->getHeight()))
785            .build();
786    renderer.renderGlop(state, glop);
787}
788
789void BakedOpDispatcher::onLayerOp(BakedOpRenderer& renderer, const LayerOp& op, const BakedOpState& state) {
790    // Note that we don't use op->paint in this function - it's never set on a LayerOp
791    OffscreenBuffer* buffer = *op.layerHandle;
792
793    if (CC_UNLIKELY(!buffer)) {
794        // Layer was not allocated, which can occur if there were no draw ops inside. We draw the
795        // equivalent by drawing a rect with the same layer properties (alpha/xfer/filter).
796        SkPaint paint;
797        paint.setAlpha(op.alpha * 255);
798        paint.setXfermodeMode(op.mode);
799        paint.setColorFilter(op.colorFilter);
800        RectOp rectOp(op.unmappedBounds, op.localMatrix, op.localClip, &paint);
801        BakedOpDispatcher::onRectOp(renderer, rectOp, state);
802    } else {
803        float layerAlpha = op.alpha * state.alpha;
804        Glop glop;
805        GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
806                .setRoundRectClipState(state.roundRectClipState)
807                .setMeshTexturedIndexedVbo(buffer->vbo, buffer->elementCount)
808                .setFillLayer(buffer->texture, op.colorFilter, layerAlpha, op.mode, Blend::ModeOrderSwap::NoSwap)
809                .setTransform(state.computedState.transform, TransformFlags::None)
810                .setModelViewOffsetRectSnap(op.unmappedBounds.left, op.unmappedBounds.top,
811                        Rect(op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight()))
812                .build();
813        renderer.renderGlop(state, glop);
814    }
815}
816
817void BakedOpDispatcher::onCopyToLayerOp(BakedOpRenderer& renderer, const CopyToLayerOp& op, const BakedOpState& state) {
818    LOG_ALWAYS_FATAL_IF(*(op.layerHandle) != nullptr, "layer already exists!");
819    *(op.layerHandle) = renderer.copyToLayer(state.computedState.clippedBounds);
820    LOG_ALWAYS_FATAL_IF(*op.layerHandle == nullptr, "layer copy failed");
821}
822
823void BakedOpDispatcher::onCopyFromLayerOp(BakedOpRenderer& renderer, const CopyFromLayerOp& op, const BakedOpState& state) {
824    LOG_ALWAYS_FATAL_IF(*op.layerHandle == nullptr, "no layer to draw underneath!");
825    if (!state.computedState.clippedBounds.isEmpty()) {
826        if (op.paint && op.paint->getAlpha() < 255) {
827            SkPaint layerPaint;
828            layerPaint.setAlpha(op.paint->getAlpha());
829            layerPaint.setXfermodeMode(SkXfermode::kDstIn_Mode);
830            layerPaint.setColorFilter(op.paint->getColorFilter());
831            RectOp rectOp(state.computedState.clippedBounds, Matrix4::identity(), nullptr, &layerPaint);
832            BakedOpDispatcher::onRectOp(renderer, rectOp, state);
833        }
834
835        OffscreenBuffer& layer = **(op.layerHandle);
836        auto mode = PaintUtils::getXfermodeDirect(op.paint);
837        Glop glop;
838        GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
839                .setRoundRectClipState(state.roundRectClipState)
840                .setMeshTexturedUvQuad(nullptr, layer.getTextureCoordinates())
841                .setFillLayer(layer.texture, nullptr, 1.0f, mode, Blend::ModeOrderSwap::Swap)
842                .setTransform(state.computedState.transform, TransformFlags::None)
843                .setModelViewMapUnitToRect(state.computedState.clippedBounds)
844                .build();
845        renderer.renderGlop(state, glop);
846    }
847    renderer.renderState().layerPool().putOrDelete(*op.layerHandle);
848}
849
850} // namespace uirenderer
851} // namespace android
852