← Back to branch summary

~noskcaj/ubuntu/trusty/cogl/1.16.2

« back to all changes in this revision

Viewing changes to cogl/driver/gl/gles/cogl-driver-gles.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha, Jeremy Bicha, Rico Tzschichholz
  • Date: 2013-02-26 16:43:25 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20130226164325-t4z9rylpa20v0p6q
Tags: 1.13.4-0ubuntu1
[ Jeremy Bicha ]
* New upstream release
  - soname bump
* debian/control.in:
  - Bump minimum glib to 2.32
  - Drop obsolete breaks/replaces
  - Bump libclutter-1.0-dev breaks for soname transition
* debian/libcogl-dev.install:
  - Add some missing files

[ Rico Tzschichholz ]
* debian/control.in:
  - Build-depend on libxrandr-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
cogl/driver/gl/gles/cogl-driver-gles.c
 
1
/*
 
2
 * Cogl
 
3
 *
 
4
 * An object oriented GL/GLES Abstraction/Utility Layer
 
5
 *
 
6
 * Copyright (C) 2007,2008,2009 Intel Corporation.
 
7
 *
 
8
 * This library is free software; you can redistribute it and/or
 
9
 * modify it under the terms of the GNU Lesser General Public
 
10
 * License as published by the Free Software Foundation; either
 
11
 * version 2 of the License, or (at your option) any later version.
 
12
 *
 
13
 * This library is distributed in the hope that it will be useful,
 
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
16
 * Lesser General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU Lesser General Public
 
19
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 
20
 *
 
21
 *
 
22
 */
 
23
 
 
24
#ifdef HAVE_CONFIG_H
 
25
#include "config.h"
 
26
#endif
 
27
 
 
28
#include <string.h>
 
29
 
 
30
#include "cogl-context-private.h"
 
31
#include "cogl-util-gl-private.h"
 
32
#include "cogl-feature-private.h"
 
33
#include "cogl-renderer-private.h"
 
34
#include "cogl-private.h"
 
35
#include "cogl-framebuffer-gl-private.h"
 
36
#include "cogl-texture-2d-gl-private.h"
 
37
#include "cogl-attribute-gl-private.h"
 
38
#include "cogl-clip-stack-gl-private.h"
 
39
#include "cogl-buffer-gl-private.h"
 
40
 
 
41
#ifndef GL_UNSIGNED_INT_24_8
 
42
#define GL_UNSIGNED_INT_24_8 0x84FA
 
43
#endif
 
44
#ifndef GL_DEPTH_STENCIL
 
45
#define GL_DEPTH_STENCIL 0x84F9
 
46
#endif
 
47
 
 
48
static CoglBool
 
49
_cogl_driver_pixel_format_from_gl_internal (CoglContext *context,
 
50
                                            GLenum gl_int_format,
 
51
                                            CoglPixelFormat *out_format)
 
52
{
 
53
  return TRUE;
 
54
}
 
55
 
 
56
static CoglPixelFormat
 
57
_cogl_driver_pixel_format_to_gl (CoglContext *context,
 
58
                                 CoglPixelFormat  format,
 
59
                                 GLenum *out_glintformat,
 
60
                                 GLenum *out_glformat,
 
61
                                 GLenum *out_gltype)
 
62
{
 
63
  CoglPixelFormat required_format;
 
64
  GLenum glintformat;
 
65
  GLenum glformat = 0;
 
66
  GLenum gltype;
 
67
 
 
68
  required_format = format;
 
69
 
 
70
  /* Find GL equivalents */
 
71
  switch (format)
 
72
    {
 
73
    case COGL_PIXEL_FORMAT_A_8:
 
74
      glintformat = GL_ALPHA;
 
75
      glformat = GL_ALPHA;
 
76
      gltype = GL_UNSIGNED_BYTE;
 
77
      break;
 
78
    case COGL_PIXEL_FORMAT_G_8:
 
79
      glintformat = GL_LUMINANCE;
 
80
      glformat = GL_LUMINANCE;
 
81
      gltype = GL_UNSIGNED_BYTE;
 
82
      break;
 
83
 
 
84
    case COGL_PIXEL_FORMAT_BGRA_8888:
 
85
    case COGL_PIXEL_FORMAT_BGRA_8888_PRE:
 
86
      /* There is an extension to support this format */
 
87
      if ((context->private_feature_flags &
 
88
           COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888))
 
89
        {
 
90
          /* For some reason the extension says you have to specify
 
91
             BGRA for the internal format too */
 
92
          glintformat = GL_BGRA_EXT;
 
93
          glformat = GL_BGRA_EXT;
 
94
          gltype = GL_UNSIGNED_BYTE;
 
95
          required_format = format;
 
96
          break;
 
97
        }
 
98
      /* flow through */
 
99
 
 
100
      /* Just one 24-bit ordering supported */
 
101
    case COGL_PIXEL_FORMAT_RGB_888:
 
102
    case COGL_PIXEL_FORMAT_BGR_888:
 
103
      glintformat = GL_RGB;
 
104
      glformat = GL_RGB;
 
105
      gltype = GL_UNSIGNED_BYTE;
 
106
      required_format = COGL_PIXEL_FORMAT_RGB_888;
 
107
      break;
 
108
 
 
109
      /* Just one 32-bit ordering supported */
 
110
    case COGL_PIXEL_FORMAT_RGBA_8888:
 
111
    case COGL_PIXEL_FORMAT_RGBA_8888_PRE:
 
112
    case COGL_PIXEL_FORMAT_ARGB_8888:
 
113
    case COGL_PIXEL_FORMAT_ARGB_8888_PRE:
 
114
    case COGL_PIXEL_FORMAT_ABGR_8888:
 
115
    case COGL_PIXEL_FORMAT_ABGR_8888_PRE:
 
116
    case COGL_PIXEL_FORMAT_RGBA_1010102:
 
117
    case COGL_PIXEL_FORMAT_RGBA_1010102_PRE:
 
118
    case COGL_PIXEL_FORMAT_BGRA_1010102:
 
119
    case COGL_PIXEL_FORMAT_BGRA_1010102_PRE:
 
120
    case COGL_PIXEL_FORMAT_ABGR_2101010:
 
121
    case COGL_PIXEL_FORMAT_ABGR_2101010_PRE:
 
122
    case COGL_PIXEL_FORMAT_ARGB_2101010:
 
123
    case COGL_PIXEL_FORMAT_ARGB_2101010_PRE:
 
124
      glintformat = GL_RGBA;
 
125
      glformat = GL_RGBA;
 
126
      gltype = GL_UNSIGNED_BYTE;
 
127
      required_format = COGL_PIXEL_FORMAT_RGBA_8888;
 
128
      required_format |= (format & COGL_PREMULT_BIT);
 
129
      break;
 
130
 
 
131
      /* The following three types of channel ordering
 
132
       * are always defined using system word byte
 
133
       * ordering (even according to GLES spec) */
 
134
    case COGL_PIXEL_FORMAT_RGB_565:
 
135
      glintformat = GL_RGB;
 
136
      glformat = GL_RGB;
 
137
      gltype = GL_UNSIGNED_SHORT_5_6_5;
 
138
      break;
 
139
    case COGL_PIXEL_FORMAT_RGBA_4444:
 
140
    case COGL_PIXEL_FORMAT_RGBA_4444_PRE:
 
141
      glintformat = GL_RGBA;
 
142
      glformat = GL_RGBA;
 
143
      gltype = GL_UNSIGNED_SHORT_4_4_4_4;
 
144
      break;
 
145
    case COGL_PIXEL_FORMAT_RGBA_5551:
 
146
    case COGL_PIXEL_FORMAT_RGBA_5551_PRE:
 
147
      glintformat = GL_RGBA;
 
148
      glformat = GL_RGBA;
 
149
      gltype = GL_UNSIGNED_SHORT_5_5_5_1;
 
150
      break;
 
151
 
 
152
    case COGL_PIXEL_FORMAT_DEPTH_16:
 
153
      glintformat = GL_DEPTH_COMPONENT;
 
154
      glformat = GL_DEPTH_COMPONENT;
 
155
      gltype = GL_UNSIGNED_SHORT;
 
156
      break;
 
157
    case COGL_PIXEL_FORMAT_DEPTH_32:
 
158
      glintformat = GL_DEPTH_COMPONENT;
 
159
      glformat = GL_DEPTH_COMPONENT;
 
160
      gltype = GL_UNSIGNED_INT;
 
161
      break;
 
162
 
 
163
    case COGL_PIXEL_FORMAT_DEPTH_24_STENCIL_8:
 
164
      glintformat = GL_DEPTH_STENCIL;
 
165
      glformat = GL_DEPTH_STENCIL;
 
166
      gltype = GL_UNSIGNED_INT_24_8;
 
167
      break;
 
168
 
 
169
    case COGL_PIXEL_FORMAT_ANY:
 
170
    case COGL_PIXEL_FORMAT_YUV:
 
171
      g_assert_not_reached ();
 
172
      break;
 
173
    }
 
174
 
 
175
  /* All of the pixel formats are handled above so if this hits then
 
176
     we've been given an invalid pixel format */
 
177
  g_assert (glformat != 0);
 
178
 
 
179
  if (out_glintformat != NULL)
 
180
    *out_glintformat = glintformat;
 
181
  if (out_glformat != NULL)
 
182
    *out_glformat = glformat;
 
183
  if (out_gltype != NULL)
 
184
    *out_gltype = gltype;
 
185
 
 
186
  return required_format;
 
187
}
 
188
 
 
189
static CoglBool
 
190
_cogl_driver_update_features (CoglContext *context,
 
191
                              CoglError **error)
 
192
{
 
193
  CoglPrivateFeatureFlags private_flags = 0;
 
194
  CoglFeatureFlags flags = 0;
 
195
  char **gl_extensions;
 
196
 
 
197
  /* We have to special case getting the pointer to the glGetString
 
198
     function because we need to use it to determine what functions we
 
199
     can expect */
 
200
  context->glGetString =
 
201
    (void *) _cogl_renderer_get_proc_address (context->display->renderer,
 
202
                                              "glGetString",
 
203
                                              TRUE);
 
204
 
 
205
  gl_extensions = _cogl_context_get_gl_extensions (context);
 
206
 
 
207
  if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_WINSYS)))
 
208
    {
 
209
      char *all_extensions = g_strjoinv (" ", gl_extensions);
 
210
 
 
211
      COGL_NOTE (WINSYS,
 
212
                 "Checking features\n"
 
213
                 "  GL_VENDOR: %s\n"
 
214
                 "  GL_RENDERER: %s\n"
 
215
                 "  GL_VERSION: %s\n"
 
216
                 "  GL_EXTENSIONS: %s",
 
217
                 context->glGetString (GL_VENDOR),
 
218
                 context->glGetString (GL_RENDERER),
 
219
                 _cogl_context_get_gl_version (context),
 
220
                 all_extensions);
 
221
 
 
222
      g_free (all_extensions);
 
223
    }
 
224
 
 
225
  context->glsl_major = 1;
 
226
  context->glsl_minor = 0;
 
227
 
 
228
  _cogl_gpu_info_init (context, &context->gpu);
 
229
 
 
230
  _cogl_feature_check_ext_functions (context,
 
231
                                     -1 /* GL major version */,
 
232
                                     -1 /* GL minor version */,
 
233
                                     gl_extensions);
 
234
 
 
235
#ifdef HAVE_COGL_GLES
 
236
  if (context->driver == COGL_DRIVER_GLES1)
 
237
    {
 
238
      int max_clip_planes;
 
239
      GE( context, glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) );
 
240
      if (max_clip_planes >= 4)
 
241
        private_flags |= COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES;
 
242
    }
 
243
#endif
 
244
 
 
245
  if (context->driver == COGL_DRIVER_GLES2)
 
246
    {
 
247
      flags |= COGL_FEATURE_SHADERS_GLSL | COGL_FEATURE_OFFSCREEN;
 
248
      /* Note GLES 2 core doesn't support mipmaps for npot textures or
 
249
       * repeat modes other than CLAMP_TO_EDGE. */
 
250
      flags |= COGL_FEATURE_TEXTURE_NPOT_BASIC;
 
251
      flags |= COGL_FEATURE_DEPTH_RANGE;
 
252
      COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_GLSL, TRUE);
 
253
      COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_OFFSCREEN, TRUE);
 
254
      COGL_FLAGS_SET (context->features,
 
255
                      COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
 
256
      COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_DEPTH_RANGE, TRUE);
 
257
      COGL_FLAGS_SET (context->features,
 
258
                      COGL_FEATURE_ID_MIRRORED_REPEAT, TRUE);
 
259
 
 
260
      private_flags |= COGL_PRIVATE_FEATURE_BLEND_CONSTANT;
 
261
    }
 
262
  else if (context->driver == COGL_DRIVER_GLES1)
 
263
    private_flags |= (COGL_PRIVATE_FEATURE_FIXED_FUNCTION |
 
264
                      COGL_PRIVATE_FEATURE_ALPHA_TEST |
 
265
                      COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM);
 
266
 
 
267
  private_flags |= (COGL_PRIVATE_FEATURE_VBOS |
 
268
                    COGL_PRIVATE_FEATURE_ANY_GL |
 
269
                    COGL_PRIVATE_FEATURE_ALPHA_TEXTURES);
 
270
 
 
271
  /* Both GLES 1.1 and GLES 2.0 support point sprites in core */
 
272
  flags |= COGL_FEATURE_POINT_SPRITE;
 
273
  COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_POINT_SPRITE, TRUE);
 
274
 
 
275
  if (context->glGenRenderbuffers)
 
276
    {
 
277
      flags |= COGL_FEATURE_OFFSCREEN;
 
278
      COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_OFFSCREEN, TRUE);
 
279
    }
 
280
 
 
281
  if (context->glBlitFramebuffer)
 
282
    private_flags |= COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT;
 
283
 
 
284
  if (_cogl_check_extension ("GL_OES_element_index_uint", gl_extensions))
 
285
    {
 
286
      flags |= COGL_FEATURE_UNSIGNED_INT_INDICES;
 
287
      COGL_FLAGS_SET (context->features,
 
288
                      COGL_FEATURE_ID_UNSIGNED_INT_INDICES, TRUE);
 
289
    }
 
290
 
 
291
  if (_cogl_check_extension ("GL_OES_depth_texture", gl_extensions))
 
292
    {
 
293
      flags |= COGL_FEATURE_DEPTH_TEXTURE;
 
294
      COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_DEPTH_TEXTURE, TRUE);
 
295
    }
 
296
 
 
297
  if (_cogl_check_extension ("GL_OES_texture_npot", gl_extensions))
 
298
    {
 
299
      flags |= (COGL_FEATURE_TEXTURE_NPOT |
 
300
                COGL_FEATURE_TEXTURE_NPOT_BASIC |
 
301
                COGL_FEATURE_TEXTURE_NPOT_MIPMAP |
 
302
                COGL_FEATURE_TEXTURE_NPOT_REPEAT);
 
303
      COGL_FLAGS_SET (context->features,
 
304
                      COGL_FEATURE_ID_TEXTURE_NPOT, TRUE);
 
305
      COGL_FLAGS_SET (context->features,
 
306
                      COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
 
307
      COGL_FLAGS_SET (context->features,
 
308
                      COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE);
 
309
      COGL_FLAGS_SET (context->features,
 
310
                      COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT, TRUE);
 
311
    }
 
312
  else if (_cogl_check_extension ("GL_IMG_texture_npot", gl_extensions))
 
313
    {
 
314
      flags |= (COGL_FEATURE_TEXTURE_NPOT_BASIC |
 
315
                COGL_FEATURE_TEXTURE_NPOT_MIPMAP);
 
316
      COGL_FLAGS_SET (context->features,
 
317
                      COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
 
318
      COGL_FLAGS_SET (context->features,
 
319
                      COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE);
 
320
    }
 
321
 
 
322
  if (context->glTexImage3D)
 
323
    {
 
324
      flags |= COGL_FEATURE_TEXTURE_3D;
 
325
      COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_3D, TRUE);
 
326
    }
 
327
 
 
328
  if (context->glMapBuffer)
 
329
    {
 
330
      /* The GL_OES_mapbuffer extension doesn't support mapping for
 
331
         read */
 
332
      flags |= COGL_FEATURE_MAP_BUFFER_FOR_WRITE;
 
333
      COGL_FLAGS_SET (context->features,
 
334
                      COGL_FEATURE_ID_MAP_BUFFER_FOR_WRITE, TRUE);
 
335
    }
 
336
 
 
337
  if (context->glEGLImageTargetTexture2D)
 
338
    private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE;
 
339
 
 
340
  if (_cogl_check_extension ("GL_OES_packed_depth_stencil", gl_extensions))
 
341
    private_flags |= COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL;
 
342
 
 
343
  if (_cogl_check_extension ("GL_EXT_texture_format_BGRA8888", gl_extensions))
 
344
    private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888;
 
345
 
 
346
  if (_cogl_check_extension ("GL_EXT_unpack_subimage", gl_extensions))
 
347
    private_flags |= COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE;
 
348
 
 
349
  /* Cache features */
 
350
  context->private_feature_flags |= private_flags;
 
351
  context->feature_flags |= flags;
 
352
 
 
353
  g_strfreev (gl_extensions);
 
354
 
 
355
  return TRUE;
 
356
}
 
357
 
 
358
const CoglDriverVtable
 
359
_cogl_driver_gles =
 
360
  {
 
361
    _cogl_driver_pixel_format_from_gl_internal,
 
362
    _cogl_driver_pixel_format_to_gl,
 
363
    _cogl_driver_update_features,
 
364
    _cogl_offscreen_gl_allocate,
 
365
    _cogl_offscreen_gl_free,
 
366
    _cogl_framebuffer_gl_flush_state,
 
367
    _cogl_framebuffer_gl_clear,
 
368
    _cogl_framebuffer_gl_query_bits,
 
369
    _cogl_framebuffer_gl_finish,
 
370
    _cogl_framebuffer_gl_discard_buffers,
 
371
    _cogl_framebuffer_gl_draw_attributes,
 
372
    _cogl_framebuffer_gl_draw_indexed_attributes,
 
373
    _cogl_framebuffer_gl_read_pixels_into_bitmap,
 
374
    _cogl_texture_2d_gl_free,
 
375
    _cogl_texture_2d_gl_can_create,
 
376
    _cogl_texture_2d_gl_init,
 
377
    _cogl_texture_2d_gl_allocate,
 
378
    _cogl_texture_2d_gl_new_from_bitmap,
 
379
#if defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base)
 
380
    _cogl_egl_texture_2d_gl_new_from_image,
 
381
#endif
 
382
    _cogl_texture_2d_gl_copy_from_framebuffer,
 
383
    _cogl_texture_2d_gl_get_gl_handle,
 
384
    _cogl_texture_2d_gl_generate_mipmap,
 
385
    _cogl_texture_2d_gl_copy_from_bitmap,
 
386
    NULL, /* texture_2d_get_data */
 
387
    _cogl_gl_flush_attributes_state,
 
388
    _cogl_clip_stack_gl_flush,
 
389
    _cogl_buffer_gl_create,
 
390
    _cogl_buffer_gl_destroy,
 
391
    _cogl_buffer_gl_map_range,
 
392
    _cogl_buffer_gl_unmap,
 
393
    _cogl_buffer_gl_set_data,
 
394
  };