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
|
/*
* 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()
: fCacheMaxResourceCount(0)
, 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(); }
int cacheMaxResourceCount() const { return fCacheMaxResourceCount; }
size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; }
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'
void set(sk_sp<GrContextThreadSafeProxy> contextInfo,
int cacheMaxResourceCount,
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;
fCacheMaxResourceCount = cacheMaxResourceCount;
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;
int fCacheMaxResourceCount;
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) {
}
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
|
