← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily

« back to all changes in this revision

Viewing changes to COLLADASaxFrameworkLoader/src/generated14/COLLADASaxFWLColladaParserAutoGen14PrivateEnums.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
COLLADASaxFrameworkLoader/src/generated14/COLLADASaxFWLColladaParserAutoGen14PrivateEnums.cpp
 
1
/*
 
2
    Copyright (c) 2008-2013 NetAllied Systems GmbH
 
3
 
 
4
    This file is part of COLLADASaxFrameworkLoader.
 
5
 
 
6
    Licensed under the MIT Open Source License,
 
7
    for details please see LICENSE file or the website
 
8
    http://www.opensource.org/licenses/mit-license.php
 
9
*/
 
10
 
 
11
#include "COLLADASaxFWLStableHeaders.h"
 
12
#include "COLLADASaxFWLColladaParserAutoGen14Enums.h"
 
13
#include "GeneratedSaxParserUtils.h"
 
14
 
 
15
 
 
16
namespace COLLADASaxFWL14
 
17
{
 
18
 
 
19
 
 
20
//---------------------------------------------------------------------
 
21
const std::pair<StringHash, ENUM__VersionType> ENUM__VersionTypeMap[ENUM__VersionType__COUNT] = 
 
22
{
 
23
    std::pair<StringHash, ENUM__VersionType>(3413776, ENUM__VersionType__1_4_0),
 
24
    std::pair<StringHash, ENUM__VersionType>(3413777, ENUM__VersionType__1_4_1)
 
25
};
 
26
 
 
27
//---------------------------------------------------------------------
 
28
ENUM__VersionType toEnum_ENUM__VersionType (
 
29
    const ParserChar** buffer,
 
30
    const ParserChar* bufferEnd,
 
31
    bool& failed,
 
32
    const std::pair<StringHash, ENUM__VersionType>* enumMap,
 
33
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
34
)
 
35
{
 
36
    return Utils::toEnum<ENUM__VersionType, StringHash, ENUM__VersionType__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
37
}
 
38
 
 
39
 
 
40
//---------------------------------------------------------------------
 
41
const std::pair<StringHash, ENUM__UpAxisType> ENUM__UpAxisTypeMap[ENUM__UpAxisType__COUNT] = 
 
42
{
 
43
    std::pair<StringHash, ENUM__UpAxisType>(386208, ENUM__UpAxisType__X_UP),
 
44
    std::pair<StringHash, ENUM__UpAxisType>(390304, ENUM__UpAxisType__Y_UP),
 
45
    std::pair<StringHash, ENUM__UpAxisType>(394400, ENUM__UpAxisType__Z_UP)
 
46
};
 
47
 
 
48
//---------------------------------------------------------------------
 
49
ENUM__UpAxisType toEnum_ENUM__UpAxisType (
 
50
    const ParserChar** buffer,
 
51
    const ParserChar* bufferEnd,
 
52
    bool& failed,
 
53
    const std::pair<StringHash, ENUM__UpAxisType>* enumMap,
 
54
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
55
)
 
56
{
 
57
    return Utils::toEnum<ENUM__UpAxisType, StringHash, ENUM__UpAxisType__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
58
}
 
59
 
 
60
 
 
61
//---------------------------------------------------------------------
 
62
const std::pair<StringHash, ENUM__MorphMethodType> ENUM__MorphMethodTypeMap[ENUM__MorphMethodType__COUNT] = 
 
63
{
 
64
    std::pair<StringHash, ENUM__MorphMethodType>(23452388, ENUM__MorphMethodType__NORMALIZED),
 
65
    std::pair<StringHash, ENUM__MorphMethodType>(168201157, ENUM__MorphMethodType__RELATIVE)
 
66
};
 
67
 
 
68
//---------------------------------------------------------------------
 
69
ENUM__MorphMethodType toEnum_ENUM__MorphMethodType (
 
70
    const ParserChar** buffer,
 
71
    const ParserChar* bufferEnd,
 
72
    bool& failed,
 
73
    const std::pair<StringHash, ENUM__MorphMethodType>* enumMap,
 
74
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
75
)
 
76
{
 
77
    return Utils::toEnum<ENUM__MorphMethodType, StringHash, ENUM__MorphMethodType__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
78
}
 
79
 
 
80
 
 
81
//---------------------------------------------------------------------
 
82
const std::pair<StringHash, ENUM__fx_modifier_enum_common> ENUM__fx_modifier_enum_commonMap[ENUM__fx_modifier_enum_common__COUNT] = 
 
83
{
 
84
    std::pair<StringHash, ENUM__fx_modifier_enum_common>(4735876, ENUM__fx_modifier_enum_common__CONST),
 
85
    std::pair<StringHash, ENUM__fx_modifier_enum_common>(78482030, ENUM__fx_modifier_enum_common__EXTERN),
 
86
    std::pair<StringHash, ENUM__fx_modifier_enum_common>(92038804, ENUM__fx_modifier_enum_common__SHARED),
 
87
    std::pair<StringHash, ENUM__fx_modifier_enum_common>(92825811, ENUM__fx_modifier_enum_common__STATIC),
 
88
    std::pair<StringHash, ENUM__fx_modifier_enum_common>(170767421, ENUM__fx_modifier_enum_common__UNIFORM),
 
89
    std::pair<StringHash, ENUM__fx_modifier_enum_common>(174579319, ENUM__fx_modifier_enum_common__VARYING),
 
90
    std::pair<StringHash, ENUM__fx_modifier_enum_common>(67537333, ENUM__fx_modifier_enum_common__VOLATILE)
 
91
};
 
92
 
 
93
//---------------------------------------------------------------------
 
94
ENUM__fx_modifier_enum_common toEnum_ENUM__fx_modifier_enum_common (
 
95
    const ParserChar** buffer,
 
96
    const ParserChar* bufferEnd,
 
97
    bool& failed,
 
98
    const std::pair<StringHash, ENUM__fx_modifier_enum_common>* enumMap,
 
99
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
100
)
 
101
{
 
102
    return Utils::toEnum<ENUM__fx_modifier_enum_common, StringHash, ENUM__fx_modifier_enum_common__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
103
}
 
104
 
 
105
 
 
106
//---------------------------------------------------------------------
 
107
const std::pair<StringHash, ENUM__fx_surface_type_enum> ENUM__fx_surface_type_enumMap[ENUM__fx_surface_type_enum__COUNT] = 
 
108
{
 
109
    std::pair<StringHash, ENUM__fx_surface_type_enum>(852, ENUM__fx_surface_type_enum__1D),
 
110
    std::pair<StringHash, ENUM__fx_surface_type_enum>(868, ENUM__fx_surface_type_enum__2D),
 
111
    std::pair<StringHash, ENUM__fx_surface_type_enum>(884, ENUM__fx_surface_type_enum__3D),
 
112
    std::pair<StringHash, ENUM__fx_surface_type_enum>(297317, ENUM__fx_surface_type_enum__CUBE),
 
113
    std::pair<StringHash, ENUM__fx_surface_type_enum>(4760968, ENUM__fx_surface_type_enum__DEPTH),
 
114
    std::pair<StringHash, ENUM__fx_surface_type_enum>(354692, ENUM__fx_surface_type_enum__RECT),
 
115
    std::pair<StringHash, ENUM__fx_surface_type_enum>(171566276, ENUM__fx_surface_type_enum__UNTYPED)
 
116
};
 
117
 
 
118
//---------------------------------------------------------------------
 
119
ENUM__fx_surface_type_enum toEnum_ENUM__fx_surface_type_enum (
 
120
    const ParserChar** buffer,
 
121
    const ParserChar* bufferEnd,
 
122
    bool& failed,
 
123
    const std::pair<StringHash, ENUM__fx_surface_type_enum>* enumMap,
 
124
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
125
)
 
126
{
 
127
    return Utils::toEnum<ENUM__fx_surface_type_enum, StringHash, ENUM__fx_surface_type_enum__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
128
}
 
129
 
 
130
 
 
131
//---------------------------------------------------------------------
 
132
const std::pair<StringHash, ENUM__fx_surface_face_enum> ENUM__fx_surface_face_enumMap[ENUM__fx_surface_face_enum__COUNT] = 
 
133
{
 
134
    std::pair<StringHash, ENUM__fx_surface_face_enum>(109806840, ENUM__fx_surface_face_enum__NEGATIVE_X),
 
135
    std::pair<StringHash, ENUM__fx_surface_face_enum>(109806841, ENUM__fx_surface_face_enum__NEGATIVE_Y),
 
136
    std::pair<StringHash, ENUM__fx_surface_face_enum>(109806842, ENUM__fx_surface_face_enum__NEGATIVE_Z),
 
137
    std::pair<StringHash, ENUM__fx_surface_face_enum>(244055864, ENUM__fx_surface_face_enum__POSITIVE_X),
 
138
    std::pair<StringHash, ENUM__fx_surface_face_enum>(244055865, ENUM__fx_surface_face_enum__POSITIVE_Y),
 
139
    std::pair<StringHash, ENUM__fx_surface_face_enum>(244055866, ENUM__fx_surface_face_enum__POSITIVE_Z)
 
140
};
 
141
 
 
142
//---------------------------------------------------------------------
 
143
ENUM__fx_surface_face_enum toEnum_ENUM__fx_surface_face_enum (
 
144
    const ParserChar** buffer,
 
145
    const ParserChar* bufferEnd,
 
146
    bool& failed,
 
147
    const std::pair<StringHash, ENUM__fx_surface_face_enum>* enumMap,
 
148
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
149
)
 
150
{
 
151
    return Utils::toEnum<ENUM__fx_surface_face_enum, StringHash, ENUM__fx_surface_face_enum__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
152
}
 
153
 
 
154
 
 
155
//---------------------------------------------------------------------
 
156
const std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum> ENUM__fx_surface_format_hint_channels_enumMap[ENUM__fx_surface_format_hint_channels_enum__COUNT] = 
 
157
{
 
158
    std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum>(68, ENUM__fx_surface_format_hint_channels_enum__D),
 
159
    std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum>(76, ENUM__fx_surface_format_hint_channels_enum__L),
 
160
    std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum>(1281, ENUM__fx_surface_format_hint_channels_enum__LA),
 
161
    std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum>(22194, ENUM__fx_surface_format_hint_channels_enum__RGB),
 
162
    std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum>(355169, ENUM__fx_surface_format_hint_channels_enum__RGBA),
 
163
    std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum>(24042, ENUM__fx_surface_format_hint_channels_enum__XYZ),
 
164
    std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum>(384759, ENUM__fx_surface_format_hint_channels_enum__XYZW)
 
165
};
 
166
 
 
167
//---------------------------------------------------------------------
 
168
ENUM__fx_surface_format_hint_channels_enum toEnum_ENUM__fx_surface_format_hint_channels_enum (
 
169
    const ParserChar** buffer,
 
170
    const ParserChar* bufferEnd,
 
171
    bool& failed,
 
172
    const std::pair<StringHash, ENUM__fx_surface_format_hint_channels_enum>* enumMap,
 
173
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
174
)
 
175
{
 
176
    return Utils::toEnum<ENUM__fx_surface_format_hint_channels_enum, StringHash, ENUM__fx_surface_format_hint_channels_enum__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
177
}
 
178
 
 
179
 
 
180
//---------------------------------------------------------------------
 
181
const std::pair<StringHash, ENUM__fx_surface_format_hint_range_enum> ENUM__fx_surface_format_hint_range_enumMap[ENUM__fx_surface_format_hint_range_enum__COUNT] = 
 
182
{
 
183
    std::pair<StringHash, ENUM__fx_surface_format_hint_range_enum>(4920164, ENUM__fx_surface_format_hint_range_enum__FLOAT),
 
184
    std::pair<StringHash, ENUM__fx_surface_format_hint_range_enum>(359988, ENUM__fx_surface_format_hint_range_enum__SINT),
 
185
    std::pair<StringHash, ENUM__fx_surface_format_hint_range_enum>(5780589, ENUM__fx_surface_format_hint_range_enum__SNORM),
 
186
    std::pair<StringHash, ENUM__fx_surface_format_hint_range_enum>(368180, ENUM__fx_surface_format_hint_range_enum__UINT),
 
187
    std::pair<StringHash, ENUM__fx_surface_format_hint_range_enum>(5911661, ENUM__fx_surface_format_hint_range_enum__UNORM)
 
188
};
 
189
 
 
190
//---------------------------------------------------------------------
 
191
ENUM__fx_surface_format_hint_range_enum toEnum_ENUM__fx_surface_format_hint_range_enum (
 
192
    const ParserChar** buffer,
 
193
    const ParserChar* bufferEnd,
 
194
    bool& failed,
 
195
    const std::pair<StringHash, ENUM__fx_surface_format_hint_range_enum>* enumMap,
 
196
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
197
)
 
198
{
 
199
    return Utils::toEnum<ENUM__fx_surface_format_hint_range_enum, StringHash, ENUM__fx_surface_format_hint_range_enum__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
200
}
 
201
 
 
202
 
 
203
//---------------------------------------------------------------------
 
204
const std::pair<StringHash, ENUM__fx_surface_format_hint_precision_enum> ENUM__fx_surface_format_hint_precision_enumMap[ENUM__fx_surface_format_hint_precision_enum__COUNT] = 
 
205
{
 
206
    std::pair<StringHash, ENUM__fx_surface_format_hint_precision_enum>(314808, ENUM__fx_surface_format_hint_precision_enum__HIGH),
 
207
    std::pair<StringHash, ENUM__fx_surface_format_hint_precision_enum>(20807, ENUM__fx_surface_format_hint_precision_enum__LOW),
 
208
    std::pair<StringHash, ENUM__fx_surface_format_hint_precision_enum>(20948, ENUM__fx_surface_format_hint_precision_enum__MID)
 
209
};
 
210
 
 
211
//---------------------------------------------------------------------
 
212
ENUM__fx_surface_format_hint_precision_enum toEnum_ENUM__fx_surface_format_hint_precision_enum (
 
213
    const ParserChar** buffer,
 
214
    const ParserChar* bufferEnd,
 
215
    bool& failed,
 
216
    const std::pair<StringHash, ENUM__fx_surface_format_hint_precision_enum>* enumMap,
 
217
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
218
)
 
219
{
 
220
    return Utils::toEnum<ENUM__fx_surface_format_hint_precision_enum, StringHash, ENUM__fx_surface_format_hint_precision_enum__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
221
}
 
222
 
 
223
 
 
224
//---------------------------------------------------------------------
 
225
const std::pair<StringHash, ENUM__fx_surface_format_hint_option_enum> ENUM__fx_surface_format_hint_option_enumMap[ENUM__fx_surface_format_hint_option_enum__COUNT] = 
 
226
{
 
227
    std::pair<StringHash, ENUM__fx_surface_format_hint_option_enum>(235107429, ENUM__fx_surface_format_hint_option_enum__COMPRESSABLE),
 
228
    std::pair<StringHash, ENUM__fx_surface_format_hint_option_enum>(106802787, ENUM__fx_surface_format_hint_option_enum__NORMALIZED3),
 
229
    std::pair<StringHash, ENUM__fx_surface_format_hint_option_enum>(106802788, ENUM__fx_surface_format_hint_option_enum__NORMALIZED4),
 
230
    std::pair<StringHash, ENUM__fx_surface_format_hint_option_enum>(138340513, ENUM__fx_surface_format_hint_option_enum__SRGB_GAMMA)
 
231
};
 
232
 
 
233
//---------------------------------------------------------------------
 
234
ENUM__fx_surface_format_hint_option_enum toEnum_ENUM__fx_surface_format_hint_option_enum (
 
235
    const ParserChar** buffer,
 
236
    const ParserChar* bufferEnd,
 
237
    bool& failed,
 
238
    const std::pair<StringHash, ENUM__fx_surface_format_hint_option_enum>* enumMap,
 
239
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
240
)
 
241
{
 
242
    return Utils::toEnum<ENUM__fx_surface_format_hint_option_enum, StringHash, ENUM__fx_surface_format_hint_option_enum__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
243
}
 
244
 
 
245
 
 
246
//---------------------------------------------------------------------
 
247
const std::pair<StringHash, ENUM__fx_sampler_wrap_common> ENUM__fx_sampler_wrap_commonMap[ENUM__fx_sampler_wrap_common__COUNT] = 
 
248
{
 
249
    std::pair<StringHash, ENUM__fx_sampler_wrap_common>(74737826, ENUM__fx_sampler_wrap_common__BORDER),
 
250
    std::pair<StringHash, ENUM__fx_sampler_wrap_common>(4720160, ENUM__fx_sampler_wrap_common__CLAMP),
 
251
    std::pair<StringHash, ENUM__fx_sampler_wrap_common>(85882690, ENUM__fx_sampler_wrap_common__MIRROR),
 
252
    std::pair<StringHash, ENUM__fx_sampler_wrap_common>(341029, ENUM__fx_sampler_wrap_common__NONE),
 
253
    std::pair<StringHash, ENUM__fx_sampler_wrap_common>(378464, ENUM__fx_sampler_wrap_common__WRAP)
 
254
};
 
255
 
 
256
//---------------------------------------------------------------------
 
257
ENUM__fx_sampler_wrap_common toEnum_ENUM__fx_sampler_wrap_common (
 
258
    const ParserChar** buffer,
 
259
    const ParserChar* bufferEnd,
 
260
    bool& failed,
 
261
    const std::pair<StringHash, ENUM__fx_sampler_wrap_common>* enumMap,
 
262
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
263
)
 
264
{
 
265
    return Utils::toEnum<ENUM__fx_sampler_wrap_common, StringHash, ENUM__fx_sampler_wrap_common__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
266
}
 
267
 
 
268
 
 
269
//---------------------------------------------------------------------
 
270
const std::pair<StringHash, ENUM__fx_sampler_filter_common> ENUM__fx_sampler_filter_commonMap[ENUM__fx_sampler_filter_common__COUNT] = 
 
271
{
 
272
    std::pair<StringHash, ENUM__fx_sampler_filter_common>(84814178, ENUM__fx_sampler_filter_common__LINEAR),
 
273
    std::pair<StringHash, ENUM__fx_sampler_filter_common>(230972482, ENUM__fx_sampler_filter_common__LINEAR_MIPMAP_LINEAR),
 
274
    std::pair<StringHash, ENUM__fx_sampler_filter_common>(242301012, ENUM__fx_sampler_filter_common__LINEAR_MIPMAP_NEAREST),
 
275
    std::pair<StringHash, ENUM__fx_sampler_filter_common>(43412180, ENUM__fx_sampler_filter_common__NEAREST),
 
276
    std::pair<StringHash, ENUM__fx_sampler_filter_common>(92529554, ENUM__fx_sampler_filter_common__NEAREST_MIPMAP_LINEAR),
 
277
    std::pair<StringHash, ENUM__fx_sampler_filter_common>(174769620, ENUM__fx_sampler_filter_common__NEAREST_MIPMAP_NEAREST),
 
278
    std::pair<StringHash, ENUM__fx_sampler_filter_common>(341029, ENUM__fx_sampler_filter_common__NONE)
 
279
};
 
280
 
 
281
//---------------------------------------------------------------------
 
282
ENUM__fx_sampler_filter_common toEnum_ENUM__fx_sampler_filter_common (
 
283
    const ParserChar** buffer,
 
284
    const ParserChar* bufferEnd,
 
285
    bool& failed,
 
286
    const std::pair<StringHash, ENUM__fx_sampler_filter_common>* enumMap,
 
287
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
288
)
 
289
{
 
290
    return Utils::toEnum<ENUM__fx_sampler_filter_common, StringHash, ENUM__fx_sampler_filter_common__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
291
}
 
292
 
 
293
 
 
294
//---------------------------------------------------------------------
 
295
const std::pair<StringHash, ENUM__NodeType> ENUM__NodeTypeMap[ENUM__NodeType__COUNT] = 
 
296
{
 
297
    std::pair<StringHash, ENUM__NodeType>(5193268, ENUM__NodeType__JOINT),
 
298
    std::pair<StringHash, ENUM__NodeType>(340869, ENUM__NodeType__NODE)
 
299
};
 
300
 
 
301
//---------------------------------------------------------------------
 
302
ENUM__NodeType toEnum_ENUM__NodeType (
 
303
    const ParserChar** buffer,
 
304
    const ParserChar* bufferEnd,
 
305
    bool& failed,
 
306
    const std::pair<StringHash, ENUM__NodeType>* enumMap,
 
307
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
308
)
 
309
{
 
310
    return Utils::toEnum<ENUM__NodeType, StringHash, ENUM__NodeType__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
311
}
 
312
 
 
313
 
 
314
//---------------------------------------------------------------------
 
315
const std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums> ENUM__gles_texcombiner_operatorRGB_enumsMap[ENUM__gles_texcombiner_operatorRGB_enums__COUNT] = 
 
316
{
 
317
    std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>(17796, ENUM__gles_texcombiner_operatorRGB_enums__ADD),
 
318
    std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>(75102772, ENUM__gles_texcombiner_operatorRGB_enums__ADD_SIGNED),
 
319
    std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>(75055650, ENUM__gles_texcombiner_operatorRGB_enums__DOT3_RGB),
 
320
    std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>(127148577, ENUM__gles_texcombiner_operatorRGB_enums__DOT3_RGBA),
 
321
    std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>(119422501, ENUM__gles_texcombiner_operatorRGB_enums__INTERPOLATE),
 
322
    std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>(60425125, ENUM__gles_texcombiner_operatorRGB_enums__MODULATE),
 
323
    std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>(111478053, ENUM__gles_texcombiner_operatorRGB_enums__REPLACE),
 
324
    std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>(158949380, ENUM__gles_texcombiner_operatorRGB_enums__SUBTRACT)
 
325
};
 
326
 
 
327
//---------------------------------------------------------------------
 
328
ENUM__gles_texcombiner_operatorRGB_enums toEnum_ENUM__gles_texcombiner_operatorRGB_enums (
 
329
    const ParserChar** buffer,
 
330
    const ParserChar* bufferEnd,
 
331
    bool& failed,
 
332
    const std::pair<StringHash, ENUM__gles_texcombiner_operatorRGB_enums>* enumMap,
 
333
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
334
)
 
335
{
 
336
    return Utils::toEnum<ENUM__gles_texcombiner_operatorRGB_enums, StringHash, ENUM__gles_texcombiner_operatorRGB_enums__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
337
}
 
338
 
 
339
 
 
340
//---------------------------------------------------------------------
 
341
const std::pair<StringHash, ENUM__gles_texcombiner_source_enums> ENUM__gles_texcombiner_source_enumsMap[ENUM__gles_texcombiner_source_enums__COUNT] = 
 
342
{
 
343
    std::pair<StringHash, ENUM__gles_texcombiner_source_enums>(70812340, ENUM__gles_texcombiner_source_enums__CONSTANT),
 
344
    std::pair<StringHash, ENUM__gles_texcombiner_source_enums>(111862259, ENUM__gles_texcombiner_source_enums__PREVIOUS),
 
345
    std::pair<StringHash, ENUM__gles_texcombiner_source_enums>(91100713, ENUM__gles_texcombiner_source_enums__PRIMARY),
 
346
    std::pair<StringHash, ENUM__gles_texcombiner_source_enums>(145594933, ENUM__gles_texcombiner_source_enums__TEXTURE)
 
347
};
 
348
 
 
349
//---------------------------------------------------------------------
 
350
ENUM__gles_texcombiner_source_enums toEnum_ENUM__gles_texcombiner_source_enums (
 
351
    const ParserChar** buffer,
 
352
    const ParserChar* bufferEnd,
 
353
    bool& failed,
 
354
    const std::pair<StringHash, ENUM__gles_texcombiner_source_enums>* enumMap,
 
355
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
356
)
 
357
{
 
358
    return Utils::toEnum<ENUM__gles_texcombiner_source_enums, StringHash, ENUM__gles_texcombiner_source_enums__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
359
}
 
360
 
 
361
 
 
362
//---------------------------------------------------------------------
 
363
const std::pair<StringHash, ENUM__gles_texcombiner_operandRGB_enums> ENUM__gles_texcombiner_operandRGB_enumsMap[ENUM__gles_texcombiner_operandRGB_enums__COUNT] = 
 
364
{
 
365
    std::pair<StringHash, ENUM__gles_texcombiner_operandRGB_enums>(11673281, ENUM__gles_texcombiner_operandRGB_enums__ONE_MINUS_SRC_ALPHA),
 
366
    std::pair<StringHash, ENUM__gles_texcombiner_operandRGB_enums>(11815746, ENUM__gles_texcombiner_operandRGB_enums__ONE_MINUS_SRC_COLOR),
 
367
    std::pair<StringHash, ENUM__gles_texcombiner_operandRGB_enums>(154553505, ENUM__gles_texcombiner_operandRGB_enums__SRC_ALPHA),
 
368
    std::pair<StringHash, ENUM__gles_texcombiner_operandRGB_enums>(154695970, ENUM__gles_texcombiner_operandRGB_enums__SRC_COLOR)
 
369
};
 
370
 
 
371
//---------------------------------------------------------------------
 
372
ENUM__gles_texcombiner_operandRGB_enums toEnum_ENUM__gles_texcombiner_operandRGB_enums (
 
373
    const ParserChar** buffer,
 
374
    const ParserChar* bufferEnd,
 
375
    bool& failed,
 
376
    const std::pair<StringHash, ENUM__gles_texcombiner_operandRGB_enums>* enumMap,
 
377
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
378
)
 
379
{
 
380
    return Utils::toEnum<ENUM__gles_texcombiner_operandRGB_enums, StringHash, ENUM__gles_texcombiner_operandRGB_enums__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
381
}
 
382
 
 
383
 
 
384
//---------------------------------------------------------------------
 
385
const std::pair<StringHash, ENUM__gles_texcombiner_operatorAlpha_enums> ENUM__gles_texcombiner_operatorAlpha_enumsMap[ENUM__gles_texcombiner_operatorAlpha_enums__COUNT] = 
 
386
{
 
387
    std::pair<StringHash, ENUM__gles_texcombiner_operatorAlpha_enums>(17796, ENUM__gles_texcombiner_operatorAlpha_enums__ADD),
 
388
    std::pair<StringHash, ENUM__gles_texcombiner_operatorAlpha_enums>(75102772, ENUM__gles_texcombiner_operatorAlpha_enums__ADD_SIGNED),
 
389
    std::pair<StringHash, ENUM__gles_texcombiner_operatorAlpha_enums>(119422501, ENUM__gles_texcombiner_operatorAlpha_enums__INTERPOLATE),
 
390
    std::pair<StringHash, ENUM__gles_texcombiner_operatorAlpha_enums>(60425125, ENUM__gles_texcombiner_operatorAlpha_enums__MODULATE),
 
391
    std::pair<StringHash, ENUM__gles_texcombiner_operatorAlpha_enums>(111478053, ENUM__gles_texcombiner_operatorAlpha_enums__REPLACE),
 
392
    std::pair<StringHash, ENUM__gles_texcombiner_operatorAlpha_enums>(158949380, ENUM__gles_texcombiner_operatorAlpha_enums__SUBTRACT)
 
393
};
 
394
 
 
395
//---------------------------------------------------------------------
 
396
ENUM__gles_texcombiner_operatorAlpha_enums toEnum_ENUM__gles_texcombiner_operatorAlpha_enums (
 
397
    const ParserChar** buffer,
 
398
    const ParserChar* bufferEnd,
 
399
    bool& failed,
 
400
    const std::pair<StringHash, ENUM__gles_texcombiner_operatorAlpha_enums>* enumMap,
 
401
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
402
)
 
403
{
 
404
    return Utils::toEnum<ENUM__gles_texcombiner_operatorAlpha_enums, StringHash, ENUM__gles_texcombiner_operatorAlpha_enums__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
405
}
 
406
 
 
407
 
 
408
//---------------------------------------------------------------------
 
409
const std::pair<StringHash, ENUM__gles_texcombiner_operandAlpha_enums> ENUM__gles_texcombiner_operandAlpha_enumsMap[ENUM__gles_texcombiner_operandAlpha_enums__COUNT] = 
 
410
{
 
411
    std::pair<StringHash, ENUM__gles_texcombiner_operandAlpha_enums>(11673281, ENUM__gles_texcombiner_operandAlpha_enums__ONE_MINUS_SRC_ALPHA),
 
412
    std::pair<StringHash, ENUM__gles_texcombiner_operandAlpha_enums>(154553505, ENUM__gles_texcombiner_operandAlpha_enums__SRC_ALPHA)
 
413
};
 
414
 
 
415
//---------------------------------------------------------------------
 
416
ENUM__gles_texcombiner_operandAlpha_enums toEnum_ENUM__gles_texcombiner_operandAlpha_enums (
 
417
    const ParserChar** buffer,
 
418
    const ParserChar* bufferEnd,
 
419
    bool& failed,
 
420
    const std::pair<StringHash, ENUM__gles_texcombiner_operandAlpha_enums>* enumMap,
 
421
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
422
)
 
423
{
 
424
    return Utils::toEnum<ENUM__gles_texcombiner_operandAlpha_enums, StringHash, ENUM__gles_texcombiner_operandAlpha_enums__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
425
}
 
426
 
 
427
 
 
428
//---------------------------------------------------------------------
 
429
const std::pair<StringHash, ENUM__gles_texenv_mode_enums> ENUM__gles_texenv_mode_enumsMap[ENUM__gles_texenv_mode_enums__COUNT] = 
 
430
{
 
431
    std::pair<StringHash, ENUM__gles_texenv_mode_enums>(17796, ENUM__gles_texenv_mode_enums__ADD),
 
432
    std::pair<StringHash, ENUM__gles_texenv_mode_enums>(4655652, ENUM__gles_texenv_mode_enums__BLEND),
 
433
    std::pair<StringHash, ENUM__gles_texenv_mode_enums>(4757340, ENUM__gles_texenv_mode_enums__DECAL),
 
434
    std::pair<StringHash, ENUM__gles_texenv_mode_enums>(60425125, ENUM__gles_texenv_mode_enums__MODULATE),
 
435
    std::pair<StringHash, ENUM__gles_texenv_mode_enums>(111478053, ENUM__gles_texenv_mode_enums__REPLACE)
 
436
};
 
437
 
 
438
//---------------------------------------------------------------------
 
439
ENUM__gles_texenv_mode_enums toEnum_ENUM__gles_texenv_mode_enums (
 
440
    const ParserChar** buffer,
 
441
    const ParserChar* bufferEnd,
 
442
    bool& failed,
 
443
    const std::pair<StringHash, ENUM__gles_texenv_mode_enums>* enumMap,
 
444
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
445
)
 
446
{
 
447
    return Utils::toEnum<ENUM__gles_texenv_mode_enums, StringHash, ENUM__gles_texenv_mode_enums__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
448
}
 
449
 
 
450
 
 
451
//---------------------------------------------------------------------
 
452
const std::pair<StringHash, ENUM__gles_sampler_wrap> ENUM__gles_sampler_wrapMap[ENUM__gles_sampler_wrap__COUNT] = 
 
453
{
 
454
    std::pair<StringHash, ENUM__gles_sampler_wrap>(4720160, ENUM__gles_sampler_wrap__CLAMP),
 
455
    std::pair<StringHash, ENUM__gles_sampler_wrap>(22396597, ENUM__gles_sampler_wrap__CLAMP_TO_EDGE),
 
456
    std::pair<StringHash, ENUM__gles_sampler_wrap>(52326884, ENUM__gles_sampler_wrap__MIRRORED_REPEAT),
 
457
    std::pair<StringHash, ENUM__gles_sampler_wrap>(90851684, ENUM__gles_sampler_wrap__REPEAT)
 
458
};
 
459
 
 
460
//---------------------------------------------------------------------
 
461
ENUM__gles_sampler_wrap toEnum_ENUM__gles_sampler_wrap (
 
462
    const ParserChar** buffer,
 
463
    const ParserChar* bufferEnd,
 
464
    bool& failed,
 
465
    const std::pair<StringHash, ENUM__gles_sampler_wrap>* enumMap,
 
466
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
467
)
 
468
{
 
469
    return Utils::toEnum<ENUM__gles_sampler_wrap, StringHash, ENUM__gles_sampler_wrap__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
470
}
 
471
 
 
472
 
 
473
//---------------------------------------------------------------------
 
474
const std::pair<StringHash, ENUM__gl_blend_type> ENUM__gl_blend_typeMap[ENUM__gl_blend_type__COUNT] = 
 
475
{
 
476
    std::pair<StringHash, ENUM__gl_blend_type>(235837041, ENUM__gl_blend_type__CONSTANT_ALPHA),
 
477
    std::pair<StringHash, ENUM__gl_blend_type>(235979762, ENUM__gl_blend_type__CONSTANT_COLOR),
 
478
    std::pair<StringHash, ENUM__gl_blend_type>(171232194, ENUM__gl_blend_type__DEST_COLOR),
 
479
    std::pair<StringHash, ENUM__gl_blend_type>(171334977, ENUM__gl_blend_type__DST_ALPHA),
 
480
    std::pair<StringHash, ENUM__gl_blend_type>(21541, ENUM__gl_blend_type__ONE),
 
481
    std::pair<StringHash, ENUM__gl_blend_type>(58120065, ENUM__gl_blend_type__ONE_MINUS_CONSTANT_ALPHA),
 
482
    std::pair<StringHash, ENUM__gl_blend_type>(58262530, ENUM__gl_blend_type__ONE_MINUS_CONSTANT_COLOR),
 
483
    std::pair<StringHash, ENUM__gl_blend_type>(41006258, ENUM__gl_blend_type__ONE_MINUS_DEST_COLOR),
 
484
    std::pair<StringHash, ENUM__gl_blend_type>(263351505, ENUM__gl_blend_type__ONE_MINUS_DST_ALPHA),
 
485
    std::pair<StringHash, ENUM__gl_blend_type>(11673281, ENUM__gl_blend_type__ONE_MINUS_SRC_ALPHA),
 
486
    std::pair<StringHash, ENUM__gl_blend_type>(11815746, ENUM__gl_blend_type__ONE_MINUS_SRC_COLOR),
 
487
    std::pair<StringHash, ENUM__gl_blend_type>(154553505, ENUM__gl_blend_type__SRC_ALPHA),
 
488
    std::pair<StringHash, ENUM__gl_blend_type>(38887829, ENUM__gl_blend_type__SRC_ALPHA_SATURATE),
 
489
    std::pair<StringHash, ENUM__gl_blend_type>(154695970, ENUM__gl_blend_type__SRC_COLOR),
 
490
    std::pair<StringHash, ENUM__gl_blend_type>(387695, ENUM__gl_blend_type__ZERO)
 
491
};
 
492
 
 
493
//---------------------------------------------------------------------
 
494
ENUM__gl_blend_type toEnum_ENUM__gl_blend_type (
 
495
    const ParserChar** buffer,
 
496
    const ParserChar* bufferEnd,
 
497
    bool& failed,
 
498
    const std::pair<StringHash, ENUM__gl_blend_type>* enumMap,
 
499
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
500
)
 
501
{
 
502
    return Utils::toEnum<ENUM__gl_blend_type, StringHash, ENUM__gl_blend_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
503
}
 
504
 
 
505
 
 
506
//---------------------------------------------------------------------
 
507
const std::pair<StringHash, ENUM__gl_face_type> ENUM__gl_face_typeMap[ENUM__gl_face_type__COUNT] = 
 
508
{
 
509
    std::pair<StringHash, ENUM__gl_face_type>(288123, ENUM__gl_face_type__BACK),
 
510
    std::pair<StringHash, ENUM__gl_face_type>(4944948, ENUM__gl_face_type__FRONT),
 
511
    std::pair<StringHash, ENUM__gl_face_type>(98615947, ENUM__gl_face_type__FRONT_AND_BACK)
 
512
};
 
513
 
 
514
//---------------------------------------------------------------------
 
515
ENUM__gl_face_type toEnum_ENUM__gl_face_type (
 
516
    const ParserChar** buffer,
 
517
    const ParserChar* bufferEnd,
 
518
    bool& failed,
 
519
    const std::pair<StringHash, ENUM__gl_face_type>* enumMap,
 
520
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
521
)
 
522
{
 
523
    return Utils::toEnum<ENUM__gl_face_type, StringHash, ENUM__gl_face_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
524
}
 
525
 
 
526
 
 
527
//---------------------------------------------------------------------
 
528
const std::pair<StringHash, ENUM__gl_func_type> ENUM__gl_func_typeMap[ENUM__gl_func_type__COUNT] = 
 
529
{
 
530
    std::pair<StringHash, ENUM__gl_func_type>(73512675, ENUM__gl_func_type__ALWAYS),
 
531
    std::pair<StringHash, ENUM__gl_func_type>(4876636, ENUM__gl_func_type__EQUAL),
 
532
    std::pair<StringHash, ENUM__gl_func_type>(79325532, ENUM__gl_func_type__GEQUAL),
 
533
    std::pair<StringHash, ENUM__gl_func_type>(208234722, ENUM__gl_func_type__GREATER),
 
534
    std::pair<StringHash, ENUM__gl_func_type>(84568412, ENUM__gl_func_type__LEQUAL),
 
535
    std::pair<StringHash, ENUM__gl_func_type>(330371, ENUM__gl_func_type__LESS),
 
536
    std::pair<StringHash, ENUM__gl_func_type>(5417634, ENUM__gl_func_type__NEVER),
 
537
    std::pair<StringHash, ENUM__gl_func_type>(76180588, ENUM__gl_func_type__NOTEQUAL)
 
538
};
 
539
 
 
540
//---------------------------------------------------------------------
 
541
ENUM__gl_func_type toEnum_ENUM__gl_func_type (
 
542
    const ParserChar** buffer,
 
543
    const ParserChar* bufferEnd,
 
544
    bool& failed,
 
545
    const std::pair<StringHash, ENUM__gl_func_type>* enumMap,
 
546
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
547
)
 
548
{
 
549
    return Utils::toEnum<ENUM__gl_func_type, StringHash, ENUM__gl_func_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
550
}
 
551
 
 
552
 
 
553
//---------------------------------------------------------------------
 
554
const std::pair<StringHash, ENUM__gl_stencil_op_type> ENUM__gl_stencil_op_typeMap[ENUM__gl_stencil_op_type__COUNT] = 
 
555
{
 
556
    std::pair<StringHash, ENUM__gl_stencil_op_type>(297346, ENUM__gl_stencil_op_type__DECR),
 
557
    std::pair<StringHash, ENUM__gl_stencil_op_type>(142905072, ENUM__gl_stencil_op_type__DECR_WRAP),
 
558
    std::pair<StringHash, ENUM__gl_stencil_op_type>(320130, ENUM__gl_stencil_op_type__INCR),
 
559
    std::pair<StringHash, ENUM__gl_stencil_op_type>(142903360, ENUM__gl_stencil_op_type__INCR_WRAP),
 
560
    std::pair<StringHash, ENUM__gl_stencil_op_type>(82029172, ENUM__gl_stencil_op_type__INVERT),
 
561
    std::pair<StringHash, ENUM__gl_stencil_op_type>(326048, ENUM__gl_stencil_op_type__KEEP),
 
562
    std::pair<StringHash, ENUM__gl_stencil_op_type>(111478053, ENUM__gl_stencil_op_type__REPLACE),
 
563
    std::pair<StringHash, ENUM__gl_stencil_op_type>(387695, ENUM__gl_stencil_op_type__ZERO)
 
564
};
 
565
 
 
566
//---------------------------------------------------------------------
 
567
ENUM__gl_stencil_op_type toEnum_ENUM__gl_stencil_op_type (
 
568
    const ParserChar** buffer,
 
569
    const ParserChar* bufferEnd,
 
570
    bool& failed,
 
571
    const std::pair<StringHash, ENUM__gl_stencil_op_type>* enumMap,
 
572
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
573
)
 
574
{
 
575
    return Utils::toEnum<ENUM__gl_stencil_op_type, StringHash, ENUM__gl_stencil_op_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
576
}
 
577
 
 
578
 
 
579
//---------------------------------------------------------------------
 
580
const std::pair<StringHash, ENUM__gl_material_type> ENUM__gl_material_typeMap[ENUM__gl_material_type__COUNT] = 
 
581
{
 
582
    std::pair<StringHash, ENUM__gl_material_type>(102161012, ENUM__gl_material_type__AMBIENT),
 
583
    std::pair<StringHash, ENUM__gl_material_type>(150884037, ENUM__gl_material_type__AMBIENT_AND_DIFFUSE),
 
584
    std::pair<StringHash, ENUM__gl_material_type>(148552245, ENUM__gl_material_type__DIFFUSE),
 
585
    std::pair<StringHash, ENUM__gl_material_type>(32012958, ENUM__gl_material_type__EMISSION),
 
586
    std::pair<StringHash, ENUM__gl_material_type>(77112802, ENUM__gl_material_type__SPECULAR)
 
587
};
 
588
 
 
589
//---------------------------------------------------------------------
 
590
ENUM__gl_material_type toEnum_ENUM__gl_material_type (
 
591
    const ParserChar** buffer,
 
592
    const ParserChar* bufferEnd,
 
593
    bool& failed,
 
594
    const std::pair<StringHash, ENUM__gl_material_type>* enumMap,
 
595
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
596
)
 
597
{
 
598
    return Utils::toEnum<ENUM__gl_material_type, StringHash, ENUM__gl_material_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
599
}
 
600
 
 
601
 
 
602
//---------------------------------------------------------------------
 
603
const std::pair<StringHash, ENUM__gl_fog_type> ENUM__gl_fog_typeMap[ENUM__gl_fog_type__COUNT] = 
 
604
{
 
605
    std::pair<StringHash, ENUM__gl_fog_type>(19152, ENUM__gl_fog_type__EXP),
 
606
    std::pair<StringHash, ENUM__gl_fog_type>(306482, ENUM__gl_fog_type__EXP2),
 
607
    std::pair<StringHash, ENUM__gl_fog_type>(84814178, ENUM__gl_fog_type__LINEAR)
 
608
};
 
609
 
 
610
//---------------------------------------------------------------------
 
611
ENUM__gl_fog_type toEnum_ENUM__gl_fog_type (
 
612
    const ParserChar** buffer,
 
613
    const ParserChar* bufferEnd,
 
614
    bool& failed,
 
615
    const std::pair<StringHash, ENUM__gl_fog_type>* enumMap,
 
616
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
617
)
 
618
{
 
619
    return Utils::toEnum<ENUM__gl_fog_type, StringHash, ENUM__gl_fog_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
620
}
 
621
 
 
622
 
 
623
//---------------------------------------------------------------------
 
624
const std::pair<StringHash, ENUM__gl_front_face_type> ENUM__gl_front_face_typeMap[ENUM__gl_front_face_type__COUNT] = 
 
625
{
 
626
    std::pair<StringHash, ENUM__gl_front_face_type>(18311, ENUM__gl_front_face_type__CCW),
 
627
    std::pair<StringHash, ENUM__gl_front_face_type>(1159, ENUM__gl_front_face_type__CW)
 
628
};
 
629
 
 
630
//---------------------------------------------------------------------
 
631
ENUM__gl_front_face_type toEnum_ENUM__gl_front_face_type (
 
632
    const ParserChar** buffer,
 
633
    const ParserChar* bufferEnd,
 
634
    bool& failed,
 
635
    const std::pair<StringHash, ENUM__gl_front_face_type>* enumMap,
 
636
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
637
)
 
638
{
 
639
    return Utils::toEnum<ENUM__gl_front_face_type, StringHash, ENUM__gl_front_face_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
640
}
 
641
 
 
642
 
 
643
//---------------------------------------------------------------------
 
644
const std::pair<StringHash, ENUM__gl_light_model_color_control_type> ENUM__gl_light_model_color_control_typeMap[ENUM__gl_light_model_color_control_type__COUNT] = 
 
645
{
 
646
    std::pair<StringHash, ENUM__gl_light_model_color_control_type>(110211522, ENUM__gl_light_model_color_control_type__SEPARATE_SPECULAR_COLOR),
 
647
    std::pair<StringHash, ENUM__gl_light_model_color_control_type>(4861266, ENUM__gl_light_model_color_control_type__SINGLE_COLOR)
 
648
};
 
649
 
 
650
//---------------------------------------------------------------------
 
651
ENUM__gl_light_model_color_control_type toEnum_ENUM__gl_light_model_color_control_type (
 
652
    const ParserChar** buffer,
 
653
    const ParserChar* bufferEnd,
 
654
    bool& failed,
 
655
    const std::pair<StringHash, ENUM__gl_light_model_color_control_type>* enumMap,
 
656
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
657
)
 
658
{
 
659
    return Utils::toEnum<ENUM__gl_light_model_color_control_type, StringHash, ENUM__gl_light_model_color_control_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
660
}
 
661
 
 
662
 
 
663
//---------------------------------------------------------------------
 
664
const std::pair<StringHash, ENUM__gl_logic_op_type> ENUM__gl_logic_op_typeMap[ENUM__gl_logic_op_type__COUNT] = 
 
665
{
 
666
    std::pair<StringHash, ENUM__gl_logic_op_type>(17956, ENUM__gl_logic_op_type__AND),
 
667
    std::pair<StringHash, ENUM__gl_logic_op_type>(130603892, ENUM__gl_logic_op_type__AND_INVERTED),
 
668
    std::pair<StringHash, ENUM__gl_logic_op_type>(116165941, ENUM__gl_logic_op_type__AND_REVERSE),
 
669
    std::pair<StringHash, ENUM__gl_logic_op_type>(4720994, ENUM__gl_logic_op_type__CLEAR),
 
670
    std::pair<StringHash, ENUM__gl_logic_op_type>(296025, ENUM__gl_logic_op_type__COPY),
 
671
    std::pair<StringHash, ENUM__gl_logic_op_type>(200248116, ENUM__gl_logic_op_type__COPY_INVERTED),
 
672
    std::pair<StringHash, ENUM__gl_logic_op_type>(4876774, ENUM__gl_logic_op_type__EQUIV),
 
673
    std::pair<StringHash, ENUM__gl_logic_op_type>(82029172, ENUM__gl_logic_op_type__INVERT),
 
674
    std::pair<StringHash, ENUM__gl_logic_op_type>(337444, ENUM__gl_logic_op_type__NAND),
 
675
    std::pair<StringHash, ENUM__gl_logic_op_type>(341056, ENUM__gl_logic_op_type__NOOP),
 
676
    std::pair<StringHash, ENUM__gl_logic_op_type>(21314, ENUM__gl_logic_op_type__NOR),
 
677
    std::pair<StringHash, ENUM__gl_logic_op_type>(1346, ENUM__gl_logic_op_type__OR),
 
678
    std::pair<StringHash, ENUM__gl_logic_op_type>(112193333, ENUM__gl_logic_op_type__OR_REVERSE),
 
679
    std::pair<StringHash, ENUM__gl_logic_op_type>(22436, ENUM__gl_logic_op_type__SET),
 
680
    std::pair<StringHash, ENUM__gl_logic_op_type>(23874, ENUM__gl_logic_op_type__XOR)
 
681
};
 
682
 
 
683
//---------------------------------------------------------------------
 
684
ENUM__gl_logic_op_type toEnum_ENUM__gl_logic_op_type (
 
685
    const ParserChar** buffer,
 
686
    const ParserChar* bufferEnd,
 
687
    bool& failed,
 
688
    const std::pair<StringHash, ENUM__gl_logic_op_type>* enumMap,
 
689
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
690
)
 
691
{
 
692
    return Utils::toEnum<ENUM__gl_logic_op_type, StringHash, ENUM__gl_logic_op_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
693
}
 
694
 
 
695
 
 
696
//---------------------------------------------------------------------
 
697
const std::pair<StringHash, ENUM__gl_polygon_mode_type> ENUM__gl_polygon_mode_typeMap[ENUM__gl_polygon_mode_type__COUNT] = 
 
698
{
 
699
    std::pair<StringHash, ENUM__gl_polygon_mode_type>(306700, ENUM__gl_polygon_mode_type__FILL),
 
700
    std::pair<StringHash, ENUM__gl_polygon_mode_type>(331301, ENUM__gl_polygon_mode_type__LINE),
 
701
    std::pair<StringHash, ENUM__gl_polygon_mode_type>(5586484, ENUM__gl_polygon_mode_type__POINT)
 
702
};
 
703
 
 
704
//---------------------------------------------------------------------
 
705
ENUM__gl_polygon_mode_type toEnum_ENUM__gl_polygon_mode_type (
 
706
    const ParserChar** buffer,
 
707
    const ParserChar* bufferEnd,
 
708
    bool& failed,
 
709
    const std::pair<StringHash, ENUM__gl_polygon_mode_type>* enumMap,
 
710
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
711
)
 
712
{
 
713
    return Utils::toEnum<ENUM__gl_polygon_mode_type, StringHash, ENUM__gl_polygon_mode_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
714
}
 
715
 
 
716
 
 
717
//---------------------------------------------------------------------
 
718
const std::pair<StringHash, ENUM__gl_shade_model_type> ENUM__gl_shade_model_typeMap[ENUM__gl_shade_model_type__COUNT] = 
 
719
{
 
720
    std::pair<StringHash, ENUM__gl_shade_model_type>(307300, ENUM__gl_shade_model_type__FLAT),
 
721
    std::pair<StringHash, ENUM__gl_shade_model_type>(92423304, ENUM__gl_shade_model_type__SMOOTH)
 
722
};
 
723
 
 
724
//---------------------------------------------------------------------
 
725
ENUM__gl_shade_model_type toEnum_ENUM__gl_shade_model_type (
 
726
    const ParserChar** buffer,
 
727
    const ParserChar* bufferEnd,
 
728
    bool& failed,
 
729
    const std::pair<StringHash, ENUM__gl_shade_model_type>* enumMap,
 
730
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
731
)
 
732
{
 
733
    return Utils::toEnum<ENUM__gl_shade_model_type, StringHash, ENUM__gl_shade_model_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
734
}
 
735
 
 
736
 
 
737
//---------------------------------------------------------------------
 
738
UNION__gles_enumeration toUnion_UNION__gles_enumeration ( const ParserChar* buffer, size_t length, bool& failed )
 
739
{
 
740
    UNION__gles_enumeration returnValue;
 
741
    const ParserChar* tmpBuf;
 
742
 
 
743
    tmpBuf = buffer;
 
744
    ENUM__gl_blend_type tmp0 = Utils::toEnum<ENUM__gl_blend_type, StringHash, ENUM__gl_blend_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_blend_typeMap, Utils::calculateStringHash );
 
745
    if( !failed )
 
746
    {
 
747
        returnValue.union_type = UNION__gles_enumeration::GL_BLEND_TYPE;
 
748
        returnValue.union_data.GL_BLEND_TYPE = tmp0;
 
749
        return returnValue;
 
750
    }
 
751
 
 
752
    tmpBuf = buffer;
 
753
    ENUM__gl_face_type tmp1 = Utils::toEnum<ENUM__gl_face_type, StringHash, ENUM__gl_face_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_face_typeMap, Utils::calculateStringHash );
 
754
    if( !failed )
 
755
    {
 
756
        returnValue.union_type = UNION__gles_enumeration::GL_FACE_TYPE;
 
757
        returnValue.union_data.GL_FACE_TYPE = tmp1;
 
758
        return returnValue;
 
759
    }
 
760
 
 
761
    tmpBuf = buffer;
 
762
    ENUM__gl_func_type tmp2 = Utils::toEnum<ENUM__gl_func_type, StringHash, ENUM__gl_func_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_func_typeMap, Utils::calculateStringHash );
 
763
    if( !failed )
 
764
    {
 
765
        returnValue.union_type = UNION__gles_enumeration::GL_FUNC_TYPE;
 
766
        returnValue.union_data.GL_FUNC_TYPE = tmp2;
 
767
        return returnValue;
 
768
    }
 
769
 
 
770
    tmpBuf = buffer;
 
771
    ENUM__gl_stencil_op_type tmp3 = Utils::toEnum<ENUM__gl_stencil_op_type, StringHash, ENUM__gl_stencil_op_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_stencil_op_typeMap, Utils::calculateStringHash );
 
772
    if( !failed )
 
773
    {
 
774
        returnValue.union_type = UNION__gles_enumeration::GL_STENCIL_OP_TYPE;
 
775
        returnValue.union_data.GL_STENCIL_OP_TYPE = tmp3;
 
776
        return returnValue;
 
777
    }
 
778
 
 
779
    tmpBuf = buffer;
 
780
    ENUM__gl_material_type tmp4 = Utils::toEnum<ENUM__gl_material_type, StringHash, ENUM__gl_material_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_material_typeMap, Utils::calculateStringHash );
 
781
    if( !failed )
 
782
    {
 
783
        returnValue.union_type = UNION__gles_enumeration::GL_MATERIAL_TYPE;
 
784
        returnValue.union_data.GL_MATERIAL_TYPE = tmp4;
 
785
        return returnValue;
 
786
    }
 
787
 
 
788
    tmpBuf = buffer;
 
789
    ENUM__gl_fog_type tmp5 = Utils::toEnum<ENUM__gl_fog_type, StringHash, ENUM__gl_fog_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_fog_typeMap, Utils::calculateStringHash );
 
790
    if( !failed )
 
791
    {
 
792
        returnValue.union_type = UNION__gles_enumeration::GL_FOG_TYPE;
 
793
        returnValue.union_data.GL_FOG_TYPE = tmp5;
 
794
        return returnValue;
 
795
    }
 
796
 
 
797
    tmpBuf = buffer;
 
798
    ENUM__gl_front_face_type tmp6 = Utils::toEnum<ENUM__gl_front_face_type, StringHash, ENUM__gl_front_face_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_front_face_typeMap, Utils::calculateStringHash );
 
799
    if( !failed )
 
800
    {
 
801
        returnValue.union_type = UNION__gles_enumeration::GL_FRONT_FACE_TYPE;
 
802
        returnValue.union_data.GL_FRONT_FACE_TYPE = tmp6;
 
803
        return returnValue;
 
804
    }
 
805
 
 
806
    tmpBuf = buffer;
 
807
    ENUM__gl_light_model_color_control_type tmp7 = Utils::toEnum<ENUM__gl_light_model_color_control_type, StringHash, ENUM__gl_light_model_color_control_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_light_model_color_control_typeMap, Utils::calculateStringHash );
 
808
    if( !failed )
 
809
    {
 
810
        returnValue.union_type = UNION__gles_enumeration::GL_LIGHT_MODEL_COLOR_CONTROL_TYPE;
 
811
        returnValue.union_data.GL_LIGHT_MODEL_COLOR_CONTROL_TYPE = tmp7;
 
812
        return returnValue;
 
813
    }
 
814
 
 
815
    tmpBuf = buffer;
 
816
    ENUM__gl_logic_op_type tmp8 = Utils::toEnum<ENUM__gl_logic_op_type, StringHash, ENUM__gl_logic_op_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_logic_op_typeMap, Utils::calculateStringHash );
 
817
    if( !failed )
 
818
    {
 
819
        returnValue.union_type = UNION__gles_enumeration::GL_LOGIC_OP_TYPE;
 
820
        returnValue.union_data.GL_LOGIC_OP_TYPE = tmp8;
 
821
        return returnValue;
 
822
    }
 
823
 
 
824
    tmpBuf = buffer;
 
825
    ENUM__gl_polygon_mode_type tmp9 = Utils::toEnum<ENUM__gl_polygon_mode_type, StringHash, ENUM__gl_polygon_mode_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_polygon_mode_typeMap, Utils::calculateStringHash );
 
826
    if( !failed )
 
827
    {
 
828
        returnValue.union_type = UNION__gles_enumeration::GL_POLYGON_MODE_TYPE;
 
829
        returnValue.union_data.GL_POLYGON_MODE_TYPE = tmp9;
 
830
        return returnValue;
 
831
    }
 
832
 
 
833
    tmpBuf = buffer;
 
834
    ENUM__gl_shade_model_type tmp10 = Utils::toEnum<ENUM__gl_shade_model_type, StringHash, ENUM__gl_shade_model_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_shade_model_typeMap, Utils::calculateStringHash );
 
835
    if( !failed )
 
836
    {
 
837
        returnValue.union_type = UNION__gles_enumeration::GL_SHADE_MODEL_TYPE;
 
838
        returnValue.union_data.GL_SHADE_MODEL_TYPE = tmp10;
 
839
        return returnValue;
 
840
    }
 
841
 
 
842
 
 
843
    returnValue.union_type = UNION__gles_enumeration::INVALID;
 
844
    return returnValue;
 
845
}
 
846
 
 
847
 
 
848
//---------------------------------------------------------------------
 
849
UNION__gles_enumeration toUnion_UNION__gles_enumeration ( const ParserChar** buffer, const ParserChar* bufferEnd, bool& failed )
 
850
{
 
851
    ParserString tmp = Utils::toStringListItem( buffer, bufferEnd, failed );
 
852
    return toUnion_UNION__gles_enumeration( tmp.str, tmp.length, failed );
 
853
}
 
854
 
 
855
 
 
856
//---------------------------------------------------------------------
 
857
UNION__gles_enumeration toUnion_UNION__gles_enumeration ( const ParserChar** buffer, bool& failed )
 
858
{
 
859
    ParserString tmp = Utils::toStringListItem( buffer, failed );
 
860
    return toUnion_UNION__gles_enumeration( tmp.str, tmp.length, failed );
 
861
}
 
862
 
 
863
 
 
864
//---------------------------------------------------------------------
 
865
const std::pair<StringHash, ENUM__gles_stencil_op_type> ENUM__gles_stencil_op_typeMap[ENUM__gles_stencil_op_type__COUNT] = 
 
866
{
 
867
    std::pair<StringHash, ENUM__gles_stencil_op_type>(297346, ENUM__gles_stencil_op_type__DECR),
 
868
    std::pair<StringHash, ENUM__gles_stencil_op_type>(320130, ENUM__gles_stencil_op_type__INCR),
 
869
    std::pair<StringHash, ENUM__gles_stencil_op_type>(82029172, ENUM__gles_stencil_op_type__INVERT),
 
870
    std::pair<StringHash, ENUM__gles_stencil_op_type>(326048, ENUM__gles_stencil_op_type__KEEP),
 
871
    std::pair<StringHash, ENUM__gles_stencil_op_type>(111478053, ENUM__gles_stencil_op_type__REPLACE),
 
872
    std::pair<StringHash, ENUM__gles_stencil_op_type>(387695, ENUM__gles_stencil_op_type__ZERO)
 
873
};
 
874
 
 
875
//---------------------------------------------------------------------
 
876
ENUM__gles_stencil_op_type toEnum_ENUM__gles_stencil_op_type (
 
877
    const ParserChar** buffer,
 
878
    const ParserChar* bufferEnd,
 
879
    bool& failed,
 
880
    const std::pair<StringHash, ENUM__gles_stencil_op_type>* enumMap,
 
881
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
882
)
 
883
{
 
884
    return Utils::toEnum<ENUM__gles_stencil_op_type, StringHash, ENUM__gles_stencil_op_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
885
}
 
886
 
 
887
 
 
888
//---------------------------------------------------------------------
 
889
const std::pair<StringHash, ENUM__gl_blend_equation_type> ENUM__gl_blend_equation_typeMap[ENUM__gl_blend_equation_type__COUNT] = 
 
890
{
 
891
    std::pair<StringHash, ENUM__gl_blend_equation_type>(170471732, ENUM__gl_blend_equation_type__FUNC_ADD),
 
892
    std::pair<StringHash, ENUM__gl_blend_equation_type>(26931204, ENUM__gl_blend_equation_type__FUNC_REVERSE_SUBTRACT),
 
893
    std::pair<StringHash, ENUM__gl_blend_equation_type>(47968580, ENUM__gl_blend_equation_type__FUNC_SUBTRACT),
 
894
    std::pair<StringHash, ENUM__gl_blend_equation_type>(20840, ENUM__gl_blend_equation_type__MAX),
 
895
    std::pair<StringHash, ENUM__gl_blend_equation_type>(20958, ENUM__gl_blend_equation_type__MIN)
 
896
};
 
897
 
 
898
//---------------------------------------------------------------------
 
899
ENUM__gl_blend_equation_type toEnum_ENUM__gl_blend_equation_type (
 
900
    const ParserChar** buffer,
 
901
    const ParserChar* bufferEnd,
 
902
    bool& failed,
 
903
    const std::pair<StringHash, ENUM__gl_blend_equation_type>* enumMap,
 
904
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
905
)
 
906
{
 
907
    return Utils::toEnum<ENUM__gl_blend_equation_type, StringHash, ENUM__gl_blend_equation_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
908
}
 
909
 
 
910
 
 
911
//---------------------------------------------------------------------
 
912
const std::pair<StringHash, ENUM__gl_fog_coord_src_type> ENUM__gl_fog_coord_src_typeMap[ENUM__gl_fog_coord_src_type__COUNT] = 
 
913
{
 
914
    std::pair<StringHash, ENUM__gl_fog_coord_src_type>(90156661, ENUM__gl_fog_coord_src_type__FOG_COORDINATE),
 
915
    std::pair<StringHash, ENUM__gl_fog_coord_src_type>(6601496, ENUM__gl_fog_coord_src_type__FRAGMENT_DEPTH)
 
916
};
 
917
 
 
918
//---------------------------------------------------------------------
 
919
ENUM__gl_fog_coord_src_type toEnum_ENUM__gl_fog_coord_src_type (
 
920
    const ParserChar** buffer,
 
921
    const ParserChar* bufferEnd,
 
922
    bool& failed,
 
923
    const std::pair<StringHash, ENUM__gl_fog_coord_src_type>* enumMap,
 
924
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
925
)
 
926
{
 
927
    return Utils::toEnum<ENUM__gl_fog_coord_src_type, StringHash, ENUM__gl_fog_coord_src_type__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
928
}
 
929
 
 
930
 
 
931
//---------------------------------------------------------------------
 
932
UNION__gl_enumeration toUnion_UNION__gl_enumeration ( const ParserChar* buffer, size_t length, bool& failed )
 
933
{
 
934
    UNION__gl_enumeration returnValue;
 
935
    const ParserChar* tmpBuf;
 
936
 
 
937
    tmpBuf = buffer;
 
938
    ENUM__gl_blend_type tmp0 = Utils::toEnum<ENUM__gl_blend_type, StringHash, ENUM__gl_blend_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_blend_typeMap, Utils::calculateStringHash );
 
939
    if( !failed )
 
940
    {
 
941
        returnValue.union_type = UNION__gl_enumeration::GL_BLEND_TYPE;
 
942
        returnValue.union_data.GL_BLEND_TYPE = tmp0;
 
943
        return returnValue;
 
944
    }
 
945
 
 
946
    tmpBuf = buffer;
 
947
    ENUM__gl_face_type tmp1 = Utils::toEnum<ENUM__gl_face_type, StringHash, ENUM__gl_face_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_face_typeMap, Utils::calculateStringHash );
 
948
    if( !failed )
 
949
    {
 
950
        returnValue.union_type = UNION__gl_enumeration::GL_FACE_TYPE;
 
951
        returnValue.union_data.GL_FACE_TYPE = tmp1;
 
952
        return returnValue;
 
953
    }
 
954
 
 
955
    tmpBuf = buffer;
 
956
    ENUM__gl_blend_equation_type tmp2 = Utils::toEnum<ENUM__gl_blend_equation_type, StringHash, ENUM__gl_blend_equation_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_blend_equation_typeMap, Utils::calculateStringHash );
 
957
    if( !failed )
 
958
    {
 
959
        returnValue.union_type = UNION__gl_enumeration::GL_BLEND_EQUATION_TYPE;
 
960
        returnValue.union_data.GL_BLEND_EQUATION_TYPE = tmp2;
 
961
        return returnValue;
 
962
    }
 
963
 
 
964
    tmpBuf = buffer;
 
965
    ENUM__gl_func_type tmp3 = Utils::toEnum<ENUM__gl_func_type, StringHash, ENUM__gl_func_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_func_typeMap, Utils::calculateStringHash );
 
966
    if( !failed )
 
967
    {
 
968
        returnValue.union_type = UNION__gl_enumeration::GL_FUNC_TYPE;
 
969
        returnValue.union_data.GL_FUNC_TYPE = tmp3;
 
970
        return returnValue;
 
971
    }
 
972
 
 
973
    tmpBuf = buffer;
 
974
    ENUM__gl_stencil_op_type tmp4 = Utils::toEnum<ENUM__gl_stencil_op_type, StringHash, ENUM__gl_stencil_op_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_stencil_op_typeMap, Utils::calculateStringHash );
 
975
    if( !failed )
 
976
    {
 
977
        returnValue.union_type = UNION__gl_enumeration::GL_STENCIL_OP_TYPE;
 
978
        returnValue.union_data.GL_STENCIL_OP_TYPE = tmp4;
 
979
        return returnValue;
 
980
    }
 
981
 
 
982
    tmpBuf = buffer;
 
983
    ENUM__gl_material_type tmp5 = Utils::toEnum<ENUM__gl_material_type, StringHash, ENUM__gl_material_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_material_typeMap, Utils::calculateStringHash );
 
984
    if( !failed )
 
985
    {
 
986
        returnValue.union_type = UNION__gl_enumeration::GL_MATERIAL_TYPE;
 
987
        returnValue.union_data.GL_MATERIAL_TYPE = tmp5;
 
988
        return returnValue;
 
989
    }
 
990
 
 
991
    tmpBuf = buffer;
 
992
    ENUM__gl_fog_type tmp6 = Utils::toEnum<ENUM__gl_fog_type, StringHash, ENUM__gl_fog_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_fog_typeMap, Utils::calculateStringHash );
 
993
    if( !failed )
 
994
    {
 
995
        returnValue.union_type = UNION__gl_enumeration::GL_FOG_TYPE;
 
996
        returnValue.union_data.GL_FOG_TYPE = tmp6;
 
997
        return returnValue;
 
998
    }
 
999
 
 
1000
    tmpBuf = buffer;
 
1001
    ENUM__gl_fog_coord_src_type tmp7 = Utils::toEnum<ENUM__gl_fog_coord_src_type, StringHash, ENUM__gl_fog_coord_src_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_fog_coord_src_typeMap, Utils::calculateStringHash );
 
1002
    if( !failed )
 
1003
    {
 
1004
        returnValue.union_type = UNION__gl_enumeration::GL_FOG_COORD_SRC_TYPE;
 
1005
        returnValue.union_data.GL_FOG_COORD_SRC_TYPE = tmp7;
 
1006
        return returnValue;
 
1007
    }
 
1008
 
 
1009
    tmpBuf = buffer;
 
1010
    ENUM__gl_front_face_type tmp8 = Utils::toEnum<ENUM__gl_front_face_type, StringHash, ENUM__gl_front_face_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_front_face_typeMap, Utils::calculateStringHash );
 
1011
    if( !failed )
 
1012
    {
 
1013
        returnValue.union_type = UNION__gl_enumeration::GL_FRONT_FACE_TYPE;
 
1014
        returnValue.union_data.GL_FRONT_FACE_TYPE = tmp8;
 
1015
        return returnValue;
 
1016
    }
 
1017
 
 
1018
    tmpBuf = buffer;
 
1019
    ENUM__gl_light_model_color_control_type tmp9 = Utils::toEnum<ENUM__gl_light_model_color_control_type, StringHash, ENUM__gl_light_model_color_control_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_light_model_color_control_typeMap, Utils::calculateStringHash );
 
1020
    if( !failed )
 
1021
    {
 
1022
        returnValue.union_type = UNION__gl_enumeration::GL_LIGHT_MODEL_COLOR_CONTROL_TYPE;
 
1023
        returnValue.union_data.GL_LIGHT_MODEL_COLOR_CONTROL_TYPE = tmp9;
 
1024
        return returnValue;
 
1025
    }
 
1026
 
 
1027
    tmpBuf = buffer;
 
1028
    ENUM__gl_logic_op_type tmp10 = Utils::toEnum<ENUM__gl_logic_op_type, StringHash, ENUM__gl_logic_op_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_logic_op_typeMap, Utils::calculateStringHash );
 
1029
    if( !failed )
 
1030
    {
 
1031
        returnValue.union_type = UNION__gl_enumeration::GL_LOGIC_OP_TYPE;
 
1032
        returnValue.union_data.GL_LOGIC_OP_TYPE = tmp10;
 
1033
        return returnValue;
 
1034
    }
 
1035
 
 
1036
    tmpBuf = buffer;
 
1037
    ENUM__gl_polygon_mode_type tmp11 = Utils::toEnum<ENUM__gl_polygon_mode_type, StringHash, ENUM__gl_polygon_mode_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_polygon_mode_typeMap, Utils::calculateStringHash );
 
1038
    if( !failed )
 
1039
    {
 
1040
        returnValue.union_type = UNION__gl_enumeration::GL_POLYGON_MODE_TYPE;
 
1041
        returnValue.union_data.GL_POLYGON_MODE_TYPE = tmp11;
 
1042
        return returnValue;
 
1043
    }
 
1044
 
 
1045
    tmpBuf = buffer;
 
1046
    ENUM__gl_shade_model_type tmp12 = Utils::toEnum<ENUM__gl_shade_model_type, StringHash, ENUM__gl_shade_model_type__COUNT>( (const ParserChar**)&tmpBuf, (const ParserChar*)(buffer+length), failed, ENUM__gl_shade_model_typeMap, Utils::calculateStringHash );
 
1047
    if( !failed )
 
1048
    {
 
1049
        returnValue.union_type = UNION__gl_enumeration::GL_SHADE_MODEL_TYPE;
 
1050
        returnValue.union_data.GL_SHADE_MODEL_TYPE = tmp12;
 
1051
        return returnValue;
 
1052
    }
 
1053
 
 
1054
 
 
1055
    returnValue.union_type = UNION__gl_enumeration::INVALID;
 
1056
    return returnValue;
 
1057
}
 
1058
 
 
1059
 
 
1060
//---------------------------------------------------------------------
 
1061
UNION__gl_enumeration toUnion_UNION__gl_enumeration ( const ParserChar** buffer, const ParserChar* bufferEnd, bool& failed )
 
1062
{
 
1063
    ParserString tmp = Utils::toStringListItem( buffer, bufferEnd, failed );
 
1064
    return toUnion_UNION__gl_enumeration( tmp.str, tmp.length, failed );
 
1065
}
 
1066
 
 
1067
 
 
1068
//---------------------------------------------------------------------
 
1069
UNION__gl_enumeration toUnion_UNION__gl_enumeration ( const ParserChar** buffer, bool& failed )
 
1070
{
 
1071
    ParserString tmp = Utils::toStringListItem( buffer, failed );
 
1072
    return toUnion_UNION__gl_enumeration( tmp.str, tmp.length, failed );
 
1073
}
 
1074
 
 
1075
 
 
1076
//---------------------------------------------------------------------
 
1077
const std::pair<StringHash, ENUM__glsl_pipeline_stage> ENUM__glsl_pipeline_stageMap[ENUM__glsl_pipeline_stage__COUNT] = 
 
1078
{
 
1079
    std::pair<StringHash, ENUM__glsl_pipeline_stage>(11677357, ENUM__glsl_pipeline_stage__FRAGMENTPROGRAM),
 
1080
    std::pair<StringHash, ENUM__glsl_pipeline_stage>(265571549, ENUM__glsl_pipeline_stage__VERTEXPROGRAM)
 
1081
};
 
1082
 
 
1083
//---------------------------------------------------------------------
 
1084
ENUM__glsl_pipeline_stage toEnum_ENUM__glsl_pipeline_stage (
 
1085
    const ParserChar** buffer,
 
1086
    const ParserChar* bufferEnd,
 
1087
    bool& failed,
 
1088
    const std::pair<StringHash, ENUM__glsl_pipeline_stage>* enumMap,
 
1089
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
1090
)
 
1091
{
 
1092
    return Utils::toEnum<ENUM__glsl_pipeline_stage, StringHash, ENUM__glsl_pipeline_stage__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
1093
}
 
1094
 
 
1095
 
 
1096
//---------------------------------------------------------------------
 
1097
const std::pair<StringHash, ENUM__cg_pipeline_stage> ENUM__cg_pipeline_stageMap[ENUM__cg_pipeline_stage__COUNT] = 
 
1098
{
 
1099
    std::pair<StringHash, ENUM__cg_pipeline_stage>(106700420, ENUM__cg_pipeline_stage__FRAGMENT),
 
1100
    std::pair<StringHash, ENUM__cg_pipeline_stage>(95058088, ENUM__cg_pipeline_stage__VERTEX)
 
1101
};
 
1102
 
 
1103
//---------------------------------------------------------------------
 
1104
ENUM__cg_pipeline_stage toEnum_ENUM__cg_pipeline_stage (
 
1105
    const ParserChar** buffer,
 
1106
    const ParserChar* bufferEnd,
 
1107
    bool& failed,
 
1108
    const std::pair<StringHash, ENUM__cg_pipeline_stage>* enumMap,
 
1109
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
1110
)
 
1111
{
 
1112
    return Utils::toEnum<ENUM__cg_pipeline_stage, StringHash, ENUM__cg_pipeline_stage__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
1113
}
 
1114
 
 
1115
 
 
1116
//---------------------------------------------------------------------
 
1117
const std::pair<StringHash, ENUM__fx_opaque_enum> ENUM__fx_opaque_enumMap[ENUM__fx_opaque_enum__COUNT] = 
 
1118
{
 
1119
    std::pair<StringHash, ENUM__fx_opaque_enum>(4670501, ENUM__fx_opaque_enum__A_ONE),
 
1120
    std::pair<StringHash, ENUM__fx_opaque_enum>(193261327, ENUM__fx_opaque_enum__RGB_ZERO)
 
1121
};
 
1122
 
 
1123
//---------------------------------------------------------------------
 
1124
ENUM__fx_opaque_enum toEnum_ENUM__fx_opaque_enum (
 
1125
    const ParserChar** buffer,
 
1126
    const ParserChar* bufferEnd,
 
1127
    bool& failed,
 
1128
    const std::pair<StringHash, ENUM__fx_opaque_enum>* enumMap,
 
1129
    StringHash (*baseConversionFunc)( const ParserChar**, const ParserChar*, bool& )
 
1130
)
 
1131
{
 
1132
    return Utils::toEnum<ENUM__fx_opaque_enum, StringHash, ENUM__fx_opaque_enum__COUNT>(buffer, bufferEnd, failed, enumMap, baseConversionFunc);
 
1133
}
 
1134
 
 
1135
 
 
1136
 
 
1137
} // namespace