← Back to branch summary

~oem-solutions-group/unity-2d/clutter-1.0

« back to all changes in this revision

Viewing changes to clutter/cogl/cogl/cogl-enum-types.c

  • Committer: Bazaar Package Importer
  • Author(s): Emilio Pozuelo Monfort
  • Date: 2010-03-21 13:27:56 UTC
  • mto: (2.1.3 experimental)
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20100321132756-nf8yd30yxo3zzwcm
Tags: upstream-1.2.2
Import upstream version 1.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
clutter/cogl/cogl/cogl-enum-types.c
 
1
 
 
2
/* Generated data (by glib-mkenums) */
 
3
 
 
4
#include "cogl-enum-types.h"
 
5
#include "cogl.h"
 
6
 
 
7
/* enumerations from "./cogl-buffer.h" */
 
8
#include "./cogl-buffer.h"
 
9
 
 
10
GType
 
11
cogl_buffer_usage_hint_get_type (void)
 
12
{
 
13
  static volatile gsize g_enum_type_id__volatile = 0;
 
14
 
 
15
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
16
    {
 
17
      static const GEnumValue values[] = {
 
18
        { COGL_BUFFER_USAGE_HINT_TEXTURE, "COGL_BUFFER_USAGE_HINT_TEXTURE", "texture" },
 
19
        { 0, NULL, NULL }
 
20
      };
 
21
      GType g_enum_type_id;
 
22
 
 
23
      g_enum_type_id =
 
24
        g_enum_register_static (g_intern_static_string ("CoglBufferUsageHint"), values);
 
25
 
 
26
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
27
    }
 
28
 
 
29
  return g_enum_type_id__volatile;
 
30
}
 
31
GType
 
32
cogl_buffer_update_hint_get_type (void)
 
33
{
 
34
  static volatile gsize g_enum_type_id__volatile = 0;
 
35
 
 
36
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
37
    {
 
38
      static const GEnumValue values[] = {
 
39
        { COGL_BUFFER_UPDATE_HINT_STATIC, "COGL_BUFFER_UPDATE_HINT_STATIC", "static" },
 
40
        { COGL_BUFFER_UPDATE_HINT_DYNAMIC, "COGL_BUFFER_UPDATE_HINT_DYNAMIC", "dynamic" },
 
41
        { COGL_BUFFER_UPDATE_HINT_STREAM, "COGL_BUFFER_UPDATE_HINT_STREAM", "stream" },
 
42
        { 0, NULL, NULL }
 
43
      };
 
44
      GType g_enum_type_id;
 
45
 
 
46
      g_enum_type_id =
 
47
        g_enum_register_static (g_intern_static_string ("CoglBufferUpdateHint"), values);
 
48
 
 
49
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
50
    }
 
51
 
 
52
  return g_enum_type_id__volatile;
 
53
}
 
54
GType
 
55
cogl_buffer_access_get_type (void)
 
56
{
 
57
  static volatile gsize g_enum_type_id__volatile = 0;
 
58
 
 
59
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
60
    {
 
61
      static const GFlagsValue values[] = {
 
62
        { COGL_BUFFER_ACCESS_READ, "COGL_BUFFER_ACCESS_READ", "read" },
 
63
        { COGL_BUFFER_ACCESS_WRITE, "COGL_BUFFER_ACCESS_WRITE", "write" },
 
64
        { COGL_BUFFER_ACCESS_READ_WRITE, "COGL_BUFFER_ACCESS_READ_WRITE", "read-write" },
 
65
        { COGL_BUFFER_ACCESS_WRITE, "COGL_BUFFER_ACCESS_WRITE", "write" },
 
66
        { 0, NULL, NULL }
 
67
      };
 
68
      GType g_enum_type_id;
 
69
 
 
70
      g_enum_type_id =
 
71
        g_flags_register_static (g_intern_static_string ("CoglBufferAccess"), values);
 
72
 
 
73
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
74
    }
 
75
 
 
76
  return g_enum_type_id__volatile;
 
77
}
 
78
 
 
79
/* enumerations from "./cogl-debug.h" */
 
80
#include "./cogl-debug.h"
 
81
 
 
82
GType
 
83
cogl_debug_flags_get_type (void)
 
84
{
 
85
  static volatile gsize g_enum_type_id__volatile = 0;
 
86
 
 
87
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
88
    {
 
89
      static const GFlagsValue values[] = {
 
90
        { COGL_DEBUG_SLICING, "COGL_DEBUG_SLICING", "slicing" },
 
91
        { COGL_DEBUG_OFFSCREEN, "COGL_DEBUG_OFFSCREEN", "offscreen" },
 
92
        { COGL_DEBUG_DRAW, "COGL_DEBUG_DRAW", "draw" },
 
93
        { COGL_DEBUG_PANGO, "COGL_DEBUG_PANGO", "pango" },
 
94
        { COGL_DEBUG_RECTANGLES, "COGL_DEBUG_RECTANGLES", "rectangles" },
 
95
        { COGL_DEBUG_HANDLE, "COGL_DEBUG_HANDLE", "handle" },
 
96
        { COGL_DEBUG_BLEND_STRINGS, "COGL_DEBUG_BLEND_STRINGS", "blend-strings" },
 
97
        { COGL_DEBUG_DISABLE_BATCHING, "COGL_DEBUG_DISABLE_BATCHING", "disable-batching" },
 
98
        { COGL_DEBUG_DISABLE_VBOS, "COGL_DEBUG_DISABLE_VBOS", "disable-vbos" },
 
99
        { COGL_DEBUG_JOURNAL, "COGL_DEBUG_JOURNAL", "journal" },
 
100
        { COGL_DEBUG_BATCHING, "COGL_DEBUG_BATCHING", "batching" },
 
101
        { COGL_DEBUG_DISABLE_SOFTWARE_TRANSFORM, "COGL_DEBUG_DISABLE_SOFTWARE_TRANSFORM", "disable-software-transform" },
 
102
        { COGL_DEBUG_MATRICES, "COGL_DEBUG_MATRICES", "matrices" },
 
103
        { COGL_DEBUG_FORCE_SCANLINE_PATHS, "COGL_DEBUG_FORCE_SCANLINE_PATHS", "force-scanline-paths" },
 
104
        { COGL_DEBUG_ATLAS, "COGL_DEBUG_ATLAS", "atlas" },
 
105
        { COGL_DEBUG_DUMP_ATLAS_IMAGE, "COGL_DEBUG_DUMP_ATLAS_IMAGE", "dump-atlas-image" },
 
106
        { COGL_DEBUG_DISABLE_ATLAS, "COGL_DEBUG_DISABLE_ATLAS", "disable-atlas" },
 
107
        { COGL_DEBUG_OPENGL, "COGL_DEBUG_OPENGL", "opengl" },
 
108
        { 0, NULL, NULL }
 
109
      };
 
110
      GType g_enum_type_id;
 
111
 
 
112
      g_enum_type_id =
 
113
        g_flags_register_static (g_intern_static_string ("CoglDebugFlags"), values);
 
114
 
 
115
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
116
    }
 
117
 
 
118
  return g_enum_type_id__volatile;
 
119
}
 
120
 
 
121
/* enumerations from "./cogl-material.h" */
 
122
#include "./cogl-material.h"
 
123
 
 
124
GType
 
125
cogl_material_filter_get_type (void)
 
126
{
 
127
  static volatile gsize g_enum_type_id__volatile = 0;
 
128
 
 
129
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
130
    {
 
131
      static const GEnumValue values[] = {
 
132
        { COGL_MATERIAL_FILTER_NEAREST, "COGL_MATERIAL_FILTER_NEAREST", "nearest" },
 
133
        { COGL_MATERIAL_FILTER_LINEAR, "COGL_MATERIAL_FILTER_LINEAR", "linear" },
 
134
        { COGL_MATERIAL_FILTER_NEAREST_MIPMAP_NEAREST, "COGL_MATERIAL_FILTER_NEAREST_MIPMAP_NEAREST", "nearest-mipmap-nearest" },
 
135
        { COGL_MATERIAL_FILTER_LINEAR_MIPMAP_NEAREST, "COGL_MATERIAL_FILTER_LINEAR_MIPMAP_NEAREST", "linear-mipmap-nearest" },
 
136
        { COGL_MATERIAL_FILTER_NEAREST_MIPMAP_LINEAR, "COGL_MATERIAL_FILTER_NEAREST_MIPMAP_LINEAR", "nearest-mipmap-linear" },
 
137
        { COGL_MATERIAL_FILTER_LINEAR_MIPMAP_LINEAR, "COGL_MATERIAL_FILTER_LINEAR_MIPMAP_LINEAR", "linear-mipmap-linear" },
 
138
        { 0, NULL, NULL }
 
139
      };
 
140
      GType g_enum_type_id;
 
141
 
 
142
      g_enum_type_id =
 
143
        g_enum_register_static (g_intern_static_string ("CoglMaterialFilter"), values);
 
144
 
 
145
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
146
    }
 
147
 
 
148
  return g_enum_type_id__volatile;
 
149
}
 
150
GType
 
151
cogl_material_alpha_func_get_type (void)
 
152
{
 
153
  static volatile gsize g_enum_type_id__volatile = 0;
 
154
 
 
155
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
156
    {
 
157
      static const GEnumValue values[] = {
 
158
        { COGL_MATERIAL_ALPHA_FUNC_NEVER, "COGL_MATERIAL_ALPHA_FUNC_NEVER", "never" },
 
159
        { COGL_MATERIAL_ALPHA_FUNC_LESS, "COGL_MATERIAL_ALPHA_FUNC_LESS", "less" },
 
160
        { COGL_MATERIAL_ALPHA_FUNC_EQUAL, "COGL_MATERIAL_ALPHA_FUNC_EQUAL", "equal" },
 
161
        { COGL_MATERIAL_ALPHA_FUNC_LEQUAL, "COGL_MATERIAL_ALPHA_FUNC_LEQUAL", "lequal" },
 
162
        { COGL_MATERIAL_ALPHA_FUNC_GREATER, "COGL_MATERIAL_ALPHA_FUNC_GREATER", "greater" },
 
163
        { COGL_MATERIAL_ALPHA_FUNC_NOTEQUAL, "COGL_MATERIAL_ALPHA_FUNC_NOTEQUAL", "notequal" },
 
164
        { COGL_MATERIAL_ALPHA_FUNC_GEQUAL, "COGL_MATERIAL_ALPHA_FUNC_GEQUAL", "gequal" },
 
165
        { COGL_MATERIAL_ALPHA_FUNC_ALWAYS, "COGL_MATERIAL_ALPHA_FUNC_ALWAYS", "always" },
 
166
        { 0, NULL, NULL }
 
167
      };
 
168
      GType g_enum_type_id;
 
169
 
 
170
      g_enum_type_id =
 
171
        g_enum_register_static (g_intern_static_string ("CoglMaterialAlphaFunc"), values);
 
172
 
 
173
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
174
    }
 
175
 
 
176
  return g_enum_type_id__volatile;
 
177
}
 
178
GType
 
179
cogl_material_layer_type_get_type (void)
 
180
{
 
181
  static volatile gsize g_enum_type_id__volatile = 0;
 
182
 
 
183
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
184
    {
 
185
      static const GEnumValue values[] = {
 
186
        { COGL_MATERIAL_LAYER_TYPE_TEXTURE, "COGL_MATERIAL_LAYER_TYPE_TEXTURE", "texture" },
 
187
        { 0, NULL, NULL }
 
188
      };
 
189
      GType g_enum_type_id;
 
190
 
 
191
      g_enum_type_id =
 
192
        g_enum_register_static (g_intern_static_string ("CoglMaterialLayerType"), values);
 
193
 
 
194
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
195
    }
 
196
 
 
197
  return g_enum_type_id__volatile;
 
198
}
 
199
 
 
200
/* enumerations from "./cogl-shader.h" */
 
201
#include "./cogl-shader.h"
 
202
 
 
203
GType
 
204
cogl_shader_type_get_type (void)
 
205
{
 
206
  static volatile gsize g_enum_type_id__volatile = 0;
 
207
 
 
208
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
209
    {
 
210
      static const GEnumValue values[] = {
 
211
        { COGL_SHADER_TYPE_VERTEX, "COGL_SHADER_TYPE_VERTEX", "vertex" },
 
212
        { COGL_SHADER_TYPE_FRAGMENT, "COGL_SHADER_TYPE_FRAGMENT", "fragment" },
 
213
        { 0, NULL, NULL }
 
214
      };
 
215
      GType g_enum_type_id;
 
216
 
 
217
      g_enum_type_id =
 
218
        g_enum_register_static (g_intern_static_string ("CoglShaderType"), values);
 
219
 
 
220
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
221
    }
 
222
 
 
223
  return g_enum_type_id__volatile;
 
224
}
 
225
 
 
226
/* enumerations from "./cogl-types.h" */
 
227
#include "./cogl-types.h"
 
228
 
 
229
GType
 
230
cogl_pixel_format_get_type (void)
 
231
{
 
232
  static volatile gsize g_enum_type_id__volatile = 0;
 
233
 
 
234
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
235
    {
 
236
      static const GEnumValue values[] = {
 
237
        { COGL_PIXEL_FORMAT_ANY, "COGL_PIXEL_FORMAT_ANY", "any" },
 
238
        { COGL_PIXEL_FORMAT_A_8, "COGL_PIXEL_FORMAT_A_8", "a-8" },
 
239
        { COGL_PIXEL_FORMAT_RGB_565, "COGL_PIXEL_FORMAT_RGB_565", "rgb-565" },
 
240
        { COGL_PIXEL_FORMAT_RGBA_4444, "COGL_PIXEL_FORMAT_RGBA_4444", "rgba-4444" },
 
241
        { COGL_PIXEL_FORMAT_RGBA_5551, "COGL_PIXEL_FORMAT_RGBA_5551", "rgba-5551" },
 
242
        { COGL_PIXEL_FORMAT_YUV, "COGL_PIXEL_FORMAT_YUV", "yuv" },
 
243
        { COGL_PIXEL_FORMAT_G_8, "COGL_PIXEL_FORMAT_G_8", "g-8" },
 
244
        { COGL_PIXEL_FORMAT_RGB_888, "COGL_PIXEL_FORMAT_RGB_888", "rgb-888" },
 
245
        { COGL_PIXEL_FORMAT_BGR_888, "COGL_PIXEL_FORMAT_BGR_888", "bgr-888" },
 
246
        { COGL_PIXEL_FORMAT_RGBA_8888, "COGL_PIXEL_FORMAT_RGBA_8888", "rgba-8888" },
 
247
        { COGL_PIXEL_FORMAT_BGRA_8888, "COGL_PIXEL_FORMAT_BGRA_8888", "bgra-8888" },
 
248
        { COGL_PIXEL_FORMAT_ARGB_8888, "COGL_PIXEL_FORMAT_ARGB_8888", "argb-8888" },
 
249
        { COGL_PIXEL_FORMAT_ABGR_8888, "COGL_PIXEL_FORMAT_ABGR_8888", "abgr-8888" },
 
250
        { COGL_PIXEL_FORMAT_RGBA_8888_PRE, "COGL_PIXEL_FORMAT_RGBA_8888_PRE", "rgba-8888-pre" },
 
251
        { COGL_PIXEL_FORMAT_BGRA_8888_PRE, "COGL_PIXEL_FORMAT_BGRA_8888_PRE", "bgra-8888-pre" },
 
252
        { COGL_PIXEL_FORMAT_ARGB_8888_PRE, "COGL_PIXEL_FORMAT_ARGB_8888_PRE", "argb-8888-pre" },
 
253
        { COGL_PIXEL_FORMAT_ABGR_8888_PRE, "COGL_PIXEL_FORMAT_ABGR_8888_PRE", "abgr-8888-pre" },
 
254
        { COGL_PIXEL_FORMAT_RGBA_4444_PRE, "COGL_PIXEL_FORMAT_RGBA_4444_PRE", "rgba-4444-pre" },
 
255
        { COGL_PIXEL_FORMAT_RGBA_5551_PRE, "COGL_PIXEL_FORMAT_RGBA_5551_PRE", "rgba-5551-pre" },
 
256
        { 0, NULL, NULL }
 
257
      };
 
258
      GType g_enum_type_id;
 
259
 
 
260
      g_enum_type_id =
 
261
        g_enum_register_static (g_intern_static_string ("CoglPixelFormat"), values);
 
262
 
 
263
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
264
    }
 
265
 
 
266
  return g_enum_type_id__volatile;
 
267
}
 
268
GType
 
269
cogl_feature_flags_get_type (void)
 
270
{
 
271
  static volatile gsize g_enum_type_id__volatile = 0;
 
272
 
 
273
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
274
    {
 
275
      static const GFlagsValue values[] = {
 
276
        { COGL_FEATURE_TEXTURE_RECTANGLE, "COGL_FEATURE_TEXTURE_RECTANGLE", "texture-rectangle" },
 
277
        { COGL_FEATURE_TEXTURE_NPOT, "COGL_FEATURE_TEXTURE_NPOT", "texture-npot" },
 
278
        { COGL_FEATURE_TEXTURE_YUV, "COGL_FEATURE_TEXTURE_YUV", "texture-yuv" },
 
279
        { COGL_FEATURE_TEXTURE_READ_PIXELS, "COGL_FEATURE_TEXTURE_READ_PIXELS", "texture-read-pixels" },
 
280
        { COGL_FEATURE_SHADERS_GLSL, "COGL_FEATURE_SHADERS_GLSL", "shaders-glsl" },
 
281
        { COGL_FEATURE_OFFSCREEN, "COGL_FEATURE_OFFSCREEN", "offscreen" },
 
282
        { COGL_FEATURE_OFFSCREEN_MULTISAMPLE, "COGL_FEATURE_OFFSCREEN_MULTISAMPLE", "offscreen-multisample" },
 
283
        { COGL_FEATURE_OFFSCREEN_BLIT, "COGL_FEATURE_OFFSCREEN_BLIT", "offscreen-blit" },
 
284
        { COGL_FEATURE_FOUR_CLIP_PLANES, "COGL_FEATURE_FOUR_CLIP_PLANES", "four-clip-planes" },
 
285
        { COGL_FEATURE_STENCIL_BUFFER, "COGL_FEATURE_STENCIL_BUFFER", "stencil-buffer" },
 
286
        { COGL_FEATURE_VBOS, "COGL_FEATURE_VBOS", "vbos" },
 
287
        { COGL_FEATURE_PBOS, "COGL_FEATURE_PBOS", "pbos" },
 
288
        { COGL_FEATURE_UNSIGNED_INT_INDICES, "COGL_FEATURE_UNSIGNED_INT_INDICES", "unsigned-int-indices" },
 
289
        { 0, NULL, NULL }
 
290
      };
 
291
      GType g_enum_type_id;
 
292
 
 
293
      g_enum_type_id =
 
294
        g_flags_register_static (g_intern_static_string ("CoglFeatureFlags"), values);
 
295
 
 
296
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
297
    }
 
298
 
 
299
  return g_enum_type_id__volatile;
 
300
}
 
301
GType
 
302
cogl_buffer_target_get_type (void)
 
303
{
 
304
  static volatile gsize g_enum_type_id__volatile = 0;
 
305
 
 
306
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
307
    {
 
308
      static const GFlagsValue values[] = {
 
309
        { COGL_WINDOW_BUFFER, "COGL_WINDOW_BUFFER", "window-buffer" },
 
310
        { COGL_OFFSCREEN_BUFFER, "COGL_OFFSCREEN_BUFFER", "offscreen-buffer" },
 
311
        { 0, NULL, NULL }
 
312
      };
 
313
      GType g_enum_type_id;
 
314
 
 
315
      g_enum_type_id =
 
316
        g_flags_register_static (g_intern_static_string ("CoglBufferTarget"), values);
 
317
 
 
318
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
319
    }
 
320
 
 
321
  return g_enum_type_id__volatile;
 
322
}
 
323
GType
 
324
cogl_texture_flags_get_type (void)
 
325
{
 
326
  static volatile gsize g_enum_type_id__volatile = 0;
 
327
 
 
328
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
329
    {
 
330
      static const GFlagsValue values[] = {
 
331
        { COGL_TEXTURE_NONE, "COGL_TEXTURE_NONE", "none" },
 
332
        { COGL_TEXTURE_NO_AUTO_MIPMAP, "COGL_TEXTURE_NO_AUTO_MIPMAP", "no-auto-mipmap" },
 
333
        { COGL_TEXTURE_NO_SLICING, "COGL_TEXTURE_NO_SLICING", "no-slicing" },
 
334
        { COGL_TEXTURE_NO_ATLAS, "COGL_TEXTURE_NO_ATLAS", "no-atlas" },
 
335
        { 0, NULL, NULL }
 
336
      };
 
337
      GType g_enum_type_id;
 
338
 
 
339
      g_enum_type_id =
 
340
        g_flags_register_static (g_intern_static_string ("CoglTextureFlags"), values);
 
341
 
 
342
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
343
    }
 
344
 
 
345
  return g_enum_type_id__volatile;
 
346
}
 
347
GType
 
348
cogl_fog_mode_get_type (void)
 
349
{
 
350
  static volatile gsize g_enum_type_id__volatile = 0;
 
351
 
 
352
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
353
    {
 
354
      static const GEnumValue values[] = {
 
355
        { COGL_FOG_MODE_LINEAR, "COGL_FOG_MODE_LINEAR", "linear" },
 
356
        { COGL_FOG_MODE_EXPONENTIAL, "COGL_FOG_MODE_EXPONENTIAL", "exponential" },
 
357
        { COGL_FOG_MODE_EXPONENTIAL_SQUARED, "COGL_FOG_MODE_EXPONENTIAL_SQUARED", "exponential-squared" },
 
358
        { 0, NULL, NULL }
 
359
      };
 
360
      GType g_enum_type_id;
 
361
 
 
362
      g_enum_type_id =
 
363
        g_enum_register_static (g_intern_static_string ("CoglFogMode"), values);
 
364
 
 
365
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
366
    }
 
367
 
 
368
  return g_enum_type_id__volatile;
 
369
}
 
370
GType
 
371
cogl_blend_string_error_get_type (void)
 
372
{
 
373
  static volatile gsize g_enum_type_id__volatile = 0;
 
374
 
 
375
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
376
    {
 
377
      static const GEnumValue values[] = {
 
378
        { COGL_BLEND_STRING_ERROR_PARSE_ERROR, "COGL_BLEND_STRING_ERROR_PARSE_ERROR", "parse-error" },
 
379
        { COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR, "COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR", "argument-parse-error" },
 
380
        { COGL_BLEND_STRING_ERROR_INVALID_ERROR, "COGL_BLEND_STRING_ERROR_INVALID_ERROR", "invalid-error" },
 
381
        { COGL_BLEND_STRING_ERROR_GPU_UNSUPPORTED_ERROR, "COGL_BLEND_STRING_ERROR_GPU_UNSUPPORTED_ERROR", "gpu-unsupported-error" },
 
382
        { 0, NULL, NULL }
 
383
      };
 
384
      GType g_enum_type_id;
 
385
 
 
386
      g_enum_type_id =
 
387
        g_enum_register_static (g_intern_static_string ("CoglBlendStringError"), values);
 
388
 
 
389
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
390
    }
 
391
 
 
392
  return g_enum_type_id__volatile;
 
393
}
 
394
 
 
395
/* enumerations from "./cogl-vertex-buffer.h" */
 
396
#include "./cogl-vertex-buffer.h"
 
397
 
 
398
GType
 
399
cogl_attribute_type_get_type (void)
 
400
{
 
401
  static volatile gsize g_enum_type_id__volatile = 0;
 
402
 
 
403
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
404
    {
 
405
      static const GEnumValue values[] = {
 
406
        { COGL_ATTRIBUTE_TYPE_BYTE, "COGL_ATTRIBUTE_TYPE_BYTE", "byte" },
 
407
        { COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE, "COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE", "unsigned-byte" },
 
408
        { COGL_ATTRIBUTE_TYPE_SHORT, "COGL_ATTRIBUTE_TYPE_SHORT", "short" },
 
409
        { COGL_ATTRIBUTE_TYPE_UNSIGNED_SHORT, "COGL_ATTRIBUTE_TYPE_UNSIGNED_SHORT", "unsigned-short" },
 
410
        { COGL_ATTRIBUTE_TYPE_FLOAT, "COGL_ATTRIBUTE_TYPE_FLOAT", "float" },
 
411
        { 0, NULL, NULL }
 
412
      };
 
413
      GType g_enum_type_id;
 
414
 
 
415
      g_enum_type_id =
 
416
        g_enum_register_static (g_intern_static_string ("CoglAttributeType"), values);
 
417
 
 
418
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
419
    }
 
420
 
 
421
  return g_enum_type_id__volatile;
 
422
}
 
423
GType
 
424
cogl_vertices_mode_get_type (void)
 
425
{
 
426
  static volatile gsize g_enum_type_id__volatile = 0;
 
427
 
 
428
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
429
    {
 
430
      static const GEnumValue values[] = {
 
431
        { COGL_VERTICES_MODE_POINTS, "COGL_VERTICES_MODE_POINTS", "points" },
 
432
        { COGL_VERTICES_MODE_LINE_STRIP, "COGL_VERTICES_MODE_LINE_STRIP", "line-strip" },
 
433
        { COGL_VERTICES_MODE_LINE_LOOP, "COGL_VERTICES_MODE_LINE_LOOP", "line-loop" },
 
434
        { COGL_VERTICES_MODE_LINES, "COGL_VERTICES_MODE_LINES", "lines" },
 
435
        { COGL_VERTICES_MODE_TRIANGLE_STRIP, "COGL_VERTICES_MODE_TRIANGLE_STRIP", "triangle-strip" },
 
436
        { COGL_VERTICES_MODE_TRIANGLE_FAN, "COGL_VERTICES_MODE_TRIANGLE_FAN", "triangle-fan" },
 
437
        { COGL_VERTICES_MODE_TRIANGLES, "COGL_VERTICES_MODE_TRIANGLES", "triangles" },
 
438
        { 0, NULL, NULL }
 
439
      };
 
440
      GType g_enum_type_id;
 
441
 
 
442
      g_enum_type_id =
 
443
        g_enum_register_static (g_intern_static_string ("CoglVerticesMode"), values);
 
444
 
 
445
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
446
    }
 
447
 
 
448
  return g_enum_type_id__volatile;
 
449
}
 
450
GType
 
451
cogl_indices_type_get_type (void)
 
452
{
 
453
  static volatile gsize g_enum_type_id__volatile = 0;
 
454
 
 
455
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
456
    {
 
457
      static const GEnumValue values[] = {
 
458
        { COGL_INDICES_TYPE_UNSIGNED_BYTE, "COGL_INDICES_TYPE_UNSIGNED_BYTE", "byte" },
 
459
        { COGL_INDICES_TYPE_UNSIGNED_SHORT, "COGL_INDICES_TYPE_UNSIGNED_SHORT", "short" },
 
460
        { COGL_INDICES_TYPE_UNSIGNED_INT, "COGL_INDICES_TYPE_UNSIGNED_INT", "int" },
 
461
        { 0, NULL, NULL }
 
462
      };
 
463
      GType g_enum_type_id;
 
464
 
 
465
      g_enum_type_id =
 
466
        g_enum_register_static (g_intern_static_string ("CoglIndicesType"), values);
 
467
 
 
468
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
469
    }
 
470
 
 
471
  return g_enum_type_id__volatile;
 
472
}
 
473
 
 
474
/* enumerations from "./cogl.h" */
 
475
#include "./cogl.h"
 
476
 
 
477
GType
 
478
cogl_buffer_bit_get_type (void)
 
479
{
 
480
  static volatile gsize g_enum_type_id__volatile = 0;
 
481
 
 
482
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
483
    {
 
484
      static const GFlagsValue values[] = {
 
485
        { COGL_BUFFER_BIT_COLOR, "COGL_BUFFER_BIT_COLOR", "color" },
 
486
        { COGL_BUFFER_BIT_DEPTH, "COGL_BUFFER_BIT_DEPTH", "depth" },
 
487
        { COGL_BUFFER_BIT_STENCIL, "COGL_BUFFER_BIT_STENCIL", "stencil" },
 
488
        { 0, NULL, NULL }
 
489
      };
 
490
      GType g_enum_type_id;
 
491
 
 
492
      g_enum_type_id =
 
493
        g_flags_register_static (g_intern_static_string ("CoglBufferBit"), values);
 
494
 
 
495
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
496
    }
 
497
 
 
498
  return g_enum_type_id__volatile;
 
499
}
 
500
GType
 
501
cogl_read_pixels_flags_get_type (void)
 
502
{
 
503
  static volatile gsize g_enum_type_id__volatile = 0;
 
504
 
 
505
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
506
    {
 
507
      static const GFlagsValue values[] = {
 
508
        { COGL_READ_PIXELS_COLOR_BUFFER, "COGL_READ_PIXELS_COLOR_BUFFER", "color-buffer" },
 
509
        { 0, NULL, NULL }
 
510
      };
 
511
      GType g_enum_type_id;
 
512
 
 
513
      g_enum_type_id =
 
514
        g_flags_register_static (g_intern_static_string ("CoglReadPixelsFlags"), values);
 
515
 
 
516
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
517
    }
 
518
 
 
519
  return g_enum_type_id__volatile;
 
520
}
 
521
GType
 
522
cogl_driver_error_get_type (void)
 
523
{
 
524
  static volatile gsize g_enum_type_id__volatile = 0;
 
525
 
 
526
  if (g_once_init_enter (&g_enum_type_id__volatile))
 
527
    {
 
528
      static const GEnumValue values[] = {
 
529
        { COGL_DRIVER_ERROR_UNKNOWN_VERSION, "COGL_DRIVER_ERROR_UNKNOWN_VERSION", "unknown-version" },
 
530
        { COGL_DRIVER_ERROR_INVALID_VERSION, "COGL_DRIVER_ERROR_INVALID_VERSION", "invalid-version" },
 
531
        { 0, NULL, NULL }
 
532
      };
 
533
      GType g_enum_type_id;
 
534
 
 
535
      g_enum_type_id =
 
536
        g_enum_register_static (g_intern_static_string ("CoglDriverError"), values);
 
537
 
 
538
      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
 
539
    }
 
540
 
 
541
  return g_enum_type_id__volatile;
 
542
}
 
543
 
 
544
/* Generated data ends here */
 
545