#include <stdint.h>
#include <stdio.h>
-#include "loader.h"
#include "eglconfig.h"
#include "eglcontext.h"
#include "egldisplay.h"
#include <OpenGLKit.h>
-#define CALLOC_STRUCT(T) (struct T *) calloc(1, sizeof(struct T))
-
#ifdef DEBUG
# define TRACE(x...) printf("egl_haiku: " x)
# define CALLED() TRACE("CALLED: %s\n", __PRETTY_FUNCTION__)
struct haiku_egl_driver
{
_EGLDriver base;
-
- void *handle;
- _EGLProc (*get_proc_address)(const char *procname);
- void (*glFlush)(void);
};
struct haiku_egl_config
};
-static void
-haiku_log(EGLint level, const char *msg)
-{
- switch (level) {
- case _EGL_DEBUG:
- fprintf(stderr,"%s", msg);
- break;
- case _EGL_INFO:
- fprintf(stderr,"%s", msg);
- break;
- case _EGL_WARNING:
- fprintf(stderr,"%s", msg);
- break;
- case _EGL_FATAL:
- fprintf(stderr,"%s", msg);
- break;
- default:
- break;
- }
-}
-
-
-/**
- * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
- */
-static _EGLSurface *
-haiku_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
- _EGLConfig *conf, void *native_surface, const EGLint *attrib_list)
-{
- return NULL;
-}
-
-
/**
* Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
*/
CALLED();
struct haiku_egl_surface* surface;
- surface = (struct haiku_egl_surface*)calloc(1,sizeof (*surface));
+ surface = (struct haiku_egl_surface*) calloc(1, sizeof (*surface));
+ if (!surface) {
+ _eglError(EGL_BAD_ALLOC, "haiku_create_window_surface");
+ return NULL;
+ }
+
+ if (!_eglInitSurface(&surface->surf, disp, EGL_WINDOW_BIT,
+ conf, attrib_list)) {
+ free(surface);
+ return NULL;
+ }
- _eglInitSurface(&surface->surf, disp, EGL_WINDOW_BIT, conf, attrib_list);
(&surface->surf)->SwapInterval = 1;
TRACE("Creating window\n");
static EGLBoolean
haiku_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
{
+ if (_eglPutSurface(surf)) {
+ // XXX: detach haiku_egl_surface::gl from the native window and destroy it
+ free(surf);
+ }
return EGL_TRUE;
}
CALLED();
struct haiku_egl_config* conf;
- conf = CALLOC_STRUCT(haiku_egl_config);
+ conf = (struct haiku_egl_config*) calloc(1, sizeof (*conf));
+ if (!conf)
+ return _eglError(EGL_BAD_ALLOC, "haiku_add_configs_for_visuals");
_eglInitConfig(&conf->base, dpy, 1);
TRACE("Config inited\n");
_eglSetConfigKey(&conf->base, EGL_LUMINANCE_SIZE, 0);
_eglSetConfigKey(&conf->base, EGL_ALPHA_SIZE, 8);
_eglSetConfigKey(&conf->base, EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER);
- EGLint r = (_eglGetConfigKey(&conf->base, EGL_RED_SIZE)
+ EGLint r = (_eglGetConfigKey(&conf->base, EGL_RED_SIZE)
+ _eglGetConfigKey(&conf->base, EGL_GREEN_SIZE)
+ _eglGetConfigKey(&conf->base, EGL_BLUE_SIZE)
+ _eglGetConfigKey(&conf->base, EGL_ALPHA_SIZE));
TRACE("Config configuated\n");
if (!_eglValidateConfig(&conf->base, EGL_FALSE)) {
_eglLog(_EGL_DEBUG, "Haiku: failed to validate config");
- return EGL_FALSE;
+ goto cleanup;
}
TRACE("Validated config\n");
-
+
_eglLinkConfig(&conf->base);
if (!_eglGetArraySize(dpy->Configs)) {
_eglLog(_EGL_WARNING, "Haiku: failed to create any config");
- return EGL_FALSE;
+ goto cleanup;
}
TRACE("Config successfull\n");
-
+
return EGL_TRUE;
+
+cleanup:
+ free(conf);
+ return EGL_FALSE;
}
+
extern "C"
EGLBoolean
init_haiku(_EGLDriver *drv, _EGLDisplay *dpy)
{
CALLED();
- _eglSetLogProc(haiku_log);
-
- loader_set_logger(_eglLog);
-
TRACE("Add configs\n");
- haiku_add_configs_for_visuals(dpy);
+ if (!haiku_add_configs_for_visuals(dpy))
+ return EGL_FALSE;
dpy->Version = 14;
-
+
TRACE("Initialization finished\n");
return EGL_TRUE;
CALLED();
struct haiku_egl_context* context;
- context=(struct haiku_egl_context*)calloc(1,sizeof (*context));
+ context = (struct haiku_egl_context*) calloc(1, sizeof (*context));
+ if (!context) {
+ _eglError(EGL_BAD_ALLOC, "haiku_create_context");
+ return NULL;
+ }
if (!_eglInitContext(&context->ctx, disp, conf, attrib_list))
- ERROR("ERROR creating context");
+ goto cleanup;
TRACE("Context created\n");
return &context->ctx;
+
+cleanup:
+ free(context);
+ return NULL;
}
EGLBoolean
haiku_destroy_context(_EGLDriver* drv, _EGLDisplay *disp, _EGLContext* ctx)
{
- ctx=NULL;
+ struct haiku_egl_context* context = haiku_egl_context(ctx);
+
+ if (_eglPutContext(ctx)) {
+ // XXX: teardown the context ?
+ free(context);
+ ctx = NULL;
+ }
return EGL_TRUE;
}
extern "C"
EGLBoolean
haiku_make_current(_EGLDriver* drv, _EGLDisplay* dpy, _EGLSurface *dsurf,
- _EGLSurface *rsurf, _EGLContext *ctx)
+ _EGLSurface *rsurf, _EGLContext *ctx)
{
CALLED();
- struct haiku_egl_context* cont=haiku_egl_context(ctx);
- struct haiku_egl_surface* surf=haiku_egl_surface(dsurf);
+ struct haiku_egl_context* cont = haiku_egl_context(ctx);
+ struct haiku_egl_surface* surf = haiku_egl_surface(dsurf);
_EGLContext *old_ctx;
- _EGLSurface *old_dsurf, *old_rsurf;
- _eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf);
+ _EGLSurface *old_dsurf, *old_rsurf;
+
+ if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
+ return EGL_FALSE;
+
//cont->ctx.DrawSurface=&surf->surf;
surf->gl->LockGL();
return EGL_TRUE;
EGLBoolean
haiku_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
{
- struct haiku_egl_surface* surface=haiku_egl_surface(surf);
+ struct haiku_egl_surface* surface = haiku_egl_surface(surf);
+
surface->gl->SwapBuffers();
//gl->Render();
return EGL_TRUE;
void
haiku_unload(_EGLDriver* drv)
{
-
+
}
CALLED();
struct haiku_egl_driver* driver;
- driver=(struct haiku_egl_driver*)calloc(1,sizeof(*driver));
+ driver = (struct haiku_egl_driver*) calloc(1, sizeof(*driver));
+ if (!driver) {
+ _eglError(EGL_BAD_ALLOC, "_eglBuiltInDriverHaiku");
+ return NULL;
+ }
+
_eglInitDriverFallbacks(&driver->base);
driver->base.API.Initialize = init_haiku;
driver->base.API.Terminate = haiku_terminate;
projects / mesa.git / blobdiff