[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / 4cf51cc5105e85b292918ee8094971c85225b0f3 / . / cc / paint / paint_canvas.h
blob: 7781c0ad512fe49a623aba7f9506876fbf02b44b [file] [log] [blame]
enne34f6084c2017-02-02 22:39:08[diff] [blame]1// Copyright 2017 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CC_PAINT_PAINT_CANVAS_H_
6#define CC_PAINT_PAINT_CANVAS_H_
7
enned2501572017-03-09 19:59:17[diff] [blame]8#include "base/compiler_specific.h"
enneea15ddb2017-03-22 01:49:08[diff] [blame]9#include "base/memory/ref_counted.h"
enne7b64edf32017-02-16 20:10:02[diff] [blame]10#include "build/build_config.h"
Tao Bai1e1deb412019-07-21 16:14:00[diff] [blame]11#include "cc/paint/node_id.h"
enne34f6084c2017-02-02 22:39:08[diff] [blame]12#include "cc/paint/paint_export.h"
vmpstr94cfa882017-04-14 01:19:35[diff] [blame]13#include "cc/paint/paint_image.h"
Eric Sum4cf51cc2021-11-09 02:21:38[diff] [blame^]14#include "cc/paint/skottie_frame_data.h"
enne34f6084c2017-02-02 22:39:08[diff] [blame]15#include "third_party/skia/include/core/SkCanvas.h"
Peter Kasting73ee7ef2021-07-20 19:47:56[diff] [blame]16
17class SkTextBlob;
enne34f6084c2017-02-02 22:39:08[diff] [blame]18
Florin Malita15935772019-02-06 21:52:24[diff] [blame]19namespace printing {
20class MetafileSkia;
21} // namespace printing
22
ckitagawa53eeaef2019-11-08 15:17:34[diff] [blame]23namespace paint_preview {
24class PaintPreviewTracker;
25} // namespace paint_preview
26
enne34f6084c2017-02-02 22:39:08[diff] [blame]27namespace cc {
Malay Keshavcf4ceef12018-10-19 17:56:51[diff] [blame]28class SkottieWrapper;
enned2501572017-03-09 19:59:17[diff] [blame]29class PaintFlags;
enne59df29de2017-05-02 03:23:37[diff] [blame]30class PaintOpBuffer;
31
Justin Novosad2756a7d52021-06-09 15:50:38[diff] [blame]32enum class UsePaintCache { kDisabled = 0, kEnabled };
33
enne59df29de2017-05-02 03:23:37[diff] [blame]34using PaintRecord = PaintOpBuffer;
enne34f6084c2017-02-02 22:39:08[diff] [blame]35
Adrienne Walker26aac6e52018-10-23 19:23:37[diff] [blame]36// PaintCanvas is the cc/paint wrapper of SkCanvas. It has a more restricted
37// interface than SkCanvas (trimmed back to only what Chrome uses). Its reason
38// for existence is so that it can do custom serialization logic into a
39// PaintOpBuffer which (unlike SkPicture) is mutable, handles image replacement,
40// and can be serialized in custom ways (such as using the transfer cache).
41//
42// PaintCanvas is usually implemented by either:
43// (1) SkiaPaintCanvas, which is backed by an SkCanvas, usually for rasterizing.
44// (2) RecordPaintCanvas, which records paint commands into a PaintOpBuffer.
45//
46// SkiaPaintCanvas allows callers to go from PaintCanvas to SkCanvas (or
47// PaintRecord to SkPicture), but this is a one way trip. There is no way to go
48// from SkCanvas to PaintCanvas or from SkPicture back into PaintRecord.
enned2501572017-03-09 19:59:17[diff] [blame]49class CC_PAINT_EXPORT PaintCanvas {
enne34f6084c2017-02-02 22:39:08[diff] [blame]50 public:
Vladimir Levinf06d1cd72019-03-13 18:24:10[diff] [blame]51 PaintCanvas() = default;
52 PaintCanvas(const PaintCanvas&) = delete;
53 virtual ~PaintCanvas() = default;
54
55 PaintCanvas& operator=(const PaintCanvas&) = delete;
khushalsagarb74f9122017-03-22 04:37:47[diff] [blame]56
enne59df29de2017-05-02 03:23:37[diff] [blame]57 // TODO(enne): this only appears to mostly be used to determine if this is
58 // recording or not, so could be simplified or removed.
enne98c9f8052017-03-15 19:38:22[diff] [blame]59 virtual SkImageInfo imageInfo() const = 0;
enned2501572017-03-09 19:59:17[diff] [blame]60
Tom Andersonbec09512019-09-16 20:32:16[diff] [blame]61 virtual void* accessTopLayerPixels(SkImageInfo* info,
62 size_t* rowBytes,
63 SkIPoint* origin = nullptr) = 0;
64
enned2501572017-03-09 19:59:17[diff] [blame]65 // TODO(enne): It would be nice to get rid of flush() entirely, as it
66 // doesn't really make sense for recording. However, this gets used by
zhuoyu.qian4689dde22017-10-16 04:11:48[diff] [blame]67 // PaintCanvasVideoRenderer which takes a PaintCanvas to paint both
enned2501572017-03-09 19:59:17[diff] [blame]68 // software and hardware video. This is super entangled with ImageBuffer
69 // and canvas/video painting in Blink where the same paths are used for
70 // both recording and gpu work.
enne98c9f8052017-03-15 19:38:22[diff] [blame]71 virtual void flush() = 0;
enned2501572017-03-09 19:59:17[diff] [blame]72
enne98c9f8052017-03-15 19:38:22[diff] [blame]73 virtual int save() = 0;
74 virtual int saveLayer(const SkRect* bounds, const PaintFlags* flags) = 0;
Peter Kastingfe4ba932019-01-07 20:21:05[diff] [blame]75 virtual int saveLayerAlpha(const SkRect* bounds, uint8_t alpha) = 0;
enne98c9f8052017-03-15 19:38:22[diff] [blame]76
77 virtual void restore() = 0;
78 virtual int getSaveCount() const = 0;
79 virtual void restoreToCount(int save_count) = 0;
80 virtual void translate(SkScalar dx, SkScalar dy) = 0;
81 virtual void scale(SkScalar sx, SkScalar sy) = 0;
82 virtual void rotate(SkScalar degrees) = 0;
Aaron Krajeski5e542c82020-12-05 01:50:21[diff] [blame]83 // TODO(aaronhk): crbug.com/1153330 deprecate these in favor of the SkM44
Aaron Krajeski8a128e232020-12-15 21:47:06[diff] [blame]84 // versions.
enne98c9f8052017-03-15 19:38:22[diff] [blame]85 virtual void concat(const SkMatrix& matrix) = 0;
86 virtual void setMatrix(const SkMatrix& matrix) = 0;
Aaron Krajeski8a128e232020-12-15 21:47:06[diff] [blame]87 virtual void concat(const SkM44& matrix) = 0;
Aaron Krajeski5e542c82020-12-05 01:50:21[diff] [blame]88 virtual void setMatrix(const SkM44& matrix) = 0;
89
enne98c9f8052017-03-15 19:38:22[diff] [blame]90 virtual void clipRect(const SkRect& rect,
91 SkClipOp op,
92 bool do_anti_alias) = 0;
93 void clipRect(const SkRect& rect, SkClipOp op) { clipRect(rect, op, false); }
94 void clipRect(const SkRect& rect, bool do_anti_alias) {
95 clipRect(rect, SkClipOp::kIntersect, do_anti_alias);
enned2501572017-03-09 19:59:17[diff] [blame]96 }
enne98c9f8052017-03-15 19:38:22[diff] [blame]97 void clipRect(const SkRect& rect) {
98 clipRect(rect, SkClipOp::kIntersect, false);
enned2501572017-03-09 19:59:17[diff] [blame]99 }
100
enne98c9f8052017-03-15 19:38:22[diff] [blame]101 virtual void clipRRect(const SkRRect& rrect,
102 SkClipOp op,
103 bool do_anti_alias) = 0;
104 void clipRRect(const SkRRect& rrect, bool do_anti_alias) {
105 clipRRect(rrect, SkClipOp::kIntersect, do_anti_alias);
enned2501572017-03-09 19:59:17[diff] [blame]106 }
enne98c9f8052017-03-15 19:38:22[diff] [blame]107 void clipRRect(const SkRRect& rrect, SkClipOp op) {
108 clipRRect(rrect, op, false);
enned2501572017-03-09 19:59:17[diff] [blame]109 }
enne98c9f8052017-03-15 19:38:22[diff] [blame]110 void clipRRect(const SkRRect& rrect) {
111 clipRRect(rrect, SkClipOp::kIntersect, false);
enned2501572017-03-09 19:59:17[diff] [blame]112 }
enned2501572017-03-09 19:59:17[diff] [blame]113
enne98c9f8052017-03-15 19:38:22[diff] [blame]114 virtual void clipPath(const SkPath& path,
115 SkClipOp op,
Justin Novosad2756a7d52021-06-09 15:50:38[diff] [blame]116 bool do_anti_alias,
117 UsePaintCache) = 0;
118 void clipPath(const SkPath& path, SkClipOp op, bool do_anti_alias) {
119 clipPath(path, op, do_anti_alias, UsePaintCache::kEnabled);
120 }
121 void clipPath(const SkPath& path, SkClipOp op) {
122 clipPath(path, op, /*do_anti_alias=*/false, UsePaintCache::kEnabled);
123 }
enne98c9f8052017-03-15 19:38:22[diff] [blame]124 void clipPath(const SkPath& path, bool do_anti_alias) {
Justin Novosad2756a7d52021-06-09 15:50:38[diff] [blame]125 clipPath(path, SkClipOp::kIntersect, do_anti_alias,
126 UsePaintCache::kEnabled);
enned2501572017-03-09 19:59:17[diff] [blame]127 }
enne98c9f8052017-03-15 19:38:22[diff] [blame]128
enne98c9f8052017-03-15 19:38:22[diff] [blame]129 virtual SkRect getLocalClipBounds() const = 0;
130 virtual bool getLocalClipBounds(SkRect* bounds) const = 0;
131 virtual SkIRect getDeviceClipBounds() const = 0;
132 virtual bool getDeviceClipBounds(SkIRect* bounds) const = 0;
133 virtual void drawColor(SkColor color, SkBlendMode mode) = 0;
134 void drawColor(SkColor color) { drawColor(color, SkBlendMode::kSrcOver); }
enne59df29de2017-05-02 03:23:37[diff] [blame]135
136 // TODO(enne): This is a synonym for drawColor with kSrc. Remove it.
enne98c9f8052017-03-15 19:38:22[diff] [blame]137 virtual void clear(SkColor color) = 0;
138
139 virtual void drawLine(SkScalar x0,
140 SkScalar y0,
141 SkScalar x1,
142 SkScalar y1,
143 const PaintFlags& flags) = 0;
144 virtual void drawRect(const SkRect& rect, const PaintFlags& flags) = 0;
145 virtual void drawIRect(const SkIRect& rect, const PaintFlags& flags) = 0;
146 virtual void drawOval(const SkRect& oval, const PaintFlags& flags) = 0;
147 virtual void drawRRect(const SkRRect& rrect, const PaintFlags& flags) = 0;
148 virtual void drawDRRect(const SkRRect& outer,
149 const SkRRect& inner,
150 const PaintFlags& flags) = 0;
enne98c9f8052017-03-15 19:38:22[diff] [blame]151 virtual void drawRoundRect(const SkRect& rect,
152 SkScalar rx,
153 SkScalar ry,
154 const PaintFlags& flags) = 0;
Justin Novosad2756a7d52021-06-09 15:50:38[diff] [blame]155 virtual void drawPath(const SkPath& path,
156 const PaintFlags& flags,
157 UsePaintCache) = 0;
158 void drawPath(const SkPath& path, const PaintFlags& flags) {
159 drawPath(path, flags, UsePaintCache::kEnabled);
160 }
vmpstr94cfa882017-04-14 01:19:35[diff] [blame]161 virtual void drawImage(const PaintImage& image,
enne98c9f8052017-03-15 19:38:22[diff] [blame]162 SkScalar left,
163 SkScalar top,
Mike Reed859086a2021-01-23 18:19:15[diff] [blame]164 const SkSamplingOptions&,
enne98c9f8052017-03-15 19:38:22[diff] [blame]165 const PaintFlags* flags) = 0;
vmpstr94cfa882017-04-14 01:19:35[diff] [blame]166 void drawImage(const PaintImage& image, SkScalar left, SkScalar top) {
Mike Reed859086a2021-01-23 18:19:15[diff] [blame]167 drawImage(image, left, top, SkSamplingOptions(), nullptr);
enned2501572017-03-09 19:59:17[diff] [blame]168 }
169
vmpstr94cfa882017-04-14 01:19:35[diff] [blame]170 virtual void drawImageRect(const PaintImage& image,
enne98c9f8052017-03-15 19:38:22[diff] [blame]171 const SkRect& src,
172 const SkRect& dst,
Mike Reed859086a2021-01-23 18:19:15[diff] [blame]173 const SkSamplingOptions&,
enne98c9f8052017-03-15 19:38:22[diff] [blame]174 const PaintFlags* flags,
jongdeok.kim50b377072020-05-15 22:16:12[diff] [blame]175 SkCanvas::SrcRectConstraint constraint) = 0;
Mike Reed859086a2021-01-23 18:19:15[diff] [blame]176 void drawImageRect(const PaintImage& image,
177 const SkRect& src,
178 const SkRect& dst,
179 SkCanvas::SrcRectConstraint constraint) {
180 drawImageRect(image, src, dst, SkSamplingOptions(), nullptr, constraint);
181 }
enned2501572017-03-09 19:59:17[diff] [blame]182
Malay Keshavcf4ceef12018-10-19 17:56:51[diff] [blame]183 // Draws the frame of the |skottie| animation specified by the normalized time
184 // t [0->first frame..1->last frame] at the destination bounds given by |dst|
Eric Sum4cf51cc2021-11-09 02:21:38[diff] [blame^]185 // onto the canvas. |images| is a map from asset id to the corresponding image
186 // to use when rendering this frame; it may be empty if this animation frame
187 // does not contain any images in it.
Malay Keshavcf4ceef12018-10-19 17:56:51[diff] [blame]188 virtual void drawSkottie(scoped_refptr<SkottieWrapper> skottie,
189 const SkRect& dst,
Eric Sum4cf51cc2021-11-09 02:21:38[diff] [blame^]190 float t,
191 SkottieFrameDataMap images) = 0;
Malay Keshavcf4ceef12018-10-19 17:56:51[diff] [blame]192
Khushal464808c92018-10-19 23:45:59[diff] [blame]193 virtual void drawTextBlob(sk_sp<SkTextBlob> blob,
enne98c9f8052017-03-15 19:38:22[diff] [blame]194 SkScalar x,
195 SkScalar y,
196 const PaintFlags& flags) = 0;
enned2501572017-03-09 19:59:17[diff] [blame]197
Tao Baiedaf87092019-01-30 23:12:54[diff] [blame]198 virtual void drawTextBlob(sk_sp<SkTextBlob> blob,
199 SkScalar x,
200 SkScalar y,
Tao Bai1e1deb412019-07-21 16:14:00[diff] [blame]201 NodeId node_id,
202 const PaintFlags& flags) = 0;
Tao Baiedaf87092019-01-30 23:12:54[diff] [blame]203
Adrienne Walker15ce23502017-05-08 18:08:15[diff] [blame]204 // Unlike SkCanvas::drawPicture, this only plays back the PaintRecord and does
205 // not add an additional clip. This is closer to SkPicture::playback.
ennedffda502017-03-23 20:46:43[diff] [blame]206 virtual void drawPicture(sk_sp<const PaintRecord> record) = 0;
enned2501572017-03-09 19:59:17[diff] [blame]207
enne98c9f8052017-03-15 19:38:22[diff] [blame]208 virtual bool isClipEmpty() const = 0;
Mike Reedf97e2d162020-01-07 15:26:43[diff] [blame]209 virtual SkMatrix getTotalMatrix() const = 0;
Aaron Krajeskie18de512021-04-15 15:17:03[diff] [blame]210 virtual SkM44 getLocalToDevice() const = 0;
enned2501572017-03-09 19:59:17[diff] [blame]211
Florin Malita15935772019-02-06 21:52:24[diff] [blame]212 // Used for printing
enne5fa117a2017-04-04 20:56:58[diff] [blame]213 enum class AnnotationType {
214 URL,
215 NAMED_DESTINATION,
216 LINK_TO_DESTINATION,
217 };
218 virtual void Annotate(AnnotationType type,
219 const SkRect& rect,
220 sk_sp<SkData> data) = 0;
Florin Malita15935772019-02-06 21:52:24[diff] [blame]221 printing::MetafileSkia* GetPrintingMetafile() const { return metafile_; }
222 void SetPrintingMetafile(printing::MetafileSkia* metafile) {
223 metafile_ = metafile;
224 }
ckitagawa53eeaef2019-11-08 15:17:34[diff] [blame]225 paint_preview::PaintPreviewTracker* GetPaintPreviewTracker() const {
226 return tracker_;
227 }
228 void SetPaintPreviewTracker(paint_preview::PaintPreviewTracker* tracker) {
229 tracker_ = tracker;
230 }
enned2501572017-03-09 19:59:17[diff] [blame]231
Wei Li2a9bfe42018-01-13 05:42:56[diff] [blame]232 // Subclasses can override to handle custom data.
233 virtual void recordCustomData(uint32_t id) {}
234
Dominic Mazzonicf5d6b02020-03-06 19:49:12[diff] [blame]235 // Used for marked content in PDF files.
236 virtual void setNodeId(int) = 0;
237
enne59df29de2017-05-02 03:23:37[diff] [blame]238 private:
Florin Malita15935772019-02-06 21:52:24[diff] [blame]239 printing::MetafileSkia* metafile_ = nullptr;
ckitagawa53eeaef2019-11-08 15:17:34[diff] [blame]240 paint_preview::PaintPreviewTracker* tracker_ = nullptr;
enne34f6084c2017-02-02 22:39:08[diff] [blame]241};
242
enned2501572017-03-09 19:59:17[diff] [blame]243class CC_PAINT_EXPORT PaintCanvasAutoRestore {
244 public:
enne98c9f8052017-03-15 19:38:22[diff] [blame]245 PaintCanvasAutoRestore(PaintCanvas* canvas, bool save) : canvas_(canvas) {
enned2501572017-03-09 19:59:17[diff] [blame]246 if (canvas_) {
247 save_count_ = canvas_->getSaveCount();
248 if (save) {
249 canvas_->save();
250 }
251 }
252 }
253
enne98c9f8052017-03-15 19:38:22[diff] [blame]254 ~PaintCanvasAutoRestore() {
enned2501572017-03-09 19:59:17[diff] [blame]255 if (canvas_) {
256 canvas_->restoreToCount(save_count_);
257 }
258 }
259
enne98c9f8052017-03-15 19:38:22[diff] [blame]260 void restore() {
enned2501572017-03-09 19:59:17[diff] [blame]261 if (canvas_) {
262 canvas_->restoreToCount(save_count_);
263 canvas_ = nullptr;
264 }
265 }
266
267 private:
268 PaintCanvas* canvas_ = nullptr;
269 int save_count_ = 0;
270};
271
enne34f6084c2017-02-02 22:39:08[diff] [blame]272} // namespace cc
273
274#endif // CC_PAINT_PAINT_CANVAS_H_