1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkSurface_Base_DEFINED
#define SkSurface_Base_DEFINED
#include "SkCanvas.h"
#include "SkImagePriv.h"
#include "SkSurface.h"
#include "SkSurfacePriv.h"
class SkSurface_Base : public SkSurface {
public:
SkSurface_Base(int width, int height, const SkSurfaceProps*);
SkSurface_Base(const SkImageInfo&, const SkSurfaceProps*);
virtual ~SkSurface_Base();
virtual GrBackendObject onGetTextureHandle(BackendHandleAccess) {
return 0;
}
virtual bool onGetRenderTargetHandle(GrBackendObject*, BackendHandleAccess) {
return false;
}
/**
* Allocate a canvas that will draw into this surface. We will cache this
* canvas, to return the same object to the caller multiple times. We
* take ownership, and will call unref() on the canvas when we go out of
* scope.
*/
virtual SkCanvas* onNewCanvas() = 0;
virtual sk_sp<SkSurface> onNewSurface(const SkImageInfo&) = 0;
/**
* Allocate an SkImage that represents the current contents of the surface.
* This needs to be able to outlive the surface itself (if need be), and
* must faithfully represent the current contents, even if the surface
* is changed after this called (e.g. it is drawn to via its canvas).
*/
virtual sk_sp<SkImage> onNewImageSnapshot() = 0;
/**
* Default implementation:
*
* image = this->newImageSnapshot();
* if (image) {
* image->draw(canvas, ...);
* image->unref();
* }
*/
virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*);
/**
* Called as a performance hint when the Surface is allowed to make it's contents
* undefined.
*/
virtual void onDiscard() {}
/**
* If the surface is about to change, we call this so that our subclass
* can optionally fork their backend (copy-on-write) in case it was
* being shared with the cachedImage.
*/
virtual void onCopyOnWrite(ContentChangeMode) = 0;
/**
* Signal the surface to remind its backing store that it's mutable again.
* Called only when we _didn't_ copy-on-write; we assume the copies start mutable.
*/
virtual void onRestoreBackingMutability() {}
/**
* Issue any pending surface IO to the current backend 3D API and resolve any surface MSAA.
* Inserts the requested number of semaphores for the gpu to signal when work is complete on the
* gpu and inits the array of GrBackendSemaphores with the signaled semaphores.
*/
virtual bool onFlush(int numSemaphores, GrBackendSemaphore* signalSemaphores) {
return false;
}
/**
* Caused the current backend 3D API to wait on the passed in semaphores before executing new
* commands on the gpu. Any previously submitting commands will not be blocked by these
* semaphores.
*/
virtual bool onWait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
return false;
}
inline SkCanvas* getCachedCanvas();
inline sk_sp<SkImage> refCachedImage();
bool hasCachedImage() const { return fCachedImage != nullptr; }
// called by SkSurface to compute a new genID
uint32_t newGenerationID();
private:
std::unique_ptr<SkCanvas> fCachedCanvas;
sk_sp<SkImage> fCachedImage;
void aboutToDraw(ContentChangeMode mode);
// Returns true if there is an outstanding image-snapshot, indicating that a call to aboutToDraw
// would trigger a copy-on-write.
bool outstandingImageSnapshot() const;
friend class SkCanvas;
friend class SkSurface;
typedef SkSurface INHERITED;
};
SkCanvas* SkSurface_Base::getCachedCanvas() {
if (nullptr == fCachedCanvas) {
fCachedCanvas = std::unique_ptr<SkCanvas>(this->onNewCanvas());
if (fCachedCanvas) {
fCachedCanvas->setSurfaceBase(this);
}
}
return fCachedCanvas.get();
}
sk_sp<SkImage> SkSurface_Base::refCachedImage() {
if (fCachedImage) {
return fCachedImage;
}
fCachedImage = this->onNewImageSnapshot();
SkASSERT(!fCachedCanvas || fCachedCanvas->getSurfaceBase() == this);
return fCachedImage;
}
#endif
|
