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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Config.cpp: Implements the egl::Config class, describing the format, type
// and size for an egl::Surface. Implements EGLConfig and related functionality.
// [EGL 1.5] section 3.4 page 19.
#include "libANGLE/Config.h"
#include "libANGLE/AttributeMap.h"
#include <algorithm>
#include <vector>
#include "angle_gl.h"
#include <EGL/eglext.h>
#include "common/debug.h"
namespace egl
{
Config::Config()
: renderTargetFormat(GL_NONE),
depthStencilFormat(GL_NONE),
bufferSize(0),
redSize(0),
greenSize(0),
blueSize(0),
luminanceSize(0),
alphaSize(0),
alphaMaskSize(0),
bindToTextureRGB(EGL_FALSE),
bindToTextureRGBA(EGL_FALSE),
colorBufferType(EGL_NONE),
configCaveat(EGL_NONE),
configID(0),
conformant(0),
depthSize(0),
level(0),
matchNativePixmap(EGL_FALSE),
maxPBufferWidth(0),
maxPBufferHeight(0),
maxPBufferPixels(0),
maxSwapInterval(0),
minSwapInterval(0),
nativeRenderable(EGL_FALSE),
nativeVisualID(0),
nativeVisualType(0),
renderableType(0),
sampleBuffers(0),
samples(0),
stencilSize(0),
surfaceType(0),
transparentType(EGL_NONE),
transparentRedValue(0),
transparentGreenValue(0),
transparentBlueValue(0),
optimalOrientation(0)
{
}
EGLint ConfigSet::add(const Config &config)
{
// Set the config's ID to a small number that starts at 1 ([EGL 1.5] section 3.4)
EGLint id = static_cast<EGLint>(mConfigs.size()) + 1;
Config copyConfig(config);
copyConfig.configID = id;
mConfigs.insert(std::make_pair(id, copyConfig));
return id;
}
const Config &ConfigSet::get(EGLint id) const
{
ASSERT(mConfigs.find(id) != mConfigs.end());
return mConfigs.find(id)->second;
}
void ConfigSet::clear()
{
mConfigs.clear();
}
size_t ConfigSet::size() const
{
return mConfigs.size();
}
bool ConfigSet::contains(const Config *config) const
{
for (auto i = mConfigs.begin(); i != mConfigs.end(); i++)
{
const Config &item = i->second;
if (config == &item)
{
return true;
}
}
return false;
}
// Function object used by STL sorting routines for ordering Configs according to [EGL 1.5] section 3.4.1.2 page 28.
class ConfigSorter
{
public:
explicit ConfigSorter(const AttributeMap &attributeMap)
: mWantRed(false),
mWantGreen(false),
mWantBlue(false),
mWantAlpha(false),
mWantLuminance(false)
{
scanForWantedComponents(attributeMap);
}
bool operator()(const Config *x, const Config *y) const
{
return (*this)(*x, *y);
}
bool operator()(const Config &x, const Config &y) const
{
#define SORT(attribute) \
if (x.attribute != y.attribute) \
{ \
return x.attribute < y.attribute; \
}
static_assert(EGL_NONE < EGL_SLOW_CONFIG && EGL_SLOW_CONFIG < EGL_NON_CONFORMANT_CONFIG, "Unexpected EGL enum value.");
SORT(configCaveat);
static_assert(EGL_RGB_BUFFER < EGL_LUMINANCE_BUFFER, "Unexpected EGL enum value.");
SORT(colorBufferType);
// By larger total number of color bits, only considering those that are requested to be > 0.
EGLint xComponentsSize = wantedComponentsSize(x);
EGLint yComponentsSize = wantedComponentsSize(y);
if (xComponentsSize != yComponentsSize)
{
return xComponentsSize > yComponentsSize;
}
SORT(bufferSize);
SORT(sampleBuffers);
SORT(samples);
SORT(depthSize);
SORT(stencilSize);
SORT(alphaMaskSize);
SORT(nativeVisualType);
SORT(configID);
#undef SORT
return false;
}
private:
void scanForWantedComponents(const AttributeMap &attributeMap)
{
// [EGL 1.5] section 3.4.1.2 page 30
// Sorting rule #3: by larger total number of color bits, not considering
// components that are 0 or don't-care.
for (auto attribIter = attributeMap.begin(); attribIter != attributeMap.end(); attribIter++)
{
EGLAttrib attributeKey = attribIter->first;
EGLAttrib attributeValue = attribIter->second;
if (attributeKey != 0 && attributeValue != EGL_DONT_CARE)
{
switch (attributeKey)
{
case EGL_RED_SIZE: mWantRed = true; break;
case EGL_GREEN_SIZE: mWantGreen = true; break;
case EGL_BLUE_SIZE: mWantBlue = true; break;
case EGL_ALPHA_SIZE: mWantAlpha = true; break;
case EGL_LUMINANCE_SIZE: mWantLuminance = true; break;
}
}
}
}
EGLint wantedComponentsSize(const Config &config) const
{
EGLint total = 0;
if (mWantRed) total += config.redSize;
if (mWantGreen) total += config.greenSize;
if (mWantBlue) total += config.blueSize;
if (mWantAlpha) total += config.alphaSize;
if (mWantLuminance) total += config.luminanceSize;
return total;
}
bool mWantRed;
bool mWantGreen;
bool mWantBlue;
bool mWantAlpha;
bool mWantLuminance;
};
std::vector<const Config*> ConfigSet::filter(const AttributeMap &attributeMap) const
{
std::vector<const Config*> result;
result.reserve(mConfigs.size());
for (auto configIter = mConfigs.begin(); configIter != mConfigs.end(); configIter++)
{
const Config &config = configIter->second;
bool match = true;
for (auto attribIter = attributeMap.begin(); attribIter != attributeMap.end(); attribIter++)
{
EGLAttrib attributeKey = attribIter->first;
EGLAttrib attributeValue = attribIter->second;
switch (attributeKey)
{
case EGL_BUFFER_SIZE: match = config.bufferSize >= attributeValue; break;
case EGL_ALPHA_SIZE: match = config.alphaSize >= attributeValue; break;
case EGL_BLUE_SIZE: match = config.blueSize >= attributeValue; break;
case EGL_GREEN_SIZE: match = config.greenSize >= attributeValue; break;
case EGL_RED_SIZE: match = config.redSize >= attributeValue; break;
case EGL_DEPTH_SIZE: match = config.depthSize >= attributeValue; break;
case EGL_STENCIL_SIZE: match = config.stencilSize >= attributeValue; break;
case EGL_CONFIG_CAVEAT: match = config.configCaveat == (EGLenum)attributeValue; break;
case EGL_CONFIG_ID: match = config.configID == attributeValue; break;
case EGL_LEVEL: match = config.level >= attributeValue; break;
case EGL_NATIVE_RENDERABLE: match = config.nativeRenderable == (EGLBoolean)attributeValue; break;
case EGL_NATIVE_VISUAL_TYPE: match = config.nativeVisualType == attributeValue; break;
case EGL_SAMPLES: match = config.samples >= attributeValue; break;
case EGL_SAMPLE_BUFFERS: match = config.sampleBuffers >= attributeValue; break;
case EGL_SURFACE_TYPE: match = (config.surfaceType & attributeValue) == attributeValue; break;
case EGL_TRANSPARENT_TYPE: match = config.transparentType == (EGLenum)attributeValue; break;
case EGL_TRANSPARENT_BLUE_VALUE: match = config.transparentBlueValue == attributeValue; break;
case EGL_TRANSPARENT_GREEN_VALUE: match = config.transparentGreenValue == attributeValue; break;
case EGL_TRANSPARENT_RED_VALUE: match = config.transparentRedValue == attributeValue; break;
case EGL_BIND_TO_TEXTURE_RGB: match = config.bindToTextureRGB == (EGLBoolean)attributeValue; break;
case EGL_BIND_TO_TEXTURE_RGBA: match = config.bindToTextureRGBA == (EGLBoolean)attributeValue; break;
case EGL_MIN_SWAP_INTERVAL: match = config.minSwapInterval == attributeValue; break;
case EGL_MAX_SWAP_INTERVAL: match = config.maxSwapInterval == attributeValue; break;
case EGL_LUMINANCE_SIZE: match = config.luminanceSize >= attributeValue; break;
case EGL_ALPHA_MASK_SIZE: match = config.alphaMaskSize >= attributeValue; break;
case EGL_COLOR_BUFFER_TYPE: match = config.colorBufferType == (EGLenum)attributeValue; break;
case EGL_RENDERABLE_TYPE: match = (config.renderableType & attributeValue) == attributeValue; break;
case EGL_MATCH_NATIVE_PIXMAP: match = false; UNIMPLEMENTED(); break;
case EGL_CONFORMANT: match = (config.conformant & attributeValue) == attributeValue; break;
case EGL_MAX_PBUFFER_WIDTH: match = config.maxPBufferWidth >= attributeValue; break;
case EGL_MAX_PBUFFER_HEIGHT: match = config.maxPBufferHeight >= attributeValue; break;
case EGL_MAX_PBUFFER_PIXELS: match = config.maxPBufferPixels >= attributeValue; break;
case EGL_OPTIMAL_SURFACE_ORIENTATION_ANGLE:
match = config.optimalOrientation == attributeValue;
break;
default: UNREACHABLE();
}
if (!match)
{
break;
}
}
if (match)
{
result.push_back(&config);
}
}
// Sort the result
std::sort(result.begin(), result.end(), ConfigSorter(attributeMap));
return result;
}
}
|
