blob: 0adb21cd88843fa829e63520e63d177b59ef81e6 [file] [log] [blame]
Chris Craikb565df12015-10-05 13:00:52 -07001/*
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 "RecordingCanvas.h"
18
Chris Craikd2dfd8f2015-12-16 14:27:20 -080019#include "DeferredLayerUpdater.h"
Chris Craikb565df12015-10-05 13:00:52 -070020#include "RecordedOp.h"
21#include "RenderNode.h"
Doris Liu766431a2016-02-04 22:17:11 +000022#include "VectorDrawable.h"
Chris Craikb565df12015-10-05 13:00:52 -070023
24namespace android {
25namespace uirenderer {
26
27RecordingCanvas::RecordingCanvas(size_t width, size_t height)
28 : mState(*this)
29 , mResourceCache(ResourceCache::getInstance()) {
Derek Sollenberger6f485562015-07-30 10:00:39 -040030 resetRecording(width, height);
Chris Craikb565df12015-10-05 13:00:52 -070031}
32
33RecordingCanvas::~RecordingCanvas() {
Chris Craik003cc3d2015-10-16 10:24:55 -070034 LOG_ALWAYS_FATAL_IF(mDisplayList,
Chris Craikb565df12015-10-05 13:00:52 -070035 "Destroyed a RecordingCanvas during a record!");
36}
37
Derek Sollenberger6f485562015-07-30 10:00:39 -040038void RecordingCanvas::resetRecording(int width, int height) {
Chris Craik003cc3d2015-10-16 10:24:55 -070039 LOG_ALWAYS_FATAL_IF(mDisplayList,
Chris Craikb565df12015-10-05 13:00:52 -070040 "prepareDirty called a second time during a recording!");
Chris Craik003cc3d2015-10-16 10:24:55 -070041 mDisplayList = new DisplayList();
Chris Craikb565df12015-10-05 13:00:52 -070042
Chris Craike4db79d2015-12-22 16:32:23 -080043 mState.initializeRecordingSaveStack(width, height);
Chris Craikb565df12015-10-05 13:00:52 -070044
Chris Craik161f54b2015-11-05 11:08:52 -080045 mDeferredBarrierType = DeferredBarrierType::InOrder;
Chris Craikb565df12015-10-05 13:00:52 -070046 mState.setDirtyClip(false);
Chris Craikb565df12015-10-05 13:00:52 -070047}
48
Chris Craik003cc3d2015-10-16 10:24:55 -070049DisplayList* RecordingCanvas::finishRecording() {
Chris Craikb87eadd2016-01-06 09:16:05 -080050 restoreToCount(1);
Chris Craikb565df12015-10-05 13:00:52 -070051 mPaintMap.clear();
52 mRegionMap.clear();
53 mPathMap.clear();
Chris Craik003cc3d2015-10-16 10:24:55 -070054 DisplayList* displayList = mDisplayList;
55 mDisplayList = nullptr;
Chris Craikb565df12015-10-05 13:00:52 -070056 mSkiaCanvasProxy.reset(nullptr);
Chris Craik003cc3d2015-10-16 10:24:55 -070057 return displayList;
Chris Craikb565df12015-10-05 13:00:52 -070058}
59
60SkCanvas* RecordingCanvas::asSkCanvas() {
Chris Craik003cc3d2015-10-16 10:24:55 -070061 LOG_ALWAYS_FATAL_IF(!mDisplayList,
Chris Craikb565df12015-10-05 13:00:52 -070062 "attempting to get an SkCanvas when we are not recording!");
63 if (!mSkiaCanvasProxy) {
64 mSkiaCanvasProxy.reset(new SkiaCanvasProxy(this));
65 }
66
67 // SkCanvas instances default to identity transform, but should inherit
68 // the state of this Canvas; if this code was in the SkiaCanvasProxy
69 // constructor, we couldn't cache mSkiaCanvasProxy.
70 SkMatrix parentTransform;
71 getMatrix(&parentTransform);
72 mSkiaCanvasProxy.get()->setMatrix(parentTransform);
73
74 return mSkiaCanvasProxy.get();
75}
76
77// ----------------------------------------------------------------------------
Chris Craik6fe991e52015-10-20 09:39:42 -070078// CanvasStateClient implementation
79// ----------------------------------------------------------------------------
80
81void RecordingCanvas::onViewportInitialized() {
Chris Craik6fe991e52015-10-20 09:39:42 -070082}
83
84void RecordingCanvas::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {
85 if (removed.flags & Snapshot::kFlagIsFboLayer) {
John Reck7df9ff22016-02-10 16:08:08 -080086 addOp(alloc().create_trivial<EndLayerOp>());
Chris Craikb87eadd2016-01-06 09:16:05 -080087 } else if (removed.flags & Snapshot::kFlagIsLayer) {
John Reck7df9ff22016-02-10 16:08:08 -080088 addOp(alloc().create_trivial<EndUnclippedLayerOp>());
Chris Craik6fe991e52015-10-20 09:39:42 -070089 }
90}
91
92// ----------------------------------------------------------------------------
Chris Craikb565df12015-10-05 13:00:52 -070093// android/graphics/Canvas state operations
94// ----------------------------------------------------------------------------
95// Save (layer)
Florin Malitaeecff562015-12-21 10:43:01 -050096int RecordingCanvas::save(SaveFlags::Flags flags) {
Chris Craikb565df12015-10-05 13:00:52 -070097 return mState.save((int) flags);
98}
99
100void RecordingCanvas::RecordingCanvas::restore() {
Chris Craikb565df12015-10-05 13:00:52 -0700101 mState.restore();
102}
103
104void RecordingCanvas::restoreToCount(int saveCount) {
Chris Craikb565df12015-10-05 13:00:52 -0700105 mState.restoreToCount(saveCount);
106}
107
Chris Craikb87eadd2016-01-06 09:16:05 -0800108int RecordingCanvas::saveLayer(float left, float top, float right, float bottom,
Florin Malitaeecff562015-12-21 10:43:01 -0500109 const SkPaint* paint, SaveFlags::Flags flags) {
Chris Craik6fe991e52015-10-20 09:39:42 -0700110 // force matrix/clip isolation for layer
Florin Malitaeecff562015-12-21 10:43:01 -0500111 flags |= SaveFlags::MatrixClip;
112 bool clippedLayer = flags & SaveFlags::ClipToLayer;
Chris Craik6fe991e52015-10-20 09:39:42 -0700113
114 const Snapshot& previous = *mState.currentSnapshot();
115
116 // initialize the snapshot as though it almost represents an FBO layer so deferred draw
117 // operations will be able to store and restore the current clip and transform info, and
118 // quick rejection will be correct (for display lists)
119
Chris Craikb87eadd2016-01-06 09:16:05 -0800120 const Rect unmappedBounds(left, top, right, bottom);
Chris Craik6fe991e52015-10-20 09:39:42 -0700121
122 // determine clipped bounds relative to previous viewport.
Chris Craikb87eadd2016-01-06 09:16:05 -0800123 Rect visibleBounds = unmappedBounds;
Chris Craik6fe991e52015-10-20 09:39:42 -0700124 previous.transform->mapRect(visibleBounds);
125
Chris Craikb87eadd2016-01-06 09:16:05 -0800126 if (CC_UNLIKELY(!clippedLayer
127 && previous.transform->rectToRect()
128 && visibleBounds.contains(previous.getRenderTargetClip()))) {
129 // unlikely case where an unclipped savelayer is recorded with a clip it can use,
130 // as none of its unaffected/unclipped area is visible
131 clippedLayer = true;
Florin Malitaeecff562015-12-21 10:43:01 -0500132 flags |= SaveFlags::ClipToLayer;
Chris Craikb87eadd2016-01-06 09:16:05 -0800133 }
Chris Craik6fe991e52015-10-20 09:39:42 -0700134
135 visibleBounds.doIntersect(previous.getRenderTargetClip());
136 visibleBounds.snapToPixelBoundaries();
Chris Craikb87eadd2016-01-06 09:16:05 -0800137 visibleBounds.doIntersect(Rect(previous.getViewportWidth(), previous.getViewportHeight()));
Chris Craik6fe991e52015-10-20 09:39:42 -0700138
139 // Map visible bounds back to layer space, and intersect with parameter bounds
140 Rect layerBounds = visibleBounds;
141 Matrix4 inverse;
142 inverse.loadInverse(*previous.transform);
143 inverse.mapRect(layerBounds);
Chris Craikb87eadd2016-01-06 09:16:05 -0800144 layerBounds.doIntersect(unmappedBounds);
Chris Craik6fe991e52015-10-20 09:39:42 -0700145
146 int saveValue = mState.save((int) flags);
147 Snapshot& snapshot = *mState.writableSnapshot();
148
Chris Craikb87eadd2016-01-06 09:16:05 -0800149 // layerBounds is in original bounds space, but clipped by current recording clip
150 if (layerBounds.isEmpty() || unmappedBounds.isEmpty()) {
Chris Craik6fe991e52015-10-20 09:39:42 -0700151 // Don't bother recording layer, since it's been rejected
Chris Craikb87eadd2016-01-06 09:16:05 -0800152 if (CC_LIKELY(clippedLayer)) {
153 snapshot.resetClip(0, 0, 0, 0);
154 }
Chris Craik6fe991e52015-10-20 09:39:42 -0700155 return saveValue;
156 }
157
Chris Craikb87eadd2016-01-06 09:16:05 -0800158 if (CC_LIKELY(clippedLayer)) {
159 auto previousClip = getRecordedClip(); // note: done before new snapshot's clip has changed
Chris Craike4db79d2015-12-22 16:32:23 -0800160
Chris Craikb87eadd2016-01-06 09:16:05 -0800161 snapshot.flags |= Snapshot::kFlagIsLayer | Snapshot::kFlagIsFboLayer;
162 snapshot.initializeViewport(unmappedBounds.getWidth(), unmappedBounds.getHeight());
163 snapshot.transform->loadTranslate(-unmappedBounds.left, -unmappedBounds.top, 0.0f);
Chris Craik6fe991e52015-10-20 09:39:42 -0700164
Chris Craikb87eadd2016-01-06 09:16:05 -0800165 Rect clip = layerBounds;
166 clip.translate(-unmappedBounds.left, -unmappedBounds.top);
167 snapshot.resetClip(clip.left, clip.top, clip.right, clip.bottom);
168 snapshot.roundRectClipState = nullptr;
Chris Craik6fe991e52015-10-20 09:39:42 -0700169
John Reck7df9ff22016-02-10 16:08:08 -0800170 addOp(alloc().create_trivial<BeginLayerOp>(
Chris Craikb87eadd2016-01-06 09:16:05 -0800171 unmappedBounds,
172 *previous.transform, // transform to *draw* with
173 previousClip, // clip to *draw* with
174 refPaint(paint)));
175 } else {
176 snapshot.flags |= Snapshot::kFlagIsLayer;
177
John Reck7df9ff22016-02-10 16:08:08 -0800178 addOp(alloc().create_trivial<BeginUnclippedLayerOp>(
Chris Craikb87eadd2016-01-06 09:16:05 -0800179 unmappedBounds,
180 *mState.currentSnapshot()->transform,
181 getRecordedClip(),
182 refPaint(paint)));
183 }
Chris Craik6fe991e52015-10-20 09:39:42 -0700184
185 return saveValue;
Chris Craikb565df12015-10-05 13:00:52 -0700186}
187
188// Matrix
189void RecordingCanvas::rotate(float degrees) {
190 if (degrees == 0) return;
191
192 mState.rotate(degrees);
193}
194
195void RecordingCanvas::scale(float sx, float sy) {
196 if (sx == 1 && sy == 1) return;
197
198 mState.scale(sx, sy);
199}
200
201void RecordingCanvas::skew(float sx, float sy) {
202 mState.skew(sx, sy);
203}
204
205void RecordingCanvas::translate(float dx, float dy) {
206 if (dx == 0 && dy == 0) return;
207
208 mState.translate(dx, dy, 0);
209}
210
211// Clip
212bool RecordingCanvas::getClipBounds(SkRect* outRect) const {
Chris Craike29ce6f2015-12-10 16:25:13 -0800213 *outRect = mState.getLocalClipBounds().toSkRect();
Chris Craikb565df12015-10-05 13:00:52 -0700214 return !(outRect->isEmpty());
215}
216bool RecordingCanvas::quickRejectRect(float left, float top, float right, float bottom) const {
217 return mState.quickRejectConservative(left, top, right, bottom);
218}
219bool RecordingCanvas::quickRejectPath(const SkPath& path) const {
220 SkRect bounds = path.getBounds();
221 return mState.quickRejectConservative(bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom);
222}
223bool RecordingCanvas::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {
224 return mState.clipRect(left, top, right, bottom, op);
225}
226bool RecordingCanvas::clipPath(const SkPath* path, SkRegion::Op op) {
227 return mState.clipPath(path, op);
228}
229bool RecordingCanvas::clipRegion(const SkRegion* region, SkRegion::Op op) {
230 return mState.clipRegion(region, op);
231}
232
233// ----------------------------------------------------------------------------
234// android/graphics/Canvas draw operations
235// ----------------------------------------------------------------------------
236void RecordingCanvas::drawColor(int color, SkXfermode::Mode mode) {
237 SkPaint paint;
238 paint.setColor(color);
239 paint.setXfermodeMode(mode);
240 drawPaint(paint);
241}
242
243void RecordingCanvas::drawPaint(const SkPaint& paint) {
John Reck7df9ff22016-02-10 16:08:08 -0800244 addOp(alloc().create_trivial<RectOp>(
Chris Craike4db79d2015-12-22 16:32:23 -0800245 mState.getRenderTargetClipBounds(), // OK, since we've not passed transform
Chris Craika1717272015-11-19 13:02:43 -0800246 Matrix4::identity(),
Chris Craike4db79d2015-12-22 16:32:23 -0800247 getRecordedClip(),
Chris Craikb565df12015-10-05 13:00:52 -0700248 refPaint(&paint)));
249}
250
Chris Craik386aa032015-12-07 17:08:25 -0800251static Rect calcBoundsOfPoints(const float* points, int floatCount) {
252 Rect unmappedBounds(points[0], points[1], points[0], points[1]);
253 for (int i = 2; i < floatCount; i += 2) {
254 unmappedBounds.expandToCover(points[i], points[i + 1]);
255 }
256 return unmappedBounds;
257}
258
Chris Craikb565df12015-10-05 13:00:52 -0700259// Geometry
Chris Craik386aa032015-12-07 17:08:25 -0800260void RecordingCanvas::drawPoints(const float* points, int floatCount, const SkPaint& paint) {
261 if (floatCount < 2) return;
262 floatCount &= ~0x1; // round down to nearest two
263
John Reck7df9ff22016-02-10 16:08:08 -0800264 addOp(alloc().create_trivial<PointsOp>(
Chris Craik386aa032015-12-07 17:08:25 -0800265 calcBoundsOfPoints(points, floatCount),
266 *mState.currentSnapshot()->transform,
Chris Craike4db79d2015-12-22 16:32:23 -0800267 getRecordedClip(),
Chris Craik386aa032015-12-07 17:08:25 -0800268 refPaint(&paint), refBuffer<float>(points, floatCount), floatCount));
Chris Craikb565df12015-10-05 13:00:52 -0700269}
Chris Craika1717272015-11-19 13:02:43 -0800270
271void RecordingCanvas::drawLines(const float* points, int floatCount, const SkPaint& paint) {
272 if (floatCount < 4) return;
273 floatCount &= ~0x3; // round down to nearest four
274
John Reck7df9ff22016-02-10 16:08:08 -0800275 addOp(alloc().create_trivial<LinesOp>(
Chris Craik386aa032015-12-07 17:08:25 -0800276 calcBoundsOfPoints(points, floatCount),
Chris Craika1717272015-11-19 13:02:43 -0800277 *mState.currentSnapshot()->transform,
Chris Craike4db79d2015-12-22 16:32:23 -0800278 getRecordedClip(),
Chris Craika1717272015-11-19 13:02:43 -0800279 refPaint(&paint), refBuffer<float>(points, floatCount), floatCount));
Chris Craikb565df12015-10-05 13:00:52 -0700280}
Chris Craika1717272015-11-19 13:02:43 -0800281
Chris Craikb565df12015-10-05 13:00:52 -0700282void RecordingCanvas::drawRect(float left, float top, float right, float bottom, const SkPaint& paint) {
John Reck7df9ff22016-02-10 16:08:08 -0800283 addOp(alloc().create_trivial<RectOp>(
Chris Craikb565df12015-10-05 13:00:52 -0700284 Rect(left, top, right, bottom),
285 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800286 getRecordedClip(),
Chris Craikb565df12015-10-05 13:00:52 -0700287 refPaint(&paint)));
288}
289
290void RecordingCanvas::drawSimpleRects(const float* rects, int vertexCount, const SkPaint* paint) {
291 if (rects == nullptr) return;
292
John Reck7df9ff22016-02-10 16:08:08 -0800293 Vertex* rectData = (Vertex*) mDisplayList->allocator.alloc<Vertex>(vertexCount * sizeof(Vertex));
Chris Craikb565df12015-10-05 13:00:52 -0700294 Vertex* vertex = rectData;
295
296 float left = FLT_MAX;
297 float top = FLT_MAX;
298 float right = FLT_MIN;
299 float bottom = FLT_MIN;
300 for (int index = 0; index < vertexCount; index += 4) {
301 float l = rects[index + 0];
302 float t = rects[index + 1];
303 float r = rects[index + 2];
304 float b = rects[index + 3];
305
306 Vertex::set(vertex++, l, t);
307 Vertex::set(vertex++, r, t);
308 Vertex::set(vertex++, l, b);
309 Vertex::set(vertex++, r, b);
310
311 left = std::min(left, l);
312 top = std::min(top, t);
313 right = std::max(right, r);
314 bottom = std::max(bottom, b);
315 }
John Reck7df9ff22016-02-10 16:08:08 -0800316 addOp(alloc().create_trivial<SimpleRectsOp>(
Chris Craikb565df12015-10-05 13:00:52 -0700317 Rect(left, top, right, bottom),
318 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800319 getRecordedClip(),
Chris Craikb565df12015-10-05 13:00:52 -0700320 refPaint(paint), rectData, vertexCount));
321}
322
323void RecordingCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) {
324 if (paint.getStyle() == SkPaint::kFill_Style
325 && (!paint.isAntiAlias() || mState.currentTransform()->isSimple())) {
326 int count = 0;
327 Vector<float> rects;
328 SkRegion::Iterator it(region);
329 while (!it.done()) {
330 const SkIRect& r = it.rect();
331 rects.push(r.fLeft);
332 rects.push(r.fTop);
333 rects.push(r.fRight);
334 rects.push(r.fBottom);
335 count += 4;
336 it.next();
337 }
338 drawSimpleRects(rects.array(), count, &paint);
339 } else {
340 SkRegion::Iterator it(region);
341 while (!it.done()) {
342 const SkIRect& r = it.rect();
343 drawRect(r.fLeft, r.fTop, r.fRight, r.fBottom, paint);
344 it.next();
345 }
346 }
347}
348void RecordingCanvas::drawRoundRect(float left, float top, float right, float bottom,
349 float rx, float ry, const SkPaint& paint) {
John Reck7df9ff22016-02-10 16:08:08 -0800350 addOp(alloc().create_trivial<RoundRectOp>(
Chris Craik386aa032015-12-07 17:08:25 -0800351 Rect(left, top, right, bottom),
352 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800353 getRecordedClip(),
Chris Craik386aa032015-12-07 17:08:25 -0800354 refPaint(&paint), rx, ry));
Chris Craikb565df12015-10-05 13:00:52 -0700355}
Chris Craik386aa032015-12-07 17:08:25 -0800356
Chris Craik268a9c02015-12-09 18:05:12 -0800357void RecordingCanvas::drawRoundRect(
358 CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
359 CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
360 CanvasPropertyPrimitive* rx, CanvasPropertyPrimitive* ry,
361 CanvasPropertyPaint* paint) {
362 mDisplayList->ref(left);
363 mDisplayList->ref(top);
364 mDisplayList->ref(right);
365 mDisplayList->ref(bottom);
366 mDisplayList->ref(rx);
367 mDisplayList->ref(ry);
368 mDisplayList->ref(paint);
369 refBitmapsInShader(paint->value.getShader());
John Reck7df9ff22016-02-10 16:08:08 -0800370 addOp(alloc().create_trivial<RoundRectPropsOp>(
Chris Craik268a9c02015-12-09 18:05:12 -0800371 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800372 getRecordedClip(),
Chris Craik268a9c02015-12-09 18:05:12 -0800373 &paint->value,
374 &left->value, &top->value, &right->value, &bottom->value,
375 &rx->value, &ry->value));
376}
377
Chris Craikb565df12015-10-05 13:00:52 -0700378void RecordingCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) {
Chris Craik268a9c02015-12-09 18:05:12 -0800379 // TODO: move to Canvas.h
Chris Craik386aa032015-12-07 17:08:25 -0800380 if (radius <= 0) return;
381 drawOval(x - radius, y - radius, x + radius, y + radius, paint);
Chris Craikb565df12015-10-05 13:00:52 -0700382}
Chris Craik386aa032015-12-07 17:08:25 -0800383
Chris Craik268a9c02015-12-09 18:05:12 -0800384void RecordingCanvas::drawCircle(
385 CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
386 CanvasPropertyPrimitive* radius, CanvasPropertyPaint* paint) {
387 mDisplayList->ref(x);
388 mDisplayList->ref(y);
389 mDisplayList->ref(radius);
390 mDisplayList->ref(paint);
391 refBitmapsInShader(paint->value.getShader());
John Reck7df9ff22016-02-10 16:08:08 -0800392 addOp(alloc().create_trivial<CirclePropsOp>(
Chris Craik268a9c02015-12-09 18:05:12 -0800393 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800394 getRecordedClip(),
Chris Craik268a9c02015-12-09 18:05:12 -0800395 &paint->value,
396 &x->value, &y->value, &radius->value));
397}
398
Chris Craikb565df12015-10-05 13:00:52 -0700399void RecordingCanvas::drawOval(float left, float top, float right, float bottom, const SkPaint& paint) {
John Reck7df9ff22016-02-10 16:08:08 -0800400 addOp(alloc().create_trivial<OvalOp>(
Chris Craik386aa032015-12-07 17:08:25 -0800401 Rect(left, top, right, bottom),
402 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800403 getRecordedClip(),
Chris Craik386aa032015-12-07 17:08:25 -0800404 refPaint(&paint)));
Chris Craikb565df12015-10-05 13:00:52 -0700405}
Chris Craik386aa032015-12-07 17:08:25 -0800406
Chris Craikb565df12015-10-05 13:00:52 -0700407void RecordingCanvas::drawArc(float left, float top, float right, float bottom,
Chris Craik386aa032015-12-07 17:08:25 -0800408 float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) {
Chris Craikcaa24182016-02-19 15:20:35 -0800409 if (fabs(sweepAngle) >= 360.0f) {
410 drawOval(left, top, right, bottom, paint);
411 } else {
412 addOp(alloc().create_trivial<ArcOp>(
413 Rect(left, top, right, bottom),
414 *(mState.currentSnapshot()->transform),
415 getRecordedClip(),
416 refPaint(&paint),
417 startAngle, sweepAngle, useCenter));
418 }
Chris Craikb565df12015-10-05 13:00:52 -0700419}
Chris Craik386aa032015-12-07 17:08:25 -0800420
Chris Craikb565df12015-10-05 13:00:52 -0700421void RecordingCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
John Reck7df9ff22016-02-10 16:08:08 -0800422 addOp(alloc().create_trivial<PathOp>(
Chris Craik386aa032015-12-07 17:08:25 -0800423 Rect(path.getBounds()),
424 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800425 getRecordedClip(),
Chris Craik386aa032015-12-07 17:08:25 -0800426 refPaint(&paint), refPath(&path)));
Chris Craikb565df12015-10-05 13:00:52 -0700427}
428
Doris Liu766431a2016-02-04 22:17:11 +0000429void RecordingCanvas::drawVectorDrawable(VectorDrawableRoot* tree) {
430 mDisplayList->ref(tree);
John Reck7df9ff22016-02-10 16:08:08 -0800431 addOp(alloc().create_trivial<VectorDrawableOp>(
Doris Liu766431a2016-02-04 22:17:11 +0000432 tree,
433 Rect(tree->getBounds()),
434 *(mState.currentSnapshot()->transform),
435 getRecordedClip()));
436}
437
Chris Craikb565df12015-10-05 13:00:52 -0700438// Bitmap-based
439void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, float left, float top, const SkPaint* paint) {
Florin Malitaeecff562015-12-21 10:43:01 -0500440 save(SaveFlags::Matrix);
Chris Craikb565df12015-10-05 13:00:52 -0700441 translate(left, top);
442 drawBitmap(&bitmap, paint);
443 restore();
444}
445
446void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix,
447 const SkPaint* paint) {
448 if (matrix.isIdentity()) {
449 drawBitmap(&bitmap, paint);
450 } else if (!(matrix.getType() & ~(SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask))
451 && MathUtils::isPositive(matrix.getScaleX())
452 && MathUtils::isPositive(matrix.getScaleY())) {
453 // SkMatrix::isScaleTranslate() not available in L
454 SkRect src;
455 SkRect dst;
456 bitmap.getBounds(&src);
457 matrix.mapRect(&dst, src);
458 drawBitmap(bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom,
459 dst.fLeft, dst.fTop, dst.fRight, dst.fBottom, paint);
460 } else {
Florin Malitaeecff562015-12-21 10:43:01 -0500461 save(SaveFlags::Matrix);
Chris Craikb565df12015-10-05 13:00:52 -0700462 concat(matrix);
463 drawBitmap(&bitmap, paint);
464 restore();
465 }
466}
Chris Craik386aa032015-12-07 17:08:25 -0800467
Chris Craikb565df12015-10-05 13:00:52 -0700468void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, float srcLeft, float srcTop,
469 float srcRight, float srcBottom, float dstLeft, float dstTop,
470 float dstRight, float dstBottom, const SkPaint* paint) {
471 if (srcLeft == 0 && srcTop == 0
472 && srcRight == bitmap.width()
473 && srcBottom == bitmap.height()
474 && (srcBottom - srcTop == dstBottom - dstTop)
475 && (srcRight - srcLeft == dstRight - dstLeft)) {
476 // transform simple rect to rect drawing case into position bitmap ops, since they merge
Florin Malitaeecff562015-12-21 10:43:01 -0500477 save(SaveFlags::Matrix);
Chris Craikb565df12015-10-05 13:00:52 -0700478 translate(dstLeft, dstTop);
479 drawBitmap(&bitmap, paint);
480 restore();
481 } else {
John Reck7df9ff22016-02-10 16:08:08 -0800482 addOp(alloc().create_trivial<BitmapRectOp>(
Chris Craikf09ff5a2015-12-08 17:21:58 -0800483 Rect(dstLeft, dstTop, dstRight, dstBottom),
484 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800485 getRecordedClip(),
Chris Craikf09ff5a2015-12-08 17:21:58 -0800486 refPaint(paint), refBitmap(bitmap),
487 Rect(srcLeft, srcTop, srcRight, srcBottom)));
Chris Craikb565df12015-10-05 13:00:52 -0700488 }
489}
Chris Craik386aa032015-12-07 17:08:25 -0800490
Chris Craikb565df12015-10-05 13:00:52 -0700491void RecordingCanvas::drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight,
492 const float* vertices, const int* colors, const SkPaint* paint) {
Chris Craikf09ff5a2015-12-08 17:21:58 -0800493 int vertexCount = (meshWidth + 1) * (meshHeight + 1);
John Reck7df9ff22016-02-10 16:08:08 -0800494 addOp(alloc().create_trivial<BitmapMeshOp>(
Chris Craikf09ff5a2015-12-08 17:21:58 -0800495 calcBoundsOfPoints(vertices, vertexCount * 2),
496 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800497 getRecordedClip(),
Chris Craikf09ff5a2015-12-08 17:21:58 -0800498 refPaint(paint), refBitmap(bitmap), meshWidth, meshHeight,
499 refBuffer<float>(vertices, vertexCount * 2), // 2 floats per vertex
500 refBuffer<int>(colors, vertexCount))); // 1 color per vertex
Chris Craikb565df12015-10-05 13:00:52 -0700501}
Chris Craik386aa032015-12-07 17:08:25 -0800502
Chris Craikf09ff5a2015-12-08 17:21:58 -0800503void RecordingCanvas::drawNinePatch(const SkBitmap& bitmap, const android::Res_png_9patch& patch,
Chris Craikb565df12015-10-05 13:00:52 -0700504 float dstLeft, float dstTop, float dstRight, float dstBottom,
505 const SkPaint* paint) {
John Reck7df9ff22016-02-10 16:08:08 -0800506 addOp(alloc().create_trivial<PatchOp>(
Chris Craikf09ff5a2015-12-08 17:21:58 -0800507 Rect(dstLeft, dstTop, dstRight, dstBottom),
508 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800509 getRecordedClip(),
Chris Craikf09ff5a2015-12-08 17:21:58 -0800510 refPaint(paint), refBitmap(bitmap), refPatch(&patch)));
Chris Craikb565df12015-10-05 13:00:52 -0700511}
512
513// Text
Chris Craika1717272015-11-19 13:02:43 -0800514void RecordingCanvas::drawText(const uint16_t* glyphs, const float* positions, int glyphCount,
Chris Craikb565df12015-10-05 13:00:52 -0700515 const SkPaint& paint, float x, float y, float boundsLeft, float boundsTop,
516 float boundsRight, float boundsBottom, float totalAdvance) {
Chris Craika1717272015-11-19 13:02:43 -0800517 if (!glyphs || !positions || glyphCount <= 0 || PaintUtils::paintWillNotDrawText(paint)) return;
518 glyphs = refBuffer<glyph_t>(glyphs, glyphCount);
519 positions = refBuffer<float>(positions, glyphCount * 2);
520
Chris Craik15c3f192015-12-03 12:16:56 -0800521 // TODO: either must account for text shadow in bounds, or record separate ops for text shadows
John Reck7df9ff22016-02-10 16:08:08 -0800522 addOp(alloc().create_trivial<TextOp>(
Chris Craika1717272015-11-19 13:02:43 -0800523 Rect(boundsLeft, boundsTop, boundsRight, boundsBottom),
524 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800525 getRecordedClip(),
Chris Craika1717272015-11-19 13:02:43 -0800526 refPaint(&paint), glyphs, positions, glyphCount, x, y));
527 drawTextDecorations(x, y, totalAdvance, paint);
Chris Craikb565df12015-10-05 13:00:52 -0700528}
Chris Craika1717272015-11-19 13:02:43 -0800529
Chris Craikd7448e62015-12-15 10:34:36 -0800530void RecordingCanvas::drawTextOnPath(const uint16_t* glyphs, int glyphCount, const SkPath& path,
Chris Craikb565df12015-10-05 13:00:52 -0700531 float hOffset, float vOffset, const SkPaint& paint) {
Chris Craikd7448e62015-12-15 10:34:36 -0800532 if (!glyphs || glyphCount <= 0 || PaintUtils::paintWillNotDrawText(paint)) return;
533 glyphs = refBuffer<glyph_t>(glyphs, glyphCount);
John Reck7df9ff22016-02-10 16:08:08 -0800534 addOp(alloc().create_trivial<TextOnPathOp>(
Chris Craike4db79d2015-12-22 16:32:23 -0800535 mState.getLocalClipBounds(), // TODO: explicitly define bounds
Chris Craikd7448e62015-12-15 10:34:36 -0800536 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800537 getRecordedClip(),
Chris Craikd7448e62015-12-15 10:34:36 -0800538 refPaint(&paint), glyphs, glyphCount, refPath(&path), hOffset, vOffset));
Chris Craikb565df12015-10-05 13:00:52 -0700539}
540
541void RecordingCanvas::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) {
John Reck7df9ff22016-02-10 16:08:08 -0800542 addOp(alloc().create_trivial<BitmapOp>(
Chris Craik5430ab22015-12-10 16:28:16 -0800543 Rect(bitmap->width(), bitmap->height()),
Chris Craikb565df12015-10-05 13:00:52 -0700544 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800545 getRecordedClip(),
Chris Craikb565df12015-10-05 13:00:52 -0700546 refPaint(paint), refBitmap(*bitmap)));
547}
Chris Craike29ce6f2015-12-10 16:25:13 -0800548
Chris Craikb565df12015-10-05 13:00:52 -0700549void RecordingCanvas::drawRenderNode(RenderNode* renderNode) {
Chris Craik54fa17f2015-11-25 14:14:53 -0800550 auto&& stagingProps = renderNode->stagingProperties();
John Reck7df9ff22016-02-10 16:08:08 -0800551 RenderNodeOp* op = alloc().create_trivial<RenderNodeOp>(
Chris Craik54fa17f2015-11-25 14:14:53 -0800552 Rect(stagingProps.getWidth(), stagingProps.getHeight()),
Chris Craikb565df12015-10-05 13:00:52 -0700553 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800554 getRecordedClip(),
Chris Craikb565df12015-10-05 13:00:52 -0700555 renderNode);
556 int opIndex = addOp(op);
Chris Craik003cc3d2015-10-16 10:24:55 -0700557 int childIndex = mDisplayList->addChild(op);
Chris Craikb565df12015-10-05 13:00:52 -0700558
559 // update the chunk's child indices
Chris Craik003cc3d2015-10-16 10:24:55 -0700560 DisplayList::Chunk& chunk = mDisplayList->chunks.back();
Chris Craikb565df12015-10-05 13:00:52 -0700561 chunk.endChildIndex = childIndex + 1;
562
563 if (renderNode->stagingProperties().isProjectionReceiver()) {
564 // use staging property, since recording on UI thread
Chris Craik003cc3d2015-10-16 10:24:55 -0700565 mDisplayList->projectionReceiveIndex = opIndex;
Chris Craikb565df12015-10-05 13:00:52 -0700566 }
567}
568
Chris Craikd2dfd8f2015-12-16 14:27:20 -0800569void RecordingCanvas::drawLayer(DeferredLayerUpdater* layerHandle) {
570 // We ref the DeferredLayerUpdater due to its thread-safe ref-counting semantics.
571 mDisplayList->ref(layerHandle);
572
573 Layer* layer = layerHandle->backingLayer();
574 Matrix4 totalTransform(*(mState.currentSnapshot()->transform));
575 totalTransform.multiply(layer->getTransform());
576
John Reck7df9ff22016-02-10 16:08:08 -0800577 addOp(alloc().create_trivial<TextureLayerOp>(
Chris Craikd2dfd8f2015-12-16 14:27:20 -0800578 Rect(layer->getWidth(), layer->getHeight()),
579 totalTransform,
Chris Craike4db79d2015-12-22 16:32:23 -0800580 getRecordedClip(),
Chris Craikd2dfd8f2015-12-16 14:27:20 -0800581 layer));
582}
583
Chris Craike29ce6f2015-12-10 16:25:13 -0800584void RecordingCanvas::callDrawGLFunction(Functor* functor) {
585 mDisplayList->functors.push_back(functor);
John Reck7df9ff22016-02-10 16:08:08 -0800586 addOp(alloc().create_trivial<FunctorOp>(
Chris Craike4db79d2015-12-22 16:32:23 -0800587 mState.getLocalClipBounds(), // TODO: explicitly define bounds
Chris Craike29ce6f2015-12-10 16:25:13 -0800588 *(mState.currentSnapshot()->transform),
Chris Craike4db79d2015-12-22 16:32:23 -0800589 getRecordedClip(),
Chris Craike29ce6f2015-12-10 16:25:13 -0800590 functor));
591}
592
Chris Craikb565df12015-10-05 13:00:52 -0700593size_t RecordingCanvas::addOp(RecordedOp* op) {
594 // TODO: validate if "addDrawOp" quickrejection logic is useful before adding
Chris Craik003cc3d2015-10-16 10:24:55 -0700595 int insertIndex = mDisplayList->ops.size();
596 mDisplayList->ops.push_back(op);
Chris Craik161f54b2015-11-05 11:08:52 -0800597 if (mDeferredBarrierType != DeferredBarrierType::None) {
Chris Craikb565df12015-10-05 13:00:52 -0700598 // op is first in new chunk
Chris Craik003cc3d2015-10-16 10:24:55 -0700599 mDisplayList->chunks.emplace_back();
600 DisplayList::Chunk& newChunk = mDisplayList->chunks.back();
Chris Craikb565df12015-10-05 13:00:52 -0700601 newChunk.beginOpIndex = insertIndex;
602 newChunk.endOpIndex = insertIndex + 1;
Chris Craik161f54b2015-11-05 11:08:52 -0800603 newChunk.reorderChildren = (mDeferredBarrierType == DeferredBarrierType::OutOfOrder);
Chris Craikb565df12015-10-05 13:00:52 -0700604
Chris Craikb36af872015-10-16 14:23:12 -0700605 int nextChildIndex = mDisplayList->children.size();
Chris Craikb565df12015-10-05 13:00:52 -0700606 newChunk.beginChildIndex = newChunk.endChildIndex = nextChildIndex;
Chris Craik161f54b2015-11-05 11:08:52 -0800607 mDeferredBarrierType = DeferredBarrierType::None;
Chris Craikb565df12015-10-05 13:00:52 -0700608 } else {
609 // standard case - append to existing chunk
Chris Craik003cc3d2015-10-16 10:24:55 -0700610 mDisplayList->chunks.back().endOpIndex = insertIndex + 1;
Chris Craikb565df12015-10-05 13:00:52 -0700611 }
612 return insertIndex;
613}
614
615void RecordingCanvas::refBitmapsInShader(const SkShader* shader) {
616 if (!shader) return;
617
618 // If this paint has an SkShader that has an SkBitmap add
619 // it to the bitmap pile
620 SkBitmap bitmap;
621 SkShader::TileMode xy[2];
Leon Scroggins IIIf35b9892015-07-31 10:38:40 -0400622 if (shader->isABitmap(&bitmap, nullptr, xy)) {
Chris Craikb565df12015-10-05 13:00:52 -0700623 refBitmap(bitmap);
624 return;
625 }
626 SkShader::ComposeRec rec;
627 if (shader->asACompose(&rec)) {
628 refBitmapsInShader(rec.fShaderA);
629 refBitmapsInShader(rec.fShaderB);
630 return;
631 }
632}
633
634}; // namespace uirenderer
635}; // namespace android