egl: drop unused _EGLDriver from Terminate()
[mesa.git] / src / egl / drivers / haiku / egl_haiku.cpp
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 2014 Adrián Arroyo Calle <adrian.arroyocalle@gmail.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25 #include <errno.h>
26 #include <dlfcn.h>
27 #include <stdint.h>
28 #include <stdio.h>
29
30 #include "eglconfig.h"
31 #include "eglcontext.h"
32 #include "egldevice.h"
33 #include "egldisplay.h"
34 #include "egldriver.h"
35 #include "eglcurrent.h"
36 #include "egllog.h"
37 #include "eglsurface.h"
38 #include "eglimage.h"
39 #include "egltypedefs.h"
40
41 #include <InterfaceKit.h>
42 #include <OpenGLKit.h>
43
44
45 #ifdef DEBUG
46 # define TRACE(x...) printf("egl_haiku: " x)
47 # define CALLED() TRACE("CALLED: %s\n", __PRETTY_FUNCTION__)
48 #else
49 # define TRACE(x...)
50 # define CALLED()
51 #endif
52 #define ERROR(x...) printf("egl_haiku: " x)
53
54
55 _EGL_DRIVER_STANDARD_TYPECASTS(haiku_egl)
56
57
58 struct haiku_egl_config
59 {
60 _EGLConfig base;
61 };
62
63 struct haiku_egl_context
64 {
65 _EGLContext ctx;
66 };
67
68 struct haiku_egl_surface
69 {
70 _EGLSurface surf;
71 BGLView* gl;
72 };
73
74
75 /**
76 * Called via eglCreateWindowSurface(), drv->CreateWindowSurface().
77 */
78 static _EGLSurface *
79 haiku_create_window_surface(const _EGLDriver *drv, _EGLDisplay *disp,
80 _EGLConfig *conf, void *native_window, const EGLint *attrib_list)
81 {
82 CALLED();
83
84 struct haiku_egl_surface* surface;
85 surface = (struct haiku_egl_surface*) calloc(1, sizeof (*surface));
86 if (!surface) {
87 _eglError(EGL_BAD_ALLOC, "haiku_create_window_surface");
88 return NULL;
89 }
90
91 if (!_eglInitSurface(&surface->surf, disp, EGL_WINDOW_BIT,
92 conf, attrib_list, native_window)) {
93 free(surface);
94 return NULL;
95 }
96
97 (&surface->surf)->SwapInterval = 1;
98
99 TRACE("Creating window\n");
100 BWindow* win = (BWindow*)native_window;
101
102 TRACE("Creating GL view\n");
103 surface->gl = new BGLView(win->Bounds(), "OpenGL", B_FOLLOW_ALL_SIDES, 0,
104 BGL_RGB | BGL_DOUBLE | BGL_ALPHA);
105
106 TRACE("Adding GL\n");
107 win->AddChild(surface->gl);
108
109 TRACE("Showing window\n");
110 win->Show();
111 return &surface->surf;
112 }
113
114
115 static _EGLSurface *
116 haiku_create_pixmap_surface(const _EGLDriver *drv, _EGLDisplay *disp,
117 _EGLConfig *conf, void *native_pixmap, const EGLint *attrib_list)
118 {
119 return NULL;
120 }
121
122
123 static _EGLSurface *
124 haiku_create_pbuffer_surface(const _EGLDriver *drv, _EGLDisplay *disp,
125 _EGLConfig *conf, const EGLint *attrib_list)
126 {
127 return NULL;
128 }
129
130
131 static EGLBoolean
132 haiku_destroy_surface(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
133 {
134 if (_eglPutSurface(surf)) {
135 // XXX: detach haiku_egl_surface::gl from the native window and destroy it
136 free(surf);
137 }
138 return EGL_TRUE;
139 }
140
141
142 static EGLBoolean
143 haiku_add_configs_for_visuals(_EGLDisplay *disp)
144 {
145 CALLED();
146
147 struct haiku_egl_config* conf;
148 conf = (struct haiku_egl_config*) calloc(1, sizeof (*conf));
149 if (!conf)
150 return _eglError(EGL_BAD_ALLOC, "haiku_add_configs_for_visuals");
151
152 _eglInitConfig(&conf->base, disp, 1);
153 TRACE("Config inited\n");
154
155 conf->base.RedSize = 8;
156 conf->base.BlueSize = 8;
157 conf->base.GreenSize = 8;
158 conf->base.LuminanceSize = 0;
159 conf->base.AlphaSize = 8;
160 conf->base.ColorBufferType = EGL_RGB_BUFFER;
161 conf->base.BufferSize = conf->base.RedSize
162 + conf->base.GreenSize
163 + conf->base.BlueSize
164 + conf->base.AlphaSize;
165 conf->base.ConfigCaveat = EGL_NONE;
166 conf->base.ConfigId = 1;
167 conf->base.BindToTextureRGB = EGL_FALSE;
168 conf->base.BindToTextureRGBA = EGL_FALSE;
169 conf->base.StencilSize = 0;
170 conf->base.TransparentType = EGL_NONE;
171 conf->base.NativeRenderable = EGL_TRUE; // Let's say yes
172 conf->base.NativeVisualID = 0; // No visual
173 conf->base.NativeVisualType = EGL_NONE; // No visual
174 conf->base.RenderableType = 0x8;
175 conf->base.SampleBuffers = 0; // TODO: How to get the right value ?
176 conf->base.Samples = conf->base.SampleBuffers == 0 ? 0 : 0;
177 conf->base.DepthSize = 24; // TODO: How to get the right value ?
178 conf->base.Level = 0;
179 conf->base.MaxPbufferWidth = 0; // TODO: How to get the right value ?
180 conf->base.MaxPbufferHeight = 0; // TODO: How to get the right value ?
181 conf->base.MaxPbufferPixels = 0; // TODO: How to get the right value ?
182 conf->base.SurfaceType = EGL_WINDOW_BIT /*| EGL_PIXMAP_BIT | EGL_PBUFFER_BIT*/;
183
184 TRACE("Config configuated\n");
185 if (!_eglValidateConfig(&conf->base, EGL_FALSE)) {
186 _eglLog(_EGL_DEBUG, "Haiku: failed to validate config");
187 goto cleanup;
188 }
189 TRACE("Validated config\n");
190
191 _eglLinkConfig(&conf->base);
192 if (!_eglGetArraySize(disp->Configs)) {
193 _eglLog(_EGL_WARNING, "Haiku: failed to create any config");
194 goto cleanup;
195 }
196 TRACE("Config successfull\n");
197
198 return EGL_TRUE;
199
200 cleanup:
201 free(conf);
202 return EGL_FALSE;
203 }
204
205
206 extern "C"
207 EGLBoolean
208 init_haiku(_EGLDisplay *disp)
209 {
210 _EGLDevice *dev;
211 CALLED();
212
213 dev = _eglAddDevice(-1, true);
214 if (!dev) {
215 _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
216 return EGL_FALSE;
217 }
218 disp->Device = dev;
219
220 TRACE("Add configs\n");
221 if (!haiku_add_configs_for_visuals(disp))
222 return EGL_FALSE;
223
224 TRACE("Initialization finished\n");
225
226 return EGL_TRUE;
227 }
228
229
230 extern "C"
231 EGLBoolean
232 haiku_terminate(_EGLDisplay *disp)
233 {
234 return EGL_TRUE;
235 }
236
237
238 extern "C"
239 _EGLContext*
240 haiku_create_context(const _EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
241 _EGLContext *share_list, const EGLint *attrib_list)
242 {
243 CALLED();
244
245 struct haiku_egl_context* context;
246 context = (struct haiku_egl_context*) calloc(1, sizeof (*context));
247 if (!context) {
248 _eglError(EGL_BAD_ALLOC, "haiku_create_context");
249 return NULL;
250 }
251
252 if (!_eglInitContext(&context->ctx, disp, conf, attrib_list))
253 goto cleanup;
254
255 TRACE("Context created\n");
256 return &context->ctx;
257
258 cleanup:
259 free(context);
260 return NULL;
261 }
262
263
264 extern "C"
265 EGLBoolean
266 haiku_destroy_context(const _EGLDriver* drv, _EGLDisplay *disp, _EGLContext* ctx)
267 {
268 struct haiku_egl_context* context = haiku_egl_context(ctx);
269
270 if (_eglPutContext(ctx)) {
271 // XXX: teardown the context ?
272 free(context);
273 ctx = NULL;
274 }
275 return EGL_TRUE;
276 }
277
278
279 extern "C"
280 EGLBoolean
281 haiku_make_current(const _EGLDriver* drv, _EGLDisplay *disp, _EGLSurface *dsurf,
282 _EGLSurface *rsurf, _EGLContext *ctx)
283 {
284 CALLED();
285
286 struct haiku_egl_context* cont = haiku_egl_context(ctx);
287 struct haiku_egl_surface* surf = haiku_egl_surface(dsurf);
288 _EGLContext *old_ctx;
289 _EGLSurface *old_dsurf, *old_rsurf;
290
291 if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
292 return EGL_FALSE;
293
294 //cont->ctx.DrawSurface=&surf->surf;
295 surf->gl->LockGL();
296 return EGL_TRUE;
297 }
298
299
300 extern "C"
301 EGLBoolean
302 haiku_swap_buffers(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
303 {
304 struct haiku_egl_surface* surface = haiku_egl_surface(surf);
305
306 surface->gl->SwapBuffers();
307 //gl->Render();
308 return EGL_TRUE;
309 }
310
311
312 extern "C"
313 const _EGLDriver _eglDriver = {
314 .Initialize = init_haiku,
315 .Terminate = haiku_terminate,
316 .CreateContext = haiku_create_context,
317 .DestroyContext = haiku_destroy_context,
318 .MakeCurrent = haiku_make_current,
319 .CreateWindowSurface = haiku_create_window_surface,
320 .CreatePixmapSurface = haiku_create_pixmap_surface,
321 .CreatePbufferSurface = haiku_create_pbuffer_surface,
322 .DestroySurface = haiku_destroy_surface,
323 .SwapBuffers = haiku_swap_buffers,
324 };