blob: 5f8cd77ad6d0c3b3acbc385fd23374d4fb04c982 (
plain)
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
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
|
#include <mbgl/gl/enum.hpp>
#include <mbgl/gfx/types.hpp>
#include <mbgl/gl/defines.hpp>
namespace mbgl {
namespace gl {
template <>
platform::GLenum Enum<gfx::DrawModeType>::to(const gfx::DrawModeType value) {
switch (value) {
case gfx::DrawModeType::Points: return GL_POINTS;
case gfx::DrawModeType::Lines: return GL_LINES;
case gfx::DrawModeType::LineLoop: return GL_LINE_LOOP;
case gfx::DrawModeType::LineStrip: return GL_LINE_STRIP;
case gfx::DrawModeType::Triangles: return GL_TRIANGLES;
case gfx::DrawModeType::TriangleStrip: return GL_TRIANGLE_STRIP;
case gfx::DrawModeType::TriangleFan: return GL_TRIANGLE_FAN;
}
return GL_INVALID_ENUM;
}
template <>
gfx::ColorBlendEquationType Enum<gfx::ColorBlendEquationType>::from(const platform::GLint value) {
switch (value) {
case GL_FUNC_ADD: return gfx::ColorBlendEquationType::Add;
case GL_FUNC_SUBTRACT: return gfx::ColorBlendEquationType::Subtract;
case GL_FUNC_REVERSE_SUBTRACT: return gfx::ColorBlendEquationType::ReverseSubtract;
}
return {};
}
template <>
platform::GLenum Enum<gfx::ColorBlendEquationType>::to(const gfx::ColorBlendEquationType value) {
switch (value) {
case gfx::ColorBlendEquationType::Add: return GL_FUNC_ADD;
case gfx::ColorBlendEquationType::Subtract: return GL_FUNC_SUBTRACT;
case gfx::ColorBlendEquationType::ReverseSubtract: return GL_FUNC_REVERSE_SUBTRACT;
}
return GL_INVALID_ENUM;
}
template <>
gfx::ColorBlendFactorType Enum<gfx::ColorBlendFactorType>::from(const platform::GLint value) {
switch (value) {
case GL_ZERO: return gfx::ColorBlendFactorType::Zero;
case GL_ONE: return gfx::ColorBlendFactorType::One;
case GL_SRC_COLOR: return gfx::ColorBlendFactorType::SrcColor;
case GL_ONE_MINUS_SRC_COLOR: return gfx::ColorBlendFactorType::OneMinusSrcColor;
case GL_DST_COLOR: return gfx::ColorBlendFactorType::DstColor;
case GL_ONE_MINUS_DST_COLOR: return gfx::ColorBlendFactorType::OneMinusDstColor;
case GL_SRC_ALPHA: return gfx::ColorBlendFactorType::SrcAlpha;
case GL_ONE_MINUS_SRC_ALPHA: return gfx::ColorBlendFactorType::OneMinusSrcAlpha;
case GL_DST_ALPHA: return gfx::ColorBlendFactorType::DstAlpha;
case GL_ONE_MINUS_DST_ALPHA: return gfx::ColorBlendFactorType::OneMinusDstAlpha;
case GL_CONSTANT_COLOR: return gfx::ColorBlendFactorType::ConstantColor;
case GL_ONE_MINUS_CONSTANT_COLOR: return gfx::ColorBlendFactorType::OneMinusConstantColor;
case GL_CONSTANT_ALPHA: return gfx::ColorBlendFactorType::ConstantAlpha;
case GL_ONE_MINUS_CONSTANT_ALPHA: return gfx::ColorBlendFactorType::OneMinusConstantAlpha;
case GL_SRC_ALPHA_SATURATE: return gfx::ColorBlendFactorType::SrcAlphaSaturate;
}
return {};
}
template <>
platform::GLenum Enum<gfx::ColorBlendFactorType>::to(const gfx::ColorBlendFactorType value) {
switch (value) {
case gfx::ColorBlendFactorType::Zero: return GL_ZERO;
case gfx::ColorBlendFactorType::One: return GL_ONE;
case gfx::ColorBlendFactorType::SrcColor: return GL_SRC_COLOR;
case gfx::ColorBlendFactorType::OneMinusSrcColor: return GL_ONE_MINUS_SRC_COLOR;
case gfx::ColorBlendFactorType::DstColor: return GL_DST_COLOR;
case gfx::ColorBlendFactorType::OneMinusDstColor: return GL_ONE_MINUS_DST_COLOR;
case gfx::ColorBlendFactorType::SrcAlpha: return GL_SRC_ALPHA;
case gfx::ColorBlendFactorType::OneMinusSrcAlpha: return GL_ONE_MINUS_SRC_ALPHA;
case gfx::ColorBlendFactorType::DstAlpha: return GL_DST_ALPHA;
case gfx::ColorBlendFactorType::OneMinusDstAlpha: return GL_ONE_MINUS_DST_ALPHA;
case gfx::ColorBlendFactorType::ConstantColor: return GL_CONSTANT_COLOR;
case gfx::ColorBlendFactorType::OneMinusConstantColor: return GL_ONE_MINUS_CONSTANT_COLOR;
case gfx::ColorBlendFactorType::ConstantAlpha: return GL_CONSTANT_ALPHA;
case gfx::ColorBlendFactorType::OneMinusConstantAlpha: return GL_ONE_MINUS_CONSTANT_ALPHA;
case gfx::ColorBlendFactorType::SrcAlphaSaturate: return GL_SRC_ALPHA_SATURATE;
}
return GL_INVALID_ENUM;
}
template <>
gfx::DepthFunctionType Enum<gfx::DepthFunctionType>::from(const platform::GLint value) {
switch (value) {
case GL_NEVER: return gfx::DepthFunctionType::Never;
case GL_LESS: return gfx::DepthFunctionType::Less;
case GL_EQUAL: return gfx::DepthFunctionType::Equal;
case GL_LEQUAL: return gfx::DepthFunctionType::LessEqual;
case GL_GREATER: return gfx::DepthFunctionType::Greater;
case GL_NOTEQUAL: return gfx::DepthFunctionType::NotEqual;
case GL_GEQUAL: return gfx::DepthFunctionType::GreaterEqual;
case GL_ALWAYS: return gfx::DepthFunctionType::Always;
}
return {};
}
template <>
platform::GLenum Enum<gfx::DepthFunctionType>::to(const gfx::DepthFunctionType value) {
switch (value) {
case gfx::DepthFunctionType::Never: return GL_NEVER;
case gfx::DepthFunctionType::Less: return GL_LESS;
case gfx::DepthFunctionType::Equal: return GL_EQUAL;
case gfx::DepthFunctionType::LessEqual: return GL_LEQUAL;
case gfx::DepthFunctionType::Greater: return GL_GREATER;
case gfx::DepthFunctionType::NotEqual: return GL_NOTEQUAL;
case gfx::DepthFunctionType::GreaterEqual: return GL_GEQUAL;
case gfx::DepthFunctionType::Always: return GL_ALWAYS;
}
return GL_INVALID_ENUM;
}
template <>
gfx::DepthMaskType Enum<gfx::DepthMaskType>::from(const platform::GLboolean value) {
return value ? gfx::DepthMaskType::ReadWrite : gfx::DepthMaskType::ReadOnly;
}
template <>
platform::GLboolean Enum<gfx::DepthMaskType>::to(const gfx::DepthMaskType value) {
return value == gfx::DepthMaskType::ReadWrite ? GL_TRUE : GL_FALSE;
}
template <>
gfx::StencilFunctionType Enum<gfx::StencilFunctionType>::from(const platform::GLint value) {
switch (value) {
case GL_NEVER: return gfx::StencilFunctionType::Never;
case GL_LESS: return gfx::StencilFunctionType::Less;
case GL_EQUAL: return gfx::StencilFunctionType::Equal;
case GL_LEQUAL: return gfx::StencilFunctionType::LessEqual;
case GL_GREATER: return gfx::StencilFunctionType::Greater;
case GL_NOTEQUAL: return gfx::StencilFunctionType::NotEqual;
case GL_GEQUAL: return gfx::StencilFunctionType::GreaterEqual;
case GL_ALWAYS: return gfx::StencilFunctionType::Always;
}
return {};
}
template <>
platform::GLenum Enum<gfx::StencilFunctionType>::to(const gfx::StencilFunctionType value) {
switch (value) {
case gfx::StencilFunctionType::Never: return GL_NEVER;
case gfx::StencilFunctionType::Less: return GL_LESS;
case gfx::StencilFunctionType::Equal: return GL_EQUAL;
case gfx::StencilFunctionType::LessEqual: return GL_LEQUAL;
case gfx::StencilFunctionType::Greater: return GL_GREATER;
case gfx::StencilFunctionType::NotEqual: return GL_NOTEQUAL;
case gfx::StencilFunctionType::GreaterEqual: return GL_GEQUAL;
case gfx::StencilFunctionType::Always: return GL_ALWAYS;
}
return GL_INVALID_ENUM;
}
template <>
gfx::StencilOpType Enum<gfx::StencilOpType>::from(const platform::GLint value) {
switch (value) {
case GL_KEEP: return gfx::StencilOpType::Keep;
case GL_ZERO: return gfx::StencilOpType::Zero;
case GL_REPLACE: return gfx::StencilOpType::Replace;
case GL_INCR: return gfx::StencilOpType::Increment;
case GL_INCR_WRAP: return gfx::StencilOpType::IncrementWrap;
case GL_DECR: return gfx::StencilOpType::Decrement;
case GL_DECR_WRAP: return gfx::StencilOpType::DecrementWrap;
case GL_INVERT: return gfx::StencilOpType::Invert;
}
return {};
}
template <>
platform::GLenum Enum<gfx::StencilOpType>::to(const gfx::StencilOpType value) {
switch (value) {
case gfx::StencilOpType::Keep: return GL_KEEP;
case gfx::StencilOpType::Zero: return GL_ZERO;
case gfx::StencilOpType::Replace: return GL_REPLACE;
case gfx::StencilOpType::Increment: return GL_INCR;
case gfx::StencilOpType::IncrementWrap: return GL_INCR_WRAP;
case gfx::StencilOpType::Decrement: return GL_DECR;
case gfx::StencilOpType::DecrementWrap: return GL_DECR_WRAP;
case gfx::StencilOpType::Invert: return GL_INVERT;
}
return GL_INVALID_ENUM;
}
template <>
gfx::CullFaceSideType Enum<gfx::CullFaceSideType>::from(const platform::GLint value) {
switch (value) {
case GL_FRONT: return gfx::CullFaceSideType::Front;
case GL_BACK: return gfx::CullFaceSideType::Back;
case GL_FRONT_AND_BACK: return gfx::CullFaceSideType::FrontAndBack;
}
return {};
}
template <>
platform::GLenum Enum<gfx::CullFaceSideType>::to(const gfx::CullFaceSideType value) {
switch (value) {
case gfx::CullFaceSideType::Front: return GL_FRONT;
case gfx::CullFaceSideType::Back: return GL_BACK;
case gfx::CullFaceSideType::FrontAndBack: return GL_FRONT_AND_BACK;
}
return GL_INVALID_ENUM;
}
template <>
gfx::CullFaceWindingType Enum<gfx::CullFaceWindingType>::from(const platform::GLint value) {
switch (value) {
case GL_CW: return gfx::CullFaceWindingType::Clockwise;
case GL_CCW: return gfx::CullFaceWindingType::CounterClockwise;
}
return {};
}
template <>
platform::GLenum Enum<gfx::CullFaceWindingType>::to(const gfx::CullFaceWindingType value) {
switch (value) {
case gfx::CullFaceWindingType::Clockwise: return GL_CW;
case gfx::CullFaceWindingType::CounterClockwise: return GL_CCW;
}
return GL_INVALID_ENUM;
}
template <>
gfx::BufferUsageType Enum<gfx::BufferUsageType>::from(const platform::GLint value) {
switch (value) {
case GL_STREAM_DRAW: return gfx::BufferUsageType::StreamDraw;
case GL_STATIC_DRAW: return gfx::BufferUsageType::StaticDraw;
case GL_DYNAMIC_DRAW: return gfx::BufferUsageType::DynamicDraw;
}
return {};
}
template <>
platform::GLenum Enum<gfx::BufferUsageType>::to(const gfx::BufferUsageType value) {
switch (value) {
case gfx::BufferUsageType::StreamDraw: return GL_STREAM_DRAW;
case gfx::BufferUsageType::StaticDraw: return GL_STATIC_DRAW;
case gfx::BufferUsageType::DynamicDraw: return GL_DYNAMIC_DRAW;
}
return GL_INVALID_ENUM;
}
template <>
gfx::TexturePixelType Enum<gfx::TexturePixelType>::from(const platform::GLint value) {
switch (value) {
case GL_RGBA: return gfx::TexturePixelType::RGBA;
case GL_ALPHA: return gfx::TexturePixelType::Alpha;
case GL_STENCIL_INDEX: return gfx::TexturePixelType::Stencil;
case GL_DEPTH_COMPONENT: return gfx::TexturePixelType::Depth;
case GL_LUMINANCE: return gfx::TexturePixelType::Luminance;
}
return {};
}
template <>
platform::GLenum Enum<gfx::TexturePixelType>::to(const gfx::TexturePixelType value) {
switch (value) {
case gfx::TexturePixelType::RGBA: return GL_RGBA;
case gfx::TexturePixelType::Alpha: return GL_ALPHA;
case gfx::TexturePixelType::Stencil: return GL_STENCIL_INDEX;
case gfx::TexturePixelType::Depth: return GL_DEPTH_COMPONENT;
case gfx::TexturePixelType::Luminance: return GL_LUMINANCE;
}
return GL_INVALID_ENUM;
}
template <>
gfx::TextureChannelDataType Enum<gfx::TextureChannelDataType>::from(const platform::GLint value) {
switch (value) {
case GL_UNSIGNED_BYTE: return gfx::TextureChannelDataType::UnsignedByte;
case GL_HALF_FLOAT: return gfx::TextureChannelDataType::HalfFloat;
}
return {};
}
template <>
platform::GLenum Enum<gfx::TextureChannelDataType>::to(const gfx::TextureChannelDataType value) {
switch (value) {
case gfx::TextureChannelDataType::UnsignedByte: return GL_UNSIGNED_BYTE;
case gfx::TextureChannelDataType::HalfFloat: return GL_HALF_FLOAT;
}
return GL_INVALID_ENUM;
}
template <>
gfx::RenderbufferPixelType Enum<gfx::RenderbufferPixelType>::from(const platform::GLint value) {
switch (value) {
#if not MBGL_USE_GLES2
case GL_RGBA8: return gfx::RenderbufferPixelType::RGBA;
case GL_DEPTH_COMPONENT: return gfx::RenderbufferPixelType::Depth;
case GL_DEPTH24_STENCIL8: return gfx::RenderbufferPixelType::DepthStencil;
#else
case GL_RGBA8_OES: return gfx::RenderbufferPixelType::RGBA;
case GL_DEPTH_COMPONENT16: return gfx::RenderbufferPixelType::Depth;
case GL_DEPTH24_STENCIL8_OES: return gfx::RenderbufferPixelType::DepthStencil;
#endif
}
return {};
}
template <>
platform::GLenum Enum<gfx::RenderbufferPixelType>::to(const gfx::RenderbufferPixelType value) {
switch (value) {
#if not MBGL_USE_GLES2
case gfx::RenderbufferPixelType::RGBA: return GL_RGBA8;
case gfx::RenderbufferPixelType::Depth: return GL_DEPTH_COMPONENT;
case gfx::RenderbufferPixelType::DepthStencil: return GL_DEPTH24_STENCIL8;
#else
case gfx::RenderbufferPixelType::RGBA: return GL_RGBA8_OES;
case gfx::RenderbufferPixelType::Depth: return GL_DEPTH_COMPONENT16;
case gfx::RenderbufferPixelType::DepthStencil: return GL_DEPTH24_STENCIL8_OES;
#endif
}
return GL_INVALID_ENUM;
}
} // namespace gl
} // namespace mbgl
|
