#include <errno.h>
#include <dlfcn.h>
+#include <stdint.h>
#include <stdio.h>
-extern "C" {
-#include "loader.h"
#include "eglconfig.h"
#include "eglcontext.h"
+#include "egldevice.h"
#include "egldisplay.h"
#include "egldriver.h"
#include "eglcurrent.h"
#include "eglsurface.h"
#include "eglimage.h"
#include "egltypedefs.h"
-}
#include <InterfaceKit.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__)
+#else
+# define TRACE(x...)
+# define CALLED()
+#endif
+#define ERROR(x...) printf("egl_haiku: " x)
_EGL_DRIVER_STANDARD_TYPECASTS(haiku_egl)
-struct haiku_egl_driver
-{
- _EGLDriver base;
-
- void *handle;
- _EGLProc (*get_proc_address)(const char *procname);
- void (*glFlush)(void);
-};
-
struct haiku_egl_config
{
- _EGLConfig base;
+ _EGLConfig base;
};
struct haiku_egl_context
};
-/*
-static void
-swrastCreateDrawable(struct dri2_egl_display * dri2_dpy,
- struct dri2_egl_surface * dri2_surf, int depth)
-{
-
-}
-
-
-static void
-swrastDestroyDrawable(struct dri2_egl_display * dri2_dpy,
- struct dri2_egl_surface * dri2_surf)
-{
-
-}
-
-
-static void
-swrastGetDrawableInfo(__DRIdrawable * draw, int *x, int *y,
- int *w, int *h, void *loaderPrivate)
-{
-
-}
-
-
-static void
-swrastPutImage(__DRIdrawable * draw, int op, int x, int y,
- int w, int h, char *data, void *loaderPrivate)
-{
-
-}
-
-
-static void
-swrastGetImage(__DRIdrawable * read, int x, int y,
- int w, int h, char *data, void *loaderPrivate)
-{
-
-}
-*/
-
-
-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 via eglCreateWindowSurface(), drv->CreateWindowSurface().
*/
static _EGLSurface *
-haiku_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
+haiku_create_window_surface(const _EGLDriver *drv, _EGLDisplay *disp,
_EGLConfig *conf, void *native_window, const EGLint *attrib_list)
{
+ 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, native_window)) {
+ free(surface);
+ return NULL;
+ }
- _eglInitSurface(&surface->surf, disp, EGL_WINDOW_BIT, conf, attrib_list);
(&surface->surf)->SwapInterval = 1;
- _eglLog(_EGL_DEBUG, "Creating window");
+ TRACE("Creating window\n");
BWindow* win = (BWindow*)native_window;
- _eglLog(_EGL_DEBUG, "Creating GL view");
+ TRACE("Creating GL view\n");
surface->gl = new BGLView(win->Bounds(), "OpenGL", B_FOLLOW_ALL_SIDES, 0,
BGL_RGB | BGL_DOUBLE | BGL_ALPHA);
- _eglLog(_EGL_DEBUG, "Adding GL");
+ TRACE("Adding GL\n");
win->AddChild(surface->gl);
- _eglLog(_EGL_DEBUG, "Showing window");
+ TRACE("Showing window\n");
win->Show();
return &surface->surf;
}
static _EGLSurface *
-haiku_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
+haiku_create_pixmap_surface(const _EGLDriver *drv, _EGLDisplay *disp,
_EGLConfig *conf, void *native_pixmap, const EGLint *attrib_list)
{
- return NULL;
+ return NULL;
}
static _EGLSurface *
-haiku_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
+haiku_create_pbuffer_surface(const _EGLDriver *drv, _EGLDisplay *disp,
_EGLConfig *conf, const EGLint *attrib_list)
{
- return NULL;
+ return NULL;
}
static EGLBoolean
-haiku_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
+haiku_destroy_surface(const _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;
}
static EGLBoolean
-haiku_add_configs_for_visuals(_EGLDisplay *dpy)
+haiku_add_configs_for_visuals(_EGLDisplay *disp)
{
- printf("Adding configs\n");
- struct haiku_egl_config conf, *final;
- //conf=CALLOC_STRUCT(haiku_egl_config);
- memset(&conf, 0, sizeof(conf));
- _eglInitConfig(&conf.base, dpy, 1);
- _eglLog(_EGL_DEBUG,"Config inited\n");
- _eglSetConfigKey(&conf.base, EGL_RED_SIZE ,8);
- _eglSetConfigKey(&conf.base, EGL_BLUE_SIZE ,8);
- _eglSetConfigKey(&conf.base, EGL_GREEN_SIZE ,8);
- _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)
- + _eglGetConfigKey(&conf.base, EGL_GREEN_SIZE)
- + _eglGetConfigKey(&conf.base, EGL_BLUE_SIZE)
- + _eglGetConfigKey(&conf.base, EGL_ALPHA_SIZE));
- _eglSetConfigKey(&conf.base, EGL_BUFFER_SIZE, r);
- _eglSetConfigKey(&conf.base, EGL_CONFIG_CAVEAT, EGL_NONE);
- _eglSetConfigKey(&conf.base, EGL_CONFIG_ID, 1);
- _eglSetConfigKey(&conf.base, EGL_BIND_TO_TEXTURE_RGB ,EGL_FALSE);
- _eglSetConfigKey(&conf.base, EGL_BIND_TO_TEXTURE_RGBA ,EGL_FALSE);
- _eglSetConfigKey(&conf.base, EGL_STENCIL_SIZE ,0);
- _eglSetConfigKey(&conf.base, EGL_TRANSPARENT_TYPE ,EGL_NONE);
- _eglSetConfigKey(&conf.base, EGL_NATIVE_RENDERABLE ,EGL_TRUE); // Let's say yes
- _eglSetConfigKey(&conf.base, EGL_NATIVE_VISUAL_ID ,0); // No visual
- _eglSetConfigKey(&conf.base, EGL_NATIVE_VISUAL_TYPE ,EGL_NONE); // No visual
- _eglSetConfigKey(&conf.base, EGL_RENDERABLE_TYPE ,0x8);
- _eglSetConfigKey(&conf.base, EGL_SAMPLE_BUFFERS ,0); // TODO: How to get the right value ?
- _eglSetConfigKey(&conf.base, EGL_SAMPLES ,_eglGetConfigKey(&conf.base, EGL_SAMPLE_BUFFERS) == 0 ? 0 : 0);
- _eglSetConfigKey(&conf.base, EGL_DEPTH_SIZE ,24); // TODO: How to get the right value ?
- _eglSetConfigKey(&conf.base, EGL_LEVEL ,0);
- _eglSetConfigKey(&conf.base, EGL_MAX_PBUFFER_WIDTH ,0); // TODO: How to get the right value ?
- _eglSetConfigKey(&conf.base, EGL_MAX_PBUFFER_HEIGHT ,0); // TODO: How to get the right value ?
- _eglSetConfigKey(&conf.base, EGL_MAX_PBUFFER_PIXELS ,0); // TODO: How to get the right value ?
- _eglSetConfigKey(&conf.base, EGL_SURFACE_TYPE, EGL_WINDOW_BIT /*| EGL_PIXMAP_BIT | EGL_PBUFFER_BIT*/);
-
- printf("Config configurated\n");
- if (!_eglValidateConfig(&conf.base, EGL_FALSE)) {
- _eglLog(_EGL_DEBUG, "Haiku failed to validate config");
- return EGL_FALSE;
+ CALLED();
+
+ struct haiku_egl_config* conf;
+ conf = (struct haiku_egl_config*) calloc(1, sizeof (*conf));
+ if (!conf)
+ return _eglError(EGL_BAD_ALLOC, "haiku_add_configs_for_visuals");
+
+ _eglInitConfig(&conf->base, disp, 1);
+ TRACE("Config inited\n");
+
+ conf->base.RedSize = 8;
+ conf->base.BlueSize = 8;
+ conf->base.GreenSize = 8;
+ conf->base.LuminanceSize = 0;
+ conf->base.AlphaSize = 8;
+ conf->base.ColorBufferType = EGL_RGB_BUFFER;
+ conf->base.BufferSize = conf->base.RedSize
+ + conf->base.GreenSize
+ + conf->base.BlueSize
+ + conf->base.AlphaSize;
+ conf->base.ConfigCaveat = EGL_NONE;
+ conf->base.ConfigId = 1;
+ conf->base.BindToTextureRGB = EGL_FALSE;
+ conf->base.BindToTextureRGBA = EGL_FALSE;
+ conf->base.StencilSize = 0;
+ conf->base.TransparentType = EGL_NONE;
+ conf->base.NativeRenderable = EGL_TRUE; // Let's say yes
+ conf->base.NativeVisualID = 0; // No visual
+ conf->base.NativeVisualType = EGL_NONE; // No visual
+ conf->base.RenderableType = 0x8;
+ conf->base.SampleBuffers = 0; // TODO: How to get the right value ?
+ conf->base.Samples = conf->base.SampleBuffers == 0 ? 0 : 0;
+ conf->base.DepthSize = 24; // TODO: How to get the right value ?
+ conf->base.Level = 0;
+ conf->base.MaxPbufferWidth = 0; // TODO: How to get the right value ?
+ conf->base.MaxPbufferHeight = 0; // TODO: How to get the right value ?
+ conf->base.MaxPbufferPixels = 0; // TODO: How to get the right value ?
+ conf->base.SurfaceType = EGL_WINDOW_BIT /*| EGL_PIXMAP_BIT | EGL_PBUFFER_BIT*/;
+
+ TRACE("Config configuated\n");
+ if (!_eglValidateConfig(&conf->base, EGL_FALSE)) {
+ _eglLog(_EGL_DEBUG, "Haiku: failed to validate config");
+ goto cleanup;
}
- printf("Validated config\n");
-
- final = CALLOC_STRUCT(haiku_egl_config);
- memcpy(final, &conf, sizeof(conf));
-
- _eglLinkConfig(&final->base);
- if (!_eglGetArraySize(dpy->Configs)) {
+ TRACE("Validated config\n");
+
+ _eglLinkConfig(&conf->base);
+ if (!_eglGetArraySize(disp->Configs)) {
_eglLog(_EGL_WARNING, "Haiku: failed to create any config");
- return EGL_FALSE;
+ goto cleanup;
}
- printf("Config succesfull\n");
-
+ TRACE("Config successfull\n");
+
return EGL_TRUE;
+
+cleanup:
+ free(conf);
+ return EGL_FALSE;
}
+
extern "C"
EGLBoolean
-init_haiku(_EGLDriver *drv, _EGLDisplay *dpy)
+init_haiku(_EGLDisplay *disp)
{
- _eglLog(_EGL_DEBUG,"\nInitializing Haiku EGL\n");
- //_EGLDisplay* egl_dpy;
-
- printf("Initializing Haiku EGL\n");
- _eglSetLogProc(haiku_log);
-
- loader_set_logger(_eglLog);
-
- /*egl_dpy = (_EGLDisplay*) calloc(1, sizeof(_EGLDisplay));
- if (!egl_dpy)
- return _eglError(EGL_BAD_ALLOC, "eglInitialize");
-
- dpy->DriverData=(void*) egl_dpy;
- if (!dpy->PlatformDisplay) {
- // OPEN DEVICE
- //dri2_dpy->bwindow = (void*)haiku_create_window();
- //dri2_dpy->own_device = true;
- } else {
- //dri2_dpy->bwindow = (BWindow*)dpy->PlatformDisplay;
- }*/
-
- //dri2_dpy->driver_name = strdup("swrast");
- //if (!dri2_load_driver_swrast(dpy))
- // goto cleanup_conn;
-
- /*dri2_dpy->swrast_loader_extension.base.name = __DRI_SWRAST_LOADER;
- dri2_dpy->swrast_loader_extension.base.version = __DRI_SWRAST_LOADER_VERSION;
- dri2_dpy->swrast_loader_extension.getDrawableInfo = swrastGetDrawableInfo;
- dri2_dpy->swrast_loader_extension.putImage = swrastPutImage;
- dri2_dpy->swrast_loader_extension.getImage = swrastGetImage;
-
- dri2_dpy->extensions[0] = &dri2_dpy->swrast_loader_extension.base;
- dri2_dpy->extensions[1] = NULL;
- dri2_dpy->extensions[2] = NULL;*/
-
- /*if (dri2_dpy->bwindow) {
- if (!dri2_haiku_add_configs_for_visuals(dri2_dpy, dpy))
- goto cleanup_configs;
- }*/
- _eglLog(_EGL_DEBUG,"Add configs");
- haiku_add_configs_for_visuals(dpy);
-
- dpy->VersionMajor=1;
- dpy->VersionMinor=4;
-
- //dpy->Extensions.KHR_create_context = true;
-
- //dri2_dpy->vtbl = &dri2_haiku_display_vtbl;
- _eglLog(_EGL_DEBUG, "Initialization finished");
+ _EGLDevice *dev;
+ CALLED();
+
+ dev = _eglAddDevice(-1, true);
+ if (!dev) {
+ _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
+ return EGL_FALSE;
+ }
+ disp->Device = dev;
+
+ TRACE("Add configs\n");
+ if (!haiku_add_configs_for_visuals(disp))
+ return EGL_FALSE;
+
+ TRACE("Initialization finished\n");
return EGL_TRUE;
}
extern "C"
EGLBoolean
-haiku_terminate(_EGLDriver* drv,_EGLDisplay* dpy)
+haiku_terminate(_EGLDisplay *disp)
{
return EGL_TRUE;
}
extern "C"
_EGLContext*
-haiku_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
+haiku_create_context(const _EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
_EGLContext *share_list, const EGLint *attrib_list)
{
- _eglLog(_EGL_DEBUG,"Creating context");
+ CALLED();
+
struct haiku_egl_context* context;
- context=(struct haiku_egl_context*)calloc(1,sizeof (*context));
- if(!_eglInitContext(&context->ctx, disp, conf, attrib_list))
- printf("ERROR creating context");
- _eglLog(_EGL_DEBUG, "Context created");
+ 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))
+ goto cleanup;
+
+ TRACE("Context created\n");
return &context->ctx;
+
+cleanup:
+ free(context);
+ return NULL;
}
extern "C"
EGLBoolean
-haiku_destroy_context(_EGLDriver* drv, _EGLDisplay *disp, _EGLContext* ctx)
+haiku_destroy_context(const _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)
+haiku_make_current(const _EGLDriver* drv, _EGLDisplay *disp, _EGLSurface *dsurf,
+ _EGLSurface *rsurf, _EGLContext *ctx)
{
- struct haiku_egl_context* cont=haiku_egl_context(ctx);
- struct haiku_egl_surface* surf=haiku_egl_surface(dsurf);
+ CALLED();
+
+ 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;
extern "C"
EGLBoolean
-haiku_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
+haiku_swap_buffers(const _EGLDriver *drv, _EGLDisplay *disp, _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;
extern "C"
-void
-haiku_unload(_EGLDriver* drv)
-{
-
-}
-
-
-/**
- * This is the main entrypoint into the driver, called by libEGL.
- * Create a new _EGLDriver object and init its dispatch table.
- */
-extern "C"
-_EGLDriver*
-_eglBuiltInDriverHaiku(const char *args)
-{
- _eglLog(_EGL_DEBUG,"Driver loaded");
- struct haiku_egl_driver* driver;
- driver=(struct haiku_egl_driver*)calloc(1,sizeof(*driver));
- _eglInitDriverFallbacks(&driver->base);
- driver->base.API.Initialize = init_haiku;
- driver->base.API.Terminate = haiku_terminate;
- driver->base.API.CreateContext = haiku_create_context;
- driver->base.API.DestroyContext = haiku_destroy_context;
- driver->base.API.MakeCurrent = haiku_make_current;
- driver->base.API.CreateWindowSurface = haiku_create_window_surface;
- driver->base.API.CreatePixmapSurface = haiku_create_pixmap_surface;
- driver->base.API.CreatePbufferSurface = haiku_create_pbuffer_surface;
- driver->base.API.DestroySurface = haiku_destroy_surface;
- /*
- driver->API.GetProcAddress = dri2_get_proc_address;
- driver->API.WaitClient = dri2_wait_client;
- driver->API.WaitNative = dri2_wait_native;
- driver->API.BindTexImage = dri2_bind_tex_image;
- driver->API.ReleaseTexImage = dri2_release_tex_image;
- driver->API.SwapInterval = dri2_swap_interval;
- */
-
- driver->base.API.SwapBuffers = haiku_swap_buffers;
- /*
- driver->API.SwapBuffersWithDamageEXT = dri2_swap_buffers_with_damage;
- driver->API.SwapBuffersRegionNOK = dri2_swap_buffers_region;
- driver->API.PostSubBufferNV = dri2_post_sub_buffer;
- driver->API.CopyBuffers = dri2_copy_buffers,
- driver->API.QueryBufferAge = dri2_query_buffer_age;
- driver->API.CreateImageKHR = dri2_create_image;
- driver->API.DestroyImageKHR = dri2_destroy_image_khr;
- driver->API.CreateWaylandBufferFromImageWL = dri2_create_wayland_buffer_from_image;
- driver->API.GetSyncValuesCHROMIUM = dri2_get_sync_values_chromium;
- */
-
- driver->base.Name = "Haiku";
- driver->base.Unload = haiku_unload;
-
- _eglLog(_EGL_DEBUG, "API Calls defined");
-
- return &driver->base;
-}
+const _EGLDriver _eglDriver = {
+ .Initialize = init_haiku,
+ .Terminate = haiku_terminate,
+ .CreateContext = haiku_create_context,
+ .DestroyContext = haiku_destroy_context,
+ .MakeCurrent = haiku_make_current,
+ .CreateWindowSurface = haiku_create_window_surface,
+ .CreatePixmapSurface = haiku_create_pixmap_surface,
+ .CreatePbufferSurface = haiku_create_pbuffer_surface,
+ .DestroySurface = haiku_destroy_surface,
+ .SwapBuffers = haiku_swap_buffers,
+};
projects / mesa.git / blobdiff