src/OpenGL/libEGL/main.cpp

   1 // SwiftShader Software Renderer\r
   2 //\r
   3 // Copyright(c) 2005-2013 TransGaming Inc.\r
   4 //\r
   5 // All rights reserved. No part of this software may be copied, distributed, transmitted,\r
   6 // transcribed, stored in a retrieval system, translated into any human or computer\r
   7 // language by any means, or disclosed to third parties without the explicit written\r
   8 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
   9 // or implied, including but not limited to any patent rights, are granted to you.\r
  10 //\r
  11 \r
  12 // main.cpp: DLL entry point and management of thread-local data.\r
  13 \r
  14 #include "main.h"\r
  15 \r
  16 #include "libEGL.hpp"\r
  17 #include "Context.hpp"\r
  18 #include "Surface.h"\r
  19 \r
  20 #include "resource.h"\r
  21 #include "Common/Thread.hpp"\r
  22 #include "Common/SharedLibrary.hpp"\r
  23 #include "common/debug.h"\r
  24 \r
  25 #include <EGL/eglext.h>\r
  26 \r
  27 static sw::Thread::LocalStorageKey currentTLS = TLS_OUT_OF_INDEXES;\r
  28 \r
  29 #if !defined(_MSC_VER)\r
  30 #define CONSTRUCTOR __attribute__((constructor))\r
  31 #define DESTRUCTOR __attribute__((destructor))\r
  32 #else\r
  33 #define CONSTRUCTOR\r
  34 #define DESTRUCTOR\r
  35 #endif\r
  36 \r
  37 static void eglAttachThread()\r
  38 {\r
  39     TRACE("()");\r
  40 \r
  41     egl::Current *current = new egl::Current;\r
  42 \r
  43     if(current)\r
  44     {\r
  45         sw::Thread::setLocalStorage(currentTLS, current);\r
  46 \r
  47         current->error = EGL_SUCCESS;\r
  48         current->API = EGL_OPENGL_ES_API;\r
  49                 current->display = nullptr;\r
  50                 current->context = nullptr;\r
  51                 current->drawSurface = nullptr;\r
  52         current->readSurface = nullptr;\r
  53         }\r
  54 }\r
  55 \r
  56 static void eglDetachThread()\r
  57 {\r
  58     TRACE("()");\r
  59 \r
  60         egl::Current *current = (egl::Current*)sw::Thread::getLocalStorage(currentTLS);\r
  61 \r
  62         if(current)\r
  63         {\r
  64         delete current;\r
  65         }\r
  66 }\r
  67 \r
  68 CONSTRUCTOR static void eglAttachProcess()\r
  69 {\r
  70     TRACE("()");\r
  71 \r
  72         #if !defined(ANGLE_DISABLE_TRACE) && defined(TRACE_OUTPUT_FILE)\r
  73         FILE *debug = fopen(TRACE_OUTPUT_FILE, "rt");\r
  74 \r
  75         if(debug)\r
  76         {\r
  77             fclose(debug);\r
  78             debug = fopen(TRACE_OUTPUT_FILE, "wt");   // Erase\r
  79             fclose(debug);\r
  80         }\r
  81         #endif\r
  82 \r
  83     currentTLS = sw::Thread::allocateLocalStorageKey();\r
  84 \r
  85     if(currentTLS == TLS_OUT_OF_INDEXES)\r
  86     {\r
  87         return;\r
  88     }\r
  89 \r
  90         eglAttachThread();\r
  91 }\r
  92 \r
  93 DESTRUCTOR static void eglDetachProcess()\r
  94 {\r
  95     TRACE("()");\r
  96 \r
  97         eglDetachThread();\r
  98         sw::Thread::freeLocalStorageKey(currentTLS);\r
  99 }\r
 100 \r
 101 #if defined(_WIN32)\r
 102 static INT_PTR CALLBACK DebuggerWaitDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)\r
 103 {\r
 104         RECT rect;\r
 105 \r
 106     switch(uMsg)\r
 107     {\r
 108     case WM_INITDIALOG:\r
 109                 GetWindowRect(GetDesktopWindow(), &rect);\r
 110                 SetWindowPos(hwnd, HWND_TOP, rect.right / 2, rect.bottom / 2, 0, 0, SWP_NOSIZE);\r
 111                 SetTimer(hwnd, 1, 100, NULL);\r
 112                 return TRUE;\r
 113     case WM_COMMAND:\r
 114         if(LOWORD(wParam) == IDCANCEL)\r
 115                 {\r
 116                         EndDialog(hwnd, 0);\r
 117                 }\r
 118         break;\r
 119     case WM_TIMER:\r
 120                 if(IsDebuggerPresent())\r
 121                 {\r
 122                         EndDialog(hwnd, 0);\r
 123                 }\r
 124     }\r
 125 \r
 126     return FALSE;\r
 127 }\r
 128 \r
 129 static void WaitForDebugger(HINSTANCE instance)\r
 130 {\r
 131     if(!IsDebuggerPresent())\r
 132     {\r
 133         HRSRC dialog = FindResource(instance, MAKEINTRESOURCE(IDD_DIALOG1), RT_DIALOG);\r
 134                 DLGTEMPLATE *dialogTemplate = (DLGTEMPLATE*)LoadResource(instance, dialog);\r
 135                 DialogBoxIndirect(instance, dialogTemplate, NULL, DebuggerWaitDialogProc);\r
 136     }\r
 137 }\r
 138 \r
 139 extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)\r
 140 {\r
 141     switch(reason)\r
 142     {\r
 143     case DLL_PROCESS_ATTACH:\r
 144                 #ifndef NDEBUG\r
 145                         WaitForDebugger(instance);\r
 146                 #endif\r
 147         eglAttachProcess();\r
 148         break;\r
 149     case DLL_THREAD_ATTACH:\r
 150         eglAttachThread();\r
 151         break;\r
 152     case DLL_THREAD_DETACH:\r
 153         eglDetachThread();\r
 154         break;\r
 155     case DLL_PROCESS_DETACH:\r
 156         eglDetachProcess();\r
 157         break;\r
 158     default:\r
 159         break;\r
 160     }\r
 161 \r
 162     return TRUE;\r
 163 }\r
 164 #endif\r
 165 \r
 166 namespace egl\r
 167 {\r
 168 static Current *eglGetCurrent(void)\r
 169 {\r
 170         Current *current = (Current*)sw::Thread::getLocalStorage(currentTLS);\r
 171 \r
 172         if(!current)\r
 173         {\r
 174                 eglAttachThread();\r
 175         }\r
 176 \r
 177         return (Current*)sw::Thread::getLocalStorage(currentTLS);\r
 178 }\r
 179 \r
 180 void setCurrentError(EGLint error)\r
 181 {\r
 182     Current *current = eglGetCurrent();\r
 183 \r
 184     current->error = error;\r
 185 }\r
 186 \r
 187 EGLint getCurrentError()\r
 188 {\r
 189     Current *current = eglGetCurrent();\r
 190 \r
 191     return current->error;\r
 192 }\r
 193 \r
 194 void setCurrentAPI(EGLenum API)\r
 195 {\r
 196     Current *current = eglGetCurrent();\r
 197 \r
 198     current->API = API;\r
 199 }\r
 200 \r
 201 EGLenum getCurrentAPI()\r
 202 {\r
 203     Current *current = eglGetCurrent();\r
 204 \r
 205     return current->API;\r
 206 }\r
 207 \r
 208 void setCurrentDisplay(egl::Display *dpy)\r
 209 {\r
 210     Current *current = eglGetCurrent();\r
 211 \r
 212     current->display = dpy;\r
 213 }\r
 214 \r
 215 egl::Display *getCurrentDisplay()\r
 216 {\r
 217     Current *current = eglGetCurrent();\r
 218 \r
 219     return current->display;\r
 220 }\r
 221 \r
 222 void setCurrentContext(egl::Context *ctx)\r
 223 {\r
 224     Current *current = eglGetCurrent();\r
 225 \r
 226         if(ctx)\r
 227         {\r
 228                 ctx->addRef();\r
 229         }\r
 230 \r
 231         if(current->context)\r
 232         {\r
 233                 current->context->release();\r
 234         }\r
 235 \r
 236     current->context = ctx;\r
 237 }\r
 238 \r
 239 egl::Context *getCurrentContext()\r
 240 {\r
 241     Current *current = eglGetCurrent();\r
 242 \r
 243     return current->context;\r
 244 }\r
 245 \r
 246 void setCurrentDrawSurface(egl::Surface *surface)\r
 247 {\r
 248     Current *current = eglGetCurrent();\r
 249 \r
 250         if(surface)\r
 251         {\r
 252                 surface->addRef();\r
 253         }\r
 254 \r
 255         if(current->drawSurface)\r
 256         {\r
 257                 current->drawSurface->release();\r
 258         }\r
 259 \r
 260     current->drawSurface = surface;\r
 261 }\r
 262 \r
 263 egl::Surface *getCurrentDrawSurface()\r
 264 {\r
 265     Current *current = eglGetCurrent();\r
 266 \r
 267     return current->drawSurface;\r
 268 }\r
 269 \r
 270 void setCurrentReadSurface(egl::Surface *surface)\r
 271 {\r
 272     Current *current = eglGetCurrent();\r
 273 \r
 274         if(surface)\r
 275         {\r
 276                 surface->addRef();\r
 277         }\r
 278 \r
 279         if(current->readSurface)\r
 280         {\r
 281                 current->readSurface->release();\r
 282         }\r
 283 \r
 284     current->readSurface = surface;\r
 285 }\r
 286 \r
 287 egl::Surface *getCurrentReadSurface()\r
 288 {\r
 289     Current *current = eglGetCurrent();\r
 290 \r
 291     return current->readSurface;\r
 292 }\r
 293 \r
 294 void error(EGLint errorCode)\r
 295 {\r
 296     egl::setCurrentError(errorCode);\r
 297 \r
 298         if(errorCode != EGL_SUCCESS)\r
 299         {\r
 300                 switch(errorCode)\r
 301                 {\r
 302                 case EGL_NOT_INITIALIZED:     TRACE("\t! Error generated: not initialized\n");     break;\r
 303                 case EGL_BAD_ACCESS:          TRACE("\t! Error generated: bad access\n");          break;\r
 304                 case EGL_BAD_ALLOC:           TRACE("\t! Error generated: bad alloc\n");           break;\r
 305                 case EGL_BAD_ATTRIBUTE:       TRACE("\t! Error generated: bad attribute\n");       break;\r
 306                 case EGL_BAD_CONFIG:          TRACE("\t! Error generated: bad config\n");          break;\r
 307                 case EGL_BAD_CONTEXT:         TRACE("\t! Error generated: bad context\n");         break;\r
 308                 case EGL_BAD_CURRENT_SURFACE: TRACE("\t! Error generated: bad current surface\n"); break;\r
 309                 case EGL_BAD_DISPLAY:         TRACE("\t! Error generated: bad display\n");         break;\r
 310                 case EGL_BAD_MATCH:           TRACE("\t! Error generated: bad match\n");           break;\r
 311                 case EGL_BAD_NATIVE_PIXMAP:   TRACE("\t! Error generated: bad native pixmap\n");   break;\r
 312                 case EGL_BAD_NATIVE_WINDOW:   TRACE("\t! Error generated: bad native window\n");   break;\r
 313                 case EGL_BAD_PARAMETER:       TRACE("\t! Error generated: bad parameter\n");       break;\r
 314                 case EGL_BAD_SURFACE:         TRACE("\t! Error generated: bad surface\n");         break;\r
 315                 case EGL_CONTEXT_LOST:        TRACE("\t! Error generated: context lost\n");        break;\r
 316                 default:                      TRACE("\t! Error generated: <0x%X>\n", errorCode);   break;\r
 317                 }\r
 318         }\r
 319 }\r
 320 }\r
 321 \r
 322 namespace egl\r
 323 {\r
 324 EGLint GetError(void);\r
 325 EGLDisplay GetDisplay(EGLNativeDisplayType display_id);\r
 326 EGLBoolean Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor);\r
 327 EGLBoolean Terminate(EGLDisplay dpy);\r
 328 const char *QueryString(EGLDisplay dpy, EGLint name);\r
 329 EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);\r
 330 EGLBoolean ChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);\r
 331 EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);\r
 332 EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list);\r
 333 EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);\r
 334 EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);\r
 335 EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface);\r
 336 EGLBoolean QuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);\r
 337 EGLBoolean BindAPI(EGLenum api);\r
 338 EGLenum QueryAPI(void);\r
 339 EGLBoolean WaitClient(void);\r
 340 EGLBoolean ReleaseThread(void);\r
 341 EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);\r
 342 EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);\r
 343 EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);\r
 344 EGLBoolean ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);\r
 345 EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval);\r
 346 EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);\r
 347 EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx);\r
 348 EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);\r
 349 EGLContext GetCurrentContext(void);\r
 350 EGLSurface GetCurrentSurface(EGLint readdraw);\r
 351 EGLDisplay GetCurrentDisplay(void);\r
 352 EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);\r
 353 EGLBoolean WaitGL(void);\r
 354 EGLBoolean WaitNative(EGLint engine);\r
 355 EGLBoolean SwapBuffers(EGLDisplay dpy, EGLSurface surface);\r
 356 EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);\r
 357 EGLImageKHR CreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);\r
 358 EGLBoolean DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image);\r
 359 EGLDisplay GetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list);\r
 360 EGLSurface CreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);\r
 361 EGLSurface CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);\r
 362 EGLSyncKHR CreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);\r
 363 EGLBoolean DestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);\r
 364 EGLint ClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);\r
 365 EGLBoolean GetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);\r
 366 __eglMustCastToProperFunctionPointerType GetProcAddress(const char *procname);\r
 367 }\r
 368 \r
 369 extern "C"\r
 370 {\r
 371 EGLAPI EGLint EGLAPIENTRY eglGetError(void)\r
 372 {\r
 373         return egl::GetError();\r
 374 }\r
 375 \r
 376 EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)\r
 377 {\r
 378         return egl::GetDisplay(display_id);\r
 379 }\r
 380 \r
 381 EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)\r
 382 {\r
 383         return egl::Initialize(dpy, major, minor);\r
 384 }\r
 385 \r
 386 EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)\r
 387 {\r
 388         return egl::Terminate(dpy);\r
 389 }\r
 390 \r
 391 EGLAPI const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)\r
 392 {\r
 393         return egl::QueryString(dpy, name);\r
 394 }\r
 395 \r
 396 EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)\r
 397 {\r
 398         return egl::GetConfigs(dpy, configs, config_size, num_config);\r
 399 }\r
 400 \r
 401 EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)\r
 402 {\r
 403         return egl::ChooseConfig(dpy, attrib_list, configs, config_size, num_config);\r
 404 }\r
 405 \r
 406 EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)\r
 407 {\r
 408         return egl::GetConfigAttrib(dpy, config, attribute, value);\r
 409 }\r
 410 \r
 411 EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list)\r
 412 {\r
 413         return egl::CreateWindowSurface(dpy, config, window, attrib_list);\r
 414 }\r
 415 \r
 416 EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)\r
 417 {\r
 418         return egl::CreatePbufferSurface(dpy, config, attrib_list);\r
 419 }\r
 420 \r
 421 EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)\r
 422 {\r
 423         return egl::CreatePixmapSurface(dpy, config, pixmap, attrib_list);\r
 424 }\r
 425 \r
 426 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)\r
 427 {\r
 428         return egl::DestroySurface(dpy, surface);\r
 429 }\r
 430 \r
 431 EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)\r
 432 {\r
 433         return egl::QuerySurface(dpy, surface, attribute, value);\r
 434 }\r
 435 \r
 436 EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)\r
 437 {\r
 438         return egl::BindAPI(api);\r
 439 }\r
 440 \r
 441 EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void)\r
 442 {\r
 443         return egl::QueryAPI();\r
 444 }\r
 445 \r
 446 EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void)\r
 447 {\r
 448         return egl::WaitClient();\r
 449 }\r
 450 \r
 451 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void)\r
 452 {\r
 453         return egl::ReleaseThread();\r
 454 }\r
 455 \r
 456 EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)\r
 457 {\r
 458         return egl::CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);\r
 459 }\r
 460 \r
 461 EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)\r
 462 {\r
 463         return egl::SurfaceAttrib(dpy, surface, attribute, value);\r
 464 }\r
 465 \r
 466 EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)\r
 467 {\r
 468         return egl::BindTexImage(dpy, surface, buffer);\r
 469 }\r
 470 \r
 471 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)\r
 472 {\r
 473         return egl::ReleaseTexImage(dpy, surface, buffer);\r
 474 }\r
 475 \r
 476 EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)\r
 477 {\r
 478         return egl::SwapInterval(dpy, interval);\r
 479 }\r
 480 \r
 481 EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)\r
 482 {\r
 483         return egl::CreateContext(dpy, config, share_context, attrib_list);\r
 484 }\r
 485 \r
 486 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)\r
 487 {\r
 488         return egl::DestroyContext(dpy, ctx);\r
 489 }\r
 490 \r
 491 EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)\r
 492 {\r
 493         return egl::MakeCurrent(dpy, draw, read, ctx);\r
 494 }\r
 495 \r
 496 EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void)\r
 497 {\r
 498         return egl::GetCurrentContext();\r
 499 }\r
 500 \r
 501 EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)\r
 502 {\r
 503         return egl::GetCurrentSurface(readdraw);\r
 504 }\r
 505 \r
 506 EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)\r
 507 {\r
 508         return egl::GetCurrentDisplay();\r
 509 }\r
 510 \r
 511 EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)\r
 512 {\r
 513         return egl::QueryContext(dpy, ctx, attribute, value);\r
 514 }\r
 515 \r
 516 EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void)\r
 517 {\r
 518         return egl::WaitClient();\r
 519 }\r
 520 \r
 521 EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)\r
 522 {\r
 523         return egl::WaitNative(engine);\r
 524 }\r
 525 \r
 526 EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)\r
 527 {\r
 528         return egl::SwapBuffers(dpy, surface);\r
 529 }\r
 530 \r
 531 EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)\r
 532 {\r
 533         return egl::CopyBuffers(dpy, surface, target);\r
 534 }\r
 535 \r
 536 EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)\r
 537 {\r
 538         return egl::CreateImageKHR(dpy, ctx, target, buffer, attrib_list);\r
 539 }\r
 540 \r
 541 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)\r
 542 {\r
 543         return egl::DestroyImageKHR(dpy, image);\r
 544 }\r
 545 \r
 546 EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list)\r
 547 {\r
 548         return egl::GetPlatformDisplayEXT(platform, native_display, attrib_list);\r
 549 }\r
 550 \r
 551 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list)\r
 552 {\r
 553         return egl::CreatePlatformWindowSurfaceEXT(dpy, config, native_window, attrib_list);\r
 554 }\r
 555 \r
 556 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list)\r
 557 {\r
 558         return egl::CreatePlatformPixmapSurfaceEXT(dpy, config, native_pixmap, attrib_list);\r
 559 }\r
 560 \r
 561 EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)\r
 562 {\r
 563         return egl::CreateSyncKHR(dpy, type, attrib_list);\r
 564 }\r
 565 \r
 566 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)\r
 567 {\r
 568         return egl::DestroySyncKHR(dpy, sync);\r
 569 }\r
 570 \r
 571 EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)\r
 572 {\r
 573         return egl::ClientWaitSyncKHR(dpy, sync, flags, timeout);\r
 574 }\r
 575 \r
 576 EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value)\r
 577 {\r
 578         return egl::GetSyncAttribKHR(dpy, sync, attribute, value);\r
 579 }\r
 580 \r
 581 EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)\r
 582 {\r
 583         return egl::GetProcAddress(procname);\r
 584 }\r
 585 }\r
 586 \r
 587 LibEGLexports::LibEGLexports()\r
 588 {\r
 589         this->eglGetError = egl::GetError;\r
 590         this->eglGetDisplay = egl::GetDisplay;\r
 591         this->eglInitialize = egl::Initialize;\r
 592         this->eglTerminate = egl::Terminate;\r
 593         this->eglQueryString = egl::QueryString;\r
 594         this->eglGetConfigs = egl::GetConfigs;\r
 595         this->eglChooseConfig = egl::ChooseConfig;\r
 596         this->eglGetConfigAttrib = egl::GetConfigAttrib;\r
 597         this->eglCreateWindowSurface = egl::CreateWindowSurface;\r
 598         this->eglCreatePbufferSurface = egl::CreatePbufferSurface;\r
 599         this->eglCreatePixmapSurface = egl::CreatePixmapSurface;\r
 600         this->eglDestroySurface = egl::DestroySurface;\r
 601         this->eglQuerySurface = egl::QuerySurface;\r
 602         this->eglBindAPI = egl::BindAPI;\r
 603         this->eglQueryAPI = egl::QueryAPI;\r
 604         this->eglWaitClient = egl::WaitClient;\r
 605         this->eglReleaseThread = egl::ReleaseThread;\r
 606         this->eglCreatePbufferFromClientBuffer = egl::CreatePbufferFromClientBuffer;\r
 607         this->eglSurfaceAttrib = egl::SurfaceAttrib;\r
 608         this->eglBindTexImage = egl::BindTexImage;\r
 609         this->eglReleaseTexImage = egl::ReleaseTexImage;\r
 610         this->eglSwapInterval = egl::SwapInterval;\r
 611         this->eglCreateContext = egl::CreateContext;\r
 612         this->eglDestroyContext = egl::DestroyContext;\r
 613         this->eglMakeCurrent = egl::MakeCurrent;\r
 614         this->eglGetCurrentContext = egl::GetCurrentContext;\r
 615         this->eglGetCurrentSurface = egl::GetCurrentSurface;\r
 616         this->eglGetCurrentDisplay = egl::GetCurrentDisplay;\r
 617         this->eglQueryContext = egl::QueryContext;\r
 618         this->eglWaitGL = egl::WaitGL;\r
 619         this->eglWaitNative = egl::WaitNative;\r
 620         this->eglSwapBuffers = egl::SwapBuffers;\r
 621         this->eglCopyBuffers = egl::CopyBuffers;\r
 622         this->eglCreateImageKHR = egl::CreateImageKHR;\r
 623         this->eglDestroyImageKHR = egl::DestroyImageKHR;\r
 624         this->eglGetProcAddress = egl::GetProcAddress;\r
 625         this->eglCreateSyncKHR = egl::CreateSyncKHR;\r
 626         this->eglDestroySyncKHR = egl::DestroySyncKHR;\r
 627         this->eglClientWaitSyncKHR = egl::ClientWaitSyncKHR;\r
 628         this->eglGetSyncAttribKHR = egl::GetSyncAttribKHR;\r
 629 \r
 630         this->clientGetCurrentContext = egl::getCurrentContext;\r
 631         this->clientGetCurrentDisplay = egl::getCurrentDisplay;\r
 632 }\r
 633 \r
 634 extern "C" EGLAPI LibEGLexports *libEGL_swiftshader()\r
 635 {\r
 636         static LibEGLexports libEGL;\r
 637         return &libEGL;\r
 638 }\r
 639 \r
 640 LibGLES_CM libGLES_CM;\r
 641 LibGLESv2 libGLESv2;\r