workbench/libs/mesa/src/egl/drivers/arosmesa/egl_arosmesa.c

   1 /*
   2     Copyright 2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include "eglsurface.h"
   7 #include "eglcontext.h"
   8 #include "eglconfig.h"
   9 #include "egldisplay.h"
  10 #include "egldriver.h"
  11
  12 #include <stdlib.h>
  13
  14 #include <GL/gla.h>
  15
  16 extern struct Library * GLBase;
  17
  18 /* General note: due to fact that AROSMesa API is not symmetric with EGL api,
  19  * AROSMesa context is not created in EGL create context, but in EGL MakeCurrent
  20  */
  21
  22 struct egl_arosmesa
  23 {
  24     _EGLDriver base;
  25 };
  26
  27 struct egl_arosmesa_context
  28 {
  29     _EGLContext base;
  30     GLAContext amesactx;
  31 };
  32
  33 static inline struct egl_arosmesa_context * egl_arosmesa_context(_EGLContext * ctx)
  34 {
  35     return (struct egl_arosmesa_context *)ctx;
  36 }
  37
  38 struct egl_arosmesa_surface
  39 {
  40     _EGLSurface base;
  41     struct Window * win;
  42 };
  43
  44 static _EGLProc egl_arosmesa_getprocaddress(_EGLDriver *drv, const char *procname)
  45 {
  46     (void) drv;
  47
  48     return glAGetProcAddress(procname);
  49 }
  50
  51 static EGLBoolean egl_arosmesa_terminate(_EGLDriver *drv, _EGLDisplay *disp)
  52 {
  53     _eglReleaseDisplayResources(drv, disp);
  54     _eglCleanupDisplay(disp);
  55
  56     disp->DriverData = NULL;
  57
  58     return EGL_TRUE;
  59 }
  60
  61 static EGLBoolean egl_arosmesa_destroycontext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
  62 {
  63     (void) drv;
  64
  65     if (_eglPutContext(ctx))
  66     {
  67         struct egl_arosmesa_context * eglctx = egl_arosmesa_context(ctx);
  68         glAMakeCurrent(NULL);
  69         if (eglctx->amesactx)
  70             glADestroyContext(eglctx->amesactx);
  71         free(eglctx);
  72     }
  73
  74     return EGL_TRUE;
  75 }
  76
  77 static EGLBoolean egl_arosmesa_destroysurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
  78 {
  79     (void) drv;
  80
  81     if (_eglPutSurface(surf))
  82     {
  83         free(surf);
  84     }
  85
  86     return EGL_TRUE;
  87 }
  88
  89 static EGLBoolean egl_arosmesa_swapbuffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
  90 {
  91     glASwapBuffers(disp->DriverData);
  92     return EGL_TRUE;
  93 }
  94
  95 static EGLBoolean egl_arosmesa_makecurrent(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
  96         _EGLSurface *rsurf, _EGLContext *ctx)
  97 {
  98     _EGLContext *old_ctx;
  99     _EGLSurface *old_dsurf, *old_rsurf;
 100
 101     if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
 102         return EGL_FALSE;
 103
 104     /* Since AROSMesa API is not symmetric with EGL, context handling needs to be performed here */
 105
 106     /* Do nothing */
 107     if ((ctx == NULL) && (old_ctx == NULL))
 108         return EGL_TRUE;
 109
 110     /* Unbind the current context */
 111     if ((ctx == NULL) && (old_ctx != NULL))
 112     {
 113         glAMakeCurrent(NULL);
 114         _eglPutSurface(old_dsurf);
 115         _eglPutSurface(old_rsurf);
 116         _eglPutContext(old_ctx);
 117         disp->DriverData = NULL;
 118         return EGL_TRUE;
 119     }
 120
 121     /* Create when needed and bind new context */
 122     if (ctx != NULL)
 123     {
 124         struct egl_arosmesa_context * eglctx = egl_arosmesa_context(ctx);
 125
 126         if (old_ctx != NULL)
 127         {
 128             _eglPutSurface(old_dsurf);
 129             _eglPutSurface(old_rsurf);
 130             _eglPutContext(old_ctx);
 131             disp->DriverData = NULL;
 132         }
 133
 134         if (eglctx->amesactx == NULL)
 135         {
 136             struct TagItem attributes [14];
 137             struct Window * win = ((struct egl_arosmesa_surface *)dsurf)->win;
 138             int i = 0;
 139
 140             attributes[i].ti_Tag = GLA_Window;      attributes[i++].ti_Data = (IPTR)win;
 141             attributes[i].ti_Tag = GLA_Left;        attributes[i++].ti_Data = win->BorderLeft;
 142             attributes[i].ti_Tag = GLA_Top;         attributes[i++].ti_Data = win->BorderTop;
 143             attributes[i].ti_Tag = GLA_Bottom;      attributes[i++].ti_Data = win->BorderBottom;
 144             attributes[i].ti_Tag = GLA_Right;       attributes[i++].ti_Data = win->BorderRight;
 145
 146             attributes[i].ti_Tag = GLA_DoubleBuf;   attributes[i++].ti_Data = GL_TRUE;
 147
 148             attributes[i].ti_Tag = GLA_RGBMode;     attributes[i++].ti_Data = GL_TRUE;
 149
 150             attributes[i].ti_Tag = GLA_NoStencil;   attributes[i++].ti_Data = GL_TRUE;
 151             attributes[i].ti_Tag = GLA_NoAccum;     attributes[i++].ti_Data = GL_TRUE;
 152
 153             attributes[i].ti_Tag = TAG_DONE;
 154
 155             eglctx->amesactx = glACreateContext(attributes);
 156         }
 157
 158         if (eglctx->amesactx != NULL)
 159         {
 160             glAMakeCurrent(eglctx->amesactx);
 161             disp->DriverData = eglctx->amesactx;
 162             return EGL_TRUE;
 163         }
 164     }
 165
 166     return EGL_FALSE;
 167 }
 168
 169 static _EGLSurface * egl_arosmesa_createwindowsurface(_EGLDriver *drv, _EGLDisplay *disp,
 170         _EGLConfig *conf, EGLNativeWindowType window, const EGLint *attrib_list)
 171 {
 172     struct egl_arosmesa_surface * surf = calloc(1, sizeof(struct egl_arosmesa_surface));
 173
 174     if (!_eglInitSurface(&surf->base, disp, EGL_WINDOW_BIT, conf, attrib_list))
 175     {
 176         free(surf);
 177         return NULL;
 178     }
 179
 180     surf->base.Width = window->Width - window->BorderLeft - window->BorderRight;
 181     surf->base.Height = window->Height - window->BorderTop -  window->BorderBottom;
 182     surf->win = window;
 183
 184     return &surf->base;
 185 }
 186
 187 static _EGLContext * egl_arosmesa_createcontext(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
 188         _EGLContext *share_list, const EGLint *attrib_list)
 189 {
 190     struct egl_arosmesa_context * ctx = calloc(1, sizeof(struct egl_arosmesa_context));
 191
 192     if (!_eglInitContext(&ctx->base, disp, conf, attrib_list))
 193     {
 194         free(ctx);
 195         return NULL;
 196     }
 197
 198     ctx->amesactx = NULL; /* Context is created elsewhere */
 199
 200     return &ctx->base;
 201 }
 202
 203 static void create_configs(_EGLDisplay *dpy)
 204 {
 205     _EGLConfig * cfg = calloc(1, sizeof(_EGLConfig));
 206     _eglInitConfig(cfg, dpy, 1);
 207
 208     cfg->RenderableType = EGL_OPENGL_BIT;
 209     cfg->Conformant = EGL_OPENGL_BIT;
 210     cfg->SurfaceType = EGL_WINDOW_BIT;
 211
 212     _eglSetConfigKey(cfg, EGL_RED_SIZE, 8);
 213     _eglSetConfigKey(cfg, EGL_GREEN_SIZE, 8);
 214     _eglSetConfigKey(cfg, EGL_BLUE_SIZE, 8);
 215     _eglSetConfigKey(cfg, EGL_ALPHA_SIZE, 8);
 216     _eglSetConfigKey(cfg, EGL_DEPTH_SIZE, 24);
 217     _eglSetConfigKey(cfg, EGL_STENCIL_SIZE, 8);
 218
 219     _eglLinkConfig(cfg);
 220 }
 221
 222 static EGLBoolean
 223 egl_arosmesa_initialize(_EGLDriver *drv, _EGLDisplay *dpy)
 224 {
 225     if (dpy->Options.TestOnly)
 226         return EGL_TRUE;
 227
 228     create_configs(dpy);
 229
 230     dpy->ClientAPIs |= EGL_OPENGL_BIT;
 231     dpy->VersionMajor = 1;
 232     dpy->VersionMinor = 4;
 233
 234     return EGL_TRUE;
 235 }
 236
 237 void egl_arosmesa_init_driver_api(_EGLDriver * drv)
 238 {
 239
 240     _eglInitDriverFallbacks(drv);
 241
 242     drv->API.Initialize = egl_arosmesa_initialize;
 243     drv->API.CreateContext = egl_arosmesa_createcontext;
 244     drv->API.CreateWindowSurface = egl_arosmesa_createwindowsurface;
 245     drv->API.MakeCurrent = egl_arosmesa_makecurrent;
 246     drv->API.SwapBuffers = egl_arosmesa_swapbuffers;
 247     drv->API.DestroySurface = egl_arosmesa_destroysurface;
 248     drv->API.DestroyContext = egl_arosmesa_destroycontext;
 249     drv->API.Terminate = egl_arosmesa_terminate;
 250     drv->API.GetProcAddress = egl_arosmesa_getprocaddress;
 251 }
 252
 253 void egl_arosmesa_unload(_EGLDriver *drv)
 254 {
 255     free(drv);
 256 }
 257
 258 _EGLDriver *
 259 _eglBuiltInDriverAROSMesa(const char *args)
 260 {
 261     struct egl_arosmesa * drv = calloc(1, sizeof(struct egl_arosmesa));
 262
 263     if (!GLBase)
 264         GLBase = OpenLibrary("gl.library", 20L);
 265
 266     if (GLBase)
 267     {
 268         egl_arosmesa_init_driver_api(&drv->base);
 269         drv->base.Name = "AROSMesa";
 270         drv->base.Unload = egl_arosmesa_unload;
 271
 272         return &drv->base;
 273     }
 274     else
 275         return NULL;
 276 }
 277
 278 static VOID CloseMesa()
 279 {
 280     if (GLBase)
 281     {
 282         CloseLibrary(GLBase);
 283         GLBase = NULL;
 284     }
 285 }
 286
 287 ADD2EXPUNGELIB(CloseMesa, 5)