/**
* The bootstrap function. Return a new drm_driver object and
* plug in API functions.
* libEGL finds this function with dlopen()/dlsym() and calls it from
* "load driver" function.
*/
_EGLDriver *
_eglMain(const char *args)
{
_EGLDriver *drv;
drv = (_EGLDriver *) calloc(1, sizeof(_EGLDriver));
if (!drv) {
return NULL;
}
/* First fill in the dispatch table with defaults */
_eglInitDriverFallbacks(drv);
/* then plug in our Drm-specific functions */
drv->API.Initialize = drm_initialize;
drv->API.Terminate = drm_terminate;
drv->API.CreateContext = drm_create_context;
drv->API.MakeCurrent = drm_make_current;
drv->API.CreateWindowSurface = drm_create_window_surface;
drv->API.CreatePixmapSurface = drm_create_pixmap_surface;
drv->API.CreatePbufferSurface = drm_create_pbuffer_surface;
drv->API.DestroySurface = drm_destroy_surface;
drv->API.DestroyContext = drm_destroy_context;
drv->API.CreateScreenSurfaceMESA = drm_create_screen_surface_mesa;
drv->API.ShowScreenSurfaceMESA = drm_show_screen_surface_mesa;
drv->API.SwapBuffers = drm_swap_buffers;
drv->Name = "DRM/Gallium/Win";
drv->Unload = drm_unload;
return drv;
}
/**
* The bootstrap function. Return a new fbDriver object and
* plug in API functions.
*/
_EGLDriver *
_eglMain(_EGLDisplay *dpy)
{
fbDriver *fb;
fb = (fbDriver *) calloc(1, sizeof(fbDriver));
if (!fb) {
return NULL;
}
/* First fill in the dispatch table with defaults */
_eglInitDriverFallbacks(&fb->Base);
/* then plug in our fb-specific functions */
fb->Base.Initialize = fbInitialize;
fb->Base.Terminate = fbTerminate;
fb->Base.CreateContext = fbCreateContext;
fb->Base.MakeCurrent = fbMakeCurrent;
fb->Base.CreateWindowSurface = fbCreateWindowSurface;
fb->Base.CreatePixmapSurface = fbCreatePixmapSurface;
fb->Base.CreatePbufferSurface = fbCreatePbufferSurface;
fb->Base.DestroySurface = fbDestroySurface;
fb->Base.DestroyContext = fbDestroyContext;
fb->Base.CreateScreenSurfaceMESA = fbCreateScreenSurfaceMESA;
fb->Base.ShowSurfaceMESA = fbShowSurfaceMESA;
fb->Base.SwapBuffers = fbSwapBuffers;
/* enable supported extensions */
fb->Base.MESA_screen_surface = EGL_TRUE;
fb->Base.MESA_copy_context = EGL_TRUE;
return &fb->Base;
}
/**
* This is the main entrypoint into the driver, called by libEGL.
* Create a new _EGLDriver object and init its dispatch table.
*/
_EGLDriver *
_eglMain(const char *args)
{
struct xdri_egl_driver *xdri_drv = CALLOC_STRUCT(xdri_egl_driver);
if (!xdri_drv)
return NULL;
_eglInitDriverFallbacks(&xdri_drv->Base);
xdri_drv->Base.API.Initialize = xdri_eglInitialize;
xdri_drv->Base.API.Terminate = xdri_eglTerminate;
xdri_drv->Base.API.GetProcAddress = xdri_eglGetProcAddress;
xdri_drv->Base.API.CreateContext = xdri_eglCreateContext;
xdri_drv->Base.API.DestroyContext = xdri_eglDestroyContext;
xdri_drv->Base.API.MakeCurrent = xdri_eglMakeCurrent;
xdri_drv->Base.API.CreateWindowSurface = xdri_eglCreateWindowSurface;
xdri_drv->Base.API.CreatePbufferSurface = xdri_eglCreatePbufferSurface;
xdri_drv->Base.API.DestroySurface = xdri_eglDestroySurface;
xdri_drv->Base.API.BindTexImage = xdri_eglBindTexImage;
xdri_drv->Base.API.ReleaseTexImage = xdri_eglReleaseTexImage;
xdri_drv->Base.API.SwapBuffers = xdri_eglSwapBuffers;
xdri_drv->Base.Name = "X/DRI";
xdri_drv->Base.Unload = xdri_Unload;
return &xdri_drv->Base;
}
void
egl_g3d_init_driver_api(_EGLDriver *drv)
{
_eglInitDriverFallbacks(drv);
drv->API.ChooseConfig = egl_g3d_choose_config;
drv->API.CreateContext = egl_g3d_create_context;
drv->API.DestroyContext = egl_g3d_destroy_context;
drv->API.CreateWindowSurface = egl_g3d_create_window_surface;
drv->API.CreatePixmapSurface = egl_g3d_create_pixmap_surface;
drv->API.CreatePbufferSurface = egl_g3d_create_pbuffer_surface;
drv->API.CreatePbufferFromClientBuffer = egl_g3d_create_pbuffer_from_client_buffer;
drv->API.DestroySurface = egl_g3d_destroy_surface;
drv->API.MakeCurrent = egl_g3d_make_current;
drv->API.SwapBuffers = egl_g3d_swap_buffers;
drv->API.CopyBuffers = egl_g3d_copy_buffers;
drv->API.WaitClient = egl_g3d_wait_client;
drv->API.WaitNative = egl_g3d_wait_native;
drv->API.BindTexImage = egl_g3d_bind_tex_image;
drv->API.ReleaseTexImage = egl_g3d_release_tex_image;
drv->API.CreateImageKHR = egl_g3d_create_image;
drv->API.DestroyImageKHR = egl_g3d_destroy_image;
#ifdef EGL_MESA_drm_image
drv->API.CreateDRMImageMESA = egl_g3d_create_drm_image;
drv->API.ExportDRMImageMESA = egl_g3d_export_drm_image;
#endif
#ifdef EGL_WL_bind_wayland_display
drv->API.BindWaylandDisplayWL = egl_g3d_bind_wayland_display_wl;
drv->API.UnbindWaylandDisplayWL = egl_g3d_unbind_wayland_display_wl;
drv->API.QueryWaylandBufferWL = egl_g3d_query_wayland_buffer_wl;
#endif
drv->API.CreateSyncKHR = egl_g3d_create_sync;
drv->API.DestroySyncKHR = egl_g3d_destroy_sync;
drv->API.ClientWaitSyncKHR = egl_g3d_client_wait_sync;
drv->API.SignalSyncKHR = egl_g3d_signal_sync;
#ifdef EGL_MESA_screen_surface
drv->API.CreateScreenSurfaceMESA = egl_g3d_create_screen_surface;
drv->API.ShowScreenSurfaceMESA = egl_g3d_show_screen_surface;
#endif
#ifdef EGL_NOK_swap_region
drv->API.SwapBuffersRegionNOK = egl_g3d_swap_buffers_region;
#endif
drv->API.PostSubBufferNV = egl_g3d_post_sub_buffer;
}
_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;
}
/**
* This is the main entrypoint into the driver.
* Called by libEGL to instantiate an _EGLDriver object.
*/
_EGLDriver *
_eglMain(_EGLDisplay *dpy, const char *args)
{
struct xlib_egl_driver *xdrv;
_eglLog(_EGL_INFO, "Entering EGL/Xlib _eglMain(%s)", args);
xdrv = CALLOC_STRUCT(xlib_egl_driver);
if (!xdrv)
return NULL;
if (!dpy->Xdpy) {
dpy->Xdpy = XOpenDisplay(NULL);
}
_eglInitDriverFallbacks(&xdrv->Base);
xdrv->Base.API.Initialize = xlib_eglInitialize;
xdrv->Base.API.Terminate = xlib_eglTerminate;
xdrv->Base.API.GetProcAddress = xlib_eglGetProcAddress;
xdrv->Base.API.CreateContext = xlib_eglCreateContext;
xdrv->Base.API.DestroyContext = xlib_eglDestroyContext;
xdrv->Base.API.CreateWindowSurface = xlib_eglCreateWindowSurface;
xdrv->Base.API.DestroySurface = xlib_eglDestroySurface;
xdrv->Base.API.MakeCurrent = xlib_eglMakeCurrent;
xdrv->Base.API.SwapBuffers = xlib_eglSwapBuffers;
xdrv->Base.ClientAPIsMask = find_supported_apis();
if (xdrv->Base.ClientAPIsMask == 0x0) {
/* the app isn't directly linked with any EGL-supprted APIs
* (such as libGLESv2.so) so use an EGL utility to see what
* APIs might be loaded dynamically on this system.
*/
xdrv->Base.ClientAPIsMask = _eglFindAPIs();
}
xdrv->Base.Name = "Xlib/softpipe";
/* create one winsys and use it for all contexts/surfaces */
xdrv->winsys = create_sw_winsys();
xdrv->winsys->flush_frontbuffer = flush_frontbuffer;
xdrv->screen = softpipe_create_screen(xdrv->winsys);
return &xdrv->Base;
}
/**
* This is the main entrypoint into the driver, called by egl dispatch API.
* Create a new _EGLDriver object and init its dispatch table.
*/
_EGLDriver* _eglMain(const char *args)
{
_EGLDriverPPAPI *drv = (_EGLDriverPPAPI *)
calloc(1, sizeof(_EGLDriverPPAPI));
if (!drv)
return NULL;
_eglInitDriverFallbacks(&drv->Base);
drv->Base.API.Initialize = _eglInitializePPAPI;
drv->Base.API.Terminate = _eglTerminatePPAPI;
drv->Base.API.CreateContext = _eglCreateContextPPAPI;
drv->Base.API.DestroyContext = _eglDestroyContextPPAPI;
drv->Base.API.CreateWindowSurface = _eglCreateWindowSurfacePPAPI;
drv->Base.API.CreatePbufferSurface = _eglCreatePbufferSurfacePPAPI;
drv->Base.API.DestroySurface = _eglDestroySurfacePPAPI;
drv->Base.API.SwapBuffers = _eglSwapBuffersPPAPI;
drv->Base.Name = "PPAPI";
drv->Base.Unload = _unloadPPAPI;
return &drv->Base;
}
