← Back to branch summary

~darkxst/ubuntu/raring/cogl/lp1163025

« back to all changes in this revision

Viewing changes to cogl/winsys/cogl-winsys-egl-null.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2012-03-13 19:11:11 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20120313191111-3hgk529qkh9m6uk2
Tags: 1.9.8-0ubuntu1
https://launchpad.net/bugs/941617
* New upstream release (LP: #941617)
* Updated symbols & library name for soname update
* debian/control.in: Bump minimum glib to 2.28
* debian/patches/02_disable_armv5t_specific_optimization.patch: Disabled

Show diffs side-by-side

added added

removed removed

Lines of Context:
cogl/winsys/cogl-winsys-egl-null.c
 
1
/*
 
2
 * Cogl
 
3
 *
 
4
 * An object oriented GL/GLES Abstraction/Utility Layer
 
5
 *
 
6
 * Copyright (C) 2011 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
 
20
 * <http://www.gnu.org/licenses/>.
 
21
 *
 
22
 *
 
23
 * Authors:
 
24
 *   Robert Bragg <robert@linux.intel.com>
 
25
 *   Neil Roberts <neil@linux.intel.com>
 
26
 */
 
27
 
 
28
#ifdef HAVE_CONFIG_H
 
29
#include "config.h"
 
30
#endif
 
31
 
 
32
#include "cogl-winsys-egl-null-private.h"
 
33
#include "cogl-winsys-egl-private.h"
 
34
#include "cogl-renderer-private.h"
 
35
#include "cogl-framebuffer-private.h"
 
36
#include "cogl-onscreen-private.h"
 
37
 
 
38
static const CoglWinsysEGLVtable _cogl_winsys_egl_vtable;
 
39
 
 
40
typedef struct _CoglDisplayNull
 
41
{
 
42
  int egl_surface_width;
 
43
  int egl_surface_height;
 
44
  gboolean have_onscreen;
 
45
} CoglDisplayNull;
 
46
 
 
47
static void
 
48
_cogl_winsys_renderer_disconnect (CoglRenderer *renderer)
 
49
{
 
50
  CoglRendererEGL *egl_renderer = renderer->winsys;
 
51
 
 
52
  eglTerminate (egl_renderer->edpy);
 
53
 
 
54
  g_slice_free (CoglRendererEGL, egl_renderer);
 
55
}
 
56
 
 
57
static gboolean
 
58
_cogl_winsys_renderer_connect (CoglRenderer *renderer,
 
59
                               GError **error)
 
60
{
 
61
  CoglRendererEGL *egl_renderer;
 
62
 
 
63
  renderer->winsys = g_slice_new0 (CoglRendererEGL);
 
64
  egl_renderer = renderer->winsys;
 
65
 
 
66
  egl_renderer->platform_vtable = &_cogl_winsys_egl_vtable;
 
67
 
 
68
  egl_renderer->edpy = eglGetDisplay (EGL_DEFAULT_DISPLAY);
 
69
 
 
70
  if (!_cogl_winsys_egl_renderer_connect_common (renderer, error))
 
71
    goto error;
 
72
 
 
73
  return TRUE;
 
74
 
 
75
error:
 
76
  _cogl_winsys_renderer_disconnect (renderer);
 
77
  return FALSE;
 
78
}
 
79
 
 
80
static gboolean
 
81
_cogl_winsys_egl_context_created (CoglDisplay *display,
 
82
                                  GError **error)
 
83
{
 
84
  CoglRenderer *renderer = display->renderer;
 
85
  CoglRendererEGL *egl_renderer = renderer->winsys;
 
86
  CoglDisplayEGL *egl_display = display->winsys;
 
87
  CoglDisplayNull *null_display = egl_display->platform;
 
88
  const char *error_message;
 
89
 
 
90
  egl_display->egl_surface =
 
91
    eglCreateWindowSurface (egl_renderer->edpy,
 
92
                            egl_display->egl_config,
 
93
                            (NativeWindowType) NULL,
 
94
                            NULL);
 
95
  if (egl_display->egl_surface == EGL_NO_SURFACE)
 
96
    {
 
97
      error_message = "Unable to create EGL window surface";
 
98
      goto fail;
 
99
    }
 
100
 
 
101
  if (!eglMakeCurrent (egl_renderer->edpy,
 
102
                       egl_display->egl_surface,
 
103
                       egl_display->egl_surface,
 
104
                       egl_display->egl_context))
 
105
    {
 
106
      error_message = "Unable to eglMakeCurrent with egl surface";
 
107
      goto fail;
 
108
    }
 
109
 
 
110
  eglQuerySurface (egl_renderer->edpy,
 
111
                   egl_display->egl_surface,
 
112
                   EGL_WIDTH,
 
113
                   &null_display->egl_surface_width);
 
114
 
 
115
  eglQuerySurface (egl_renderer->edpy,
 
116
                   egl_display->egl_surface,
 
117
                   EGL_HEIGHT,
 
118
                   &null_display->egl_surface_height);
 
119
 
 
120
  return TRUE;
 
121
 
 
122
 fail:
 
123
  g_set_error (error, COGL_WINSYS_ERROR,
 
124
               COGL_WINSYS_ERROR_CREATE_CONTEXT,
 
125
               "%s", error_message);
 
126
  return FALSE;
 
127
}
 
128
 
 
129
static gboolean
 
130
_cogl_winsys_egl_display_setup (CoglDisplay *display,
 
131
                                GError **error)
 
132
{
 
133
  CoglDisplayEGL *egl_display = display->winsys;
 
134
  CoglDisplayNull *null_display;
 
135
 
 
136
  null_display = g_slice_new0 (CoglDisplayNull);
 
137
  egl_display->platform = null_display;
 
138
 
 
139
  return TRUE;
 
140
}
 
141
 
 
142
static void
 
143
_cogl_winsys_egl_display_destroy (CoglDisplay *display)
 
144
{
 
145
  CoglDisplayEGL *egl_display = display->winsys;
 
146
 
 
147
  g_slice_free (CoglDisplayNull, egl_display->platform);
 
148
}
 
149
 
 
150
static void
 
151
_cogl_winsys_egl_cleanup_context (CoglDisplay *display)
 
152
{
 
153
  CoglRenderer *renderer = display->renderer;
 
154
  CoglRendererEGL *egl_renderer = renderer->winsys;
 
155
  CoglDisplayEGL *egl_display = display->winsys;
 
156
 
 
157
  if (egl_display->egl_surface != EGL_NO_SURFACE)
 
158
    {
 
159
      eglDestroySurface (egl_renderer->edpy, egl_display->egl_surface);
 
160
      egl_display->egl_surface = EGL_NO_SURFACE;
 
161
    }
 
162
}
 
163
 
 
164
static gboolean
 
165
_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen,
 
166
                                EGLConfig egl_config,
 
167
                                GError **error)
 
168
{
 
169
  CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
 
170
  CoglContext *context = framebuffer->context;
 
171
  CoglDisplay *display = context->display;
 
172
  CoglDisplayEGL *egl_display = display->winsys;
 
173
  CoglDisplayNull *null_display = egl_display->platform;
 
174
  CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
 
175
 
 
176
  if (null_display->have_onscreen)
 
177
    {
 
178
      g_set_error (error, COGL_WINSYS_ERROR,
 
179
                   COGL_WINSYS_ERROR_CREATE_ONSCREEN,
 
180
                   "EGL platform only supports a single onscreen window");
 
181
      return FALSE;
 
182
    }
 
183
 
 
184
  egl_onscreen->egl_surface = egl_display->egl_surface;
 
185
 
 
186
  _cogl_framebuffer_winsys_update_size (framebuffer,
 
187
                                        null_display->egl_surface_width,
 
188
                                        null_display->egl_surface_height);
 
189
  null_display->have_onscreen = TRUE;
 
190
 
 
191
  return TRUE;
 
192
}
 
193
 
 
194
static void
 
195
_cogl_winsys_egl_onscreen_deinit (CoglOnscreen *onscreen)
 
196
{
 
197
  CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
 
198
  CoglContext *context = framebuffer->context;
 
199
  CoglDisplay *display = context->display;
 
200
  CoglDisplayEGL *egl_display = display->winsys;
 
201
  CoglDisplayNull *null_display = egl_display->platform;
 
202
 
 
203
  null_display->have_onscreen = FALSE;
 
204
}
 
205
 
 
206
static const CoglWinsysEGLVtable
 
207
_cogl_winsys_egl_vtable =
 
208
  {
 
209
    .display_setup = _cogl_winsys_egl_display_setup,
 
210
    .display_destroy = _cogl_winsys_egl_display_destroy,
 
211
    .context_created = _cogl_winsys_egl_context_created,
 
212
    .cleanup_context = _cogl_winsys_egl_cleanup_context,
 
213
    .onscreen_init = _cogl_winsys_egl_onscreen_init,
 
214
    .onscreen_deinit = _cogl_winsys_egl_onscreen_deinit
 
215
  };
 
216
 
 
217
const CoglWinsysVtable *
 
218
_cogl_winsys_egl_null_get_vtable (void)
 
219
{
 
220
  static gboolean vtable_inited = FALSE;
 
221
  static CoglWinsysVtable vtable;
 
222
 
 
223
  if (!vtable_inited)
 
224
    {
 
225
      /* The EGL_NULL winsys is a subclass of the EGL winsys so we
 
226
         start by copying its vtable */
 
227
 
 
228
      vtable = *_cogl_winsys_egl_get_vtable ();
 
229
 
 
230
      vtable.id = COGL_WINSYS_ID_EGL_NULL;
 
231
      vtable.name = "EGL_NULL";
 
232
 
 
233
      vtable.renderer_connect = _cogl_winsys_renderer_connect;
 
234
      vtable.renderer_disconnect = _cogl_winsys_renderer_disconnect;
 
235
 
 
236
      vtable_inited = TRUE;
 
237
    }
 
238
 
 
239
  return &vtable;
 
240
}