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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkSurfaceCharacterization_DEFINED
#define SkSurfaceCharacterization_DEFINED
#include "GrTypes.h"
#include "SkColorSpace.h"
#include "SkRefCnt.h"
#include "SkSurfaceProps.h"
class SkColorSpace;
// This define can be used to swap between the default (raster) DDL implementation and the
// gpu implementation.
#define SK_RASTER_RECORDER_IMPLEMENTATION 1
#if SK_SUPPORT_GPU
#include "GrContext.h"
/** \class SkSurfaceCharacterization
A surface characterization contains all the information Ganesh requires to makes its internal
rendering decisions. When passed into a SkDeferredDisplayListRecorder it will copy the
data and pass it on to the SkDeferredDisplayList if/when it is created. Note that both of
those objects (the Recorder and the DisplayList) will take a ref on the
GrContextThreadSafeProxy and SkColorSpace objects.
*/
class SkSurfaceCharacterization {
public:
enum class Textureable : bool { kNo = false, kYes = true };
enum class MipMapped : bool { kNo = false, kYes = true };
SkSurfaceCharacterization()
: fCacheMaxResourceBytes(0)
, fOrigin(kBottomLeft_GrSurfaceOrigin)
, fWidth(0)
, fHeight(0)
, fConfig(kUnknown_GrPixelConfig)
, fFSAAType(GrFSAAType::kNone)
, fStencilCnt(0)
, fIsTextureable(Textureable::kYes)
, fIsMipMapped(MipMapped::kYes)
, fSurfaceProps(0, kUnknown_SkPixelGeometry) {
}
SkSurfaceCharacterization(SkSurfaceCharacterization&&) = default;
SkSurfaceCharacterization& operator=(SkSurfaceCharacterization&&) = default;
SkSurfaceCharacterization(const SkSurfaceCharacterization&) = default;
SkSurfaceCharacterization& operator=(const SkSurfaceCharacterization& other) = default;
GrContextThreadSafeProxy* contextInfo() const { return fContextInfo.get(); }
size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; }
bool isValid() const { return kUnknown_GrPixelConfig != fConfig; }
GrSurfaceOrigin origin() const { return fOrigin; }
int width() const { return fWidth; }
int height() const { return fHeight; }
GrPixelConfig config() const { return fConfig; }
GrFSAAType fsaaType() const { return fFSAAType; }
int stencilCount() const { return fStencilCnt; }
bool isTextureable() const { return Textureable::kYes == fIsTextureable; }
bool isMipMapped() const { return MipMapped::kYes == fIsMipMapped; }
SkColorSpace* colorSpace() const { return fColorSpace.get(); }
sk_sp<SkColorSpace> refColorSpace() const { return fColorSpace; }
const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
private:
friend class SkSurface_Gpu; // for 'set'
friend class GrContextThreadSafeProxy; // for private ctor
SkSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,
size_t cacheMaxResourceBytes,
GrSurfaceOrigin origin, int width, int height,
GrPixelConfig config, GrFSAAType FSAAType, int stencilCnt,
Textureable isTextureable, MipMapped isMipMapped,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps& surfaceProps)
: fContextInfo(std::move(contextInfo))
, fCacheMaxResourceBytes(cacheMaxResourceBytes)
, fOrigin(origin)
, fWidth(width)
, fHeight(height)
, fConfig(config)
, fFSAAType(FSAAType)
, fStencilCnt(stencilCnt)
, fIsTextureable(isTextureable)
, fIsMipMapped(isMipMapped)
, fColorSpace(std::move(colorSpace))
, fSurfaceProps(surfaceProps) {
}
void set(sk_sp<GrContextThreadSafeProxy> contextInfo,
size_t cacheMaxResourceBytes,
GrSurfaceOrigin origin,
int width, int height,
GrPixelConfig config,
GrFSAAType fsaaType,
int stencilCnt,
Textureable isTextureable,
MipMapped isMipMapped,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps& surfaceProps) {
SkASSERT(MipMapped::kNo == isMipMapped || Textureable::kYes == isTextureable);
fContextInfo = contextInfo;
fCacheMaxResourceBytes = cacheMaxResourceBytes;
fOrigin = origin;
fWidth = width;
fHeight = height;
fConfig = config;
fFSAAType = fsaaType;
fStencilCnt = stencilCnt;
fIsTextureable = isTextureable;
fIsMipMapped = isMipMapped;
fColorSpace = std::move(colorSpace);
fSurfaceProps = surfaceProps;
}
sk_sp<GrContextThreadSafeProxy> fContextInfo;
size_t fCacheMaxResourceBytes;
GrSurfaceOrigin fOrigin;
int fWidth;
int fHeight;
GrPixelConfig fConfig;
GrFSAAType fFSAAType;
int fStencilCnt;
Textureable fIsTextureable;
MipMapped fIsMipMapped;
sk_sp<SkColorSpace> fColorSpace;
SkSurfaceProps fSurfaceProps;
};
#else// !SK_SUPPORT_GPU
class SkSurfaceCharacterization {
public:
SkSurfaceCharacterization()
: fWidth(0)
, fHeight(0)
, fSurfaceProps(0, kUnknown_SkPixelGeometry) {
}
bool isValid() const { return false; }
int width() const { return fWidth; }
int height() const { return fHeight; }
SkColorSpace* colorSpace() const { return fColorSpace.get(); }
sk_sp<SkColorSpace> refColorSpace() const { return fColorSpace; }
const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
private:
int fWidth;
int fHeight;
sk_sp<SkColorSpace> fColorSpace;
SkSurfaceProps fSurfaceProps;
};
#endif
#endif
|
