blob: 65a052e8591e2a12d07b15c0b59f21884eec0caa [file] [log] [blame]
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// main.cpp: DLL entry point and management of thread-local data.
#include "main.h"
#include "Context.hpp"
#include "Display.h"
#include "Surface.hpp"
#include "libEGL.hpp"
#include "Common/SharedLibrary.hpp"
#include "Common/Thread.hpp"
#include "common/debug.h"
#include "resource.h"
#include <EGL/eglext.h>
static sw::Thread::LocalStorageKey currentTLS = TLS_OUT_OF_INDEXES;
#if !defined(_MSC_VER)
#define CONSTRUCTOR __attribute__((constructor))
#define DESTRUCTOR __attribute__((destructor))
#else
#define CONSTRUCTOR
#define DESTRUCTOR
#endif
namespace egl
{
void releaseCurrent(void *storage)
{
// This pthread destructor is called after the TLS is already reset to NULL,
// so we can't call EGL functions here to do the cleanup.
Current *current = (Current*)storage;
if(current)
{
if(current->drawSurface)
{
current->drawSurface->release();
}
if(current->readSurface)
{
current->readSurface->release();
}
if(current->context)
{
current->context->release();
}
free(current);
}
}
Current *attachThread()
{
TRACE("()");
if(currentTLS == TLS_OUT_OF_INDEXES)
{
currentTLS = sw::Thread::allocateLocalStorageKey(releaseCurrent);
}
Current *current = (Current*)sw::Thread::allocateLocalStorage(currentTLS, sizeof(Current));
current->error = EGL_SUCCESS;
current->API = EGL_OPENGL_ES_API;
current->context = nullptr;
current->drawSurface = nullptr;
current->readSurface = nullptr;
return current;
}
void detachThread()
{
TRACE("()");
eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
sw::Thread::freeLocalStorage(currentTLS);
}
CONSTRUCTOR void attachProcess()
{
TRACE("()");
#if !defined(ANGLE_DISABLE_TRACE) && defined(TRACE_OUTPUT_FILE)
FILE *debug = fopen(TRACE_OUTPUT_FILE, "rt");
if(debug)
{
fclose(debug);
debug = fopen(TRACE_OUTPUT_FILE, "wt"); // Erase
fclose(debug);
}
#endif
attachThread();
}
DESTRUCTOR void detachProcess()
{
TRACE("()");
detachThread();
sw::Thread::freeLocalStorageKey(currentTLS);
}
}
#if defined(_WIN32)
#ifdef DEBUGGER_WAIT_DIALOG
static INT_PTR CALLBACK DebuggerWaitDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT rect;
switch(uMsg)
{
case WM_INITDIALOG:
GetWindowRect(GetDesktopWindow(), &rect);
SetWindowPos(hwnd, HWND_TOP, rect.right / 2, rect.bottom / 2, 0, 0, SWP_NOSIZE);
SetTimer(hwnd, 1, 100, NULL);
return TRUE;
case WM_COMMAND:
if(LOWORD(wParam) == IDCANCEL)
{
EndDialog(hwnd, 0);
}
break;
case WM_TIMER:
if(IsDebuggerPresent())
{
EndDialog(hwnd, 0);
}
}
return FALSE;
}
static void WaitForDebugger(HINSTANCE instance)
{
if(!IsDebuggerPresent())
{
HRSRC dialog = FindResource(instance, MAKEINTRESOURCE(IDD_DIALOG1), RT_DIALOG);
DLGTEMPLATE *dialogTemplate = (DLGTEMPLATE*)LoadResource(instance, dialog);
DialogBoxIndirect(instance, dialogTemplate, NULL, DebuggerWaitDialogProc);
}
}
#endif
extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
{
switch(reason)
{
case DLL_PROCESS_ATTACH:
#ifdef DEBUGGER_WAIT_DIALOG
{
char disable_debugger_wait_dialog[] = "0";
GetEnvironmentVariable("SWIFTSHADER_DISABLE_DEBUGGER_WAIT_DIALOG", disable_debugger_wait_dialog, sizeof(disable_debugger_wait_dialog));
if(disable_debugger_wait_dialog[0] != '1')
{
WaitForDebugger(instance);
}
}
#endif
egl::attachProcess();
break;
case DLL_THREAD_ATTACH:
egl::attachThread();
break;
case DLL_THREAD_DETACH:
egl::detachThread();
break;
case DLL_PROCESS_DETACH:
egl::detachProcess();
break;
default:
break;
}
return TRUE;
}
#endif
namespace egl
{
static Current *getCurrent(void)
{
Current *current = (Current*)sw::Thread::getLocalStorage(currentTLS);
if(!current)
{
current = attachThread();
}
return current;
}
void setCurrentError(EGLint error)
{
Current *current = getCurrent();
current->error = error;
}
EGLint getCurrentError()
{
Current *current = getCurrent();
return current->error;
}
void setCurrentAPI(EGLenum API)
{
Current *current = getCurrent();
current->API = API;
}
EGLenum getCurrentAPI()
{
Current *current = getCurrent();
return current->API;
}
void setCurrentContext(egl::Context *ctx)
{
Current *current = getCurrent();
if(ctx)
{
ctx->addRef();
}
if(current->context)
{
current->context->release();
}
current->context = ctx;
}
NO_SANITIZE_FUNCTION egl::Context *getCurrentContext()
{
Current *current = getCurrent();
return current->context;
}
void setCurrentDrawSurface(egl::Surface *surface)
{
Current *current = getCurrent();
if(surface)
{
surface->addRef();
}
if(current->drawSurface)
{
current->drawSurface->release();
}
current->drawSurface = surface;
}
egl::Surface *getCurrentDrawSurface()
{
Current *current = getCurrent();
return current->drawSurface;
}
void setCurrentReadSurface(egl::Surface *surface)
{
Current *current = getCurrent();
if(surface)
{
surface->addRef();
}
if(current->readSurface)
{
current->readSurface->release();
}
current->readSurface = surface;
}
egl::Surface *getCurrentReadSurface()
{
Current *current = getCurrent();
return current->readSurface;
}
void error(EGLint errorCode)
{
egl::setCurrentError(errorCode);
if(errorCode != EGL_SUCCESS)
{
switch(errorCode)
{
case EGL_NOT_INITIALIZED: TRACE("\t! Error generated: not initialized\n"); break;
case EGL_BAD_ACCESS: TRACE("\t! Error generated: bad access\n"); break;
case EGL_BAD_ALLOC: TRACE("\t! Error generated: bad alloc\n"); break;
case EGL_BAD_ATTRIBUTE: TRACE("\t! Error generated: bad attribute\n"); break;
case EGL_BAD_CONFIG: TRACE("\t! Error generated: bad config\n"); break;
case EGL_BAD_CONTEXT: TRACE("\t! Error generated: bad context\n"); break;
case EGL_BAD_CURRENT_SURFACE: TRACE("\t! Error generated: bad current surface\n"); break;
case EGL_BAD_DISPLAY: TRACE("\t! Error generated: bad display\n"); break;
case EGL_BAD_MATCH: TRACE("\t! Error generated: bad match\n"); break;
case EGL_BAD_NATIVE_PIXMAP: TRACE("\t! Error generated: bad native pixmap\n"); break;
case EGL_BAD_NATIVE_WINDOW: TRACE("\t! Error generated: bad native window\n"); break;
case EGL_BAD_PARAMETER: TRACE("\t! Error generated: bad parameter\n"); break;
case EGL_BAD_SURFACE: TRACE("\t! Error generated: bad surface\n"); break;
case EGL_CONTEXT_LOST: TRACE("\t! Error generated: context lost\n"); break;
default: TRACE("\t! Error generated: <0x%X>\n", errorCode); break;
}
}
}
}
namespace egl
{
EGLint EGLAPIENTRY GetError(void);
EGLDisplay EGLAPIENTRY GetDisplay(EGLNativeDisplayType display_id);
EGLBoolean EGLAPIENTRY Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
EGLBoolean EGLAPIENTRY Terminate(EGLDisplay dpy);
const char *EGLAPIENTRY QueryString(EGLDisplay dpy, EGLint name);
EGLBoolean EGLAPIENTRY GetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
EGLBoolean EGLAPIENTRY ChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
EGLBoolean EGLAPIENTRY GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
EGLSurface EGLAPIENTRY CreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list);
EGLSurface EGLAPIENTRY CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
EGLSurface EGLAPIENTRY CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
EGLBoolean EGLAPIENTRY DestroySurface(EGLDisplay dpy, EGLSurface surface);
EGLBoolean EGLAPIENTRY QuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
EGLBoolean EGLAPIENTRY BindAPI(EGLenum api);
EGLenum EGLAPIENTRY QueryAPI(void);
EGLBoolean EGLAPIENTRY WaitClient(void);
EGLBoolean EGLAPIENTRY ReleaseThread(void);
EGLSurface EGLAPIENTRY CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
EGLBoolean EGLAPIENTRY SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
EGLBoolean EGLAPIENTRY BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLBoolean EGLAPIENTRY ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLBoolean EGLAPIENTRY SwapInterval(EGLDisplay dpy, EGLint interval);
EGLContext EGLAPIENTRY CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
EGLBoolean EGLAPIENTRY DestroyContext(EGLDisplay dpy, EGLContext ctx);
EGLBoolean EGLAPIENTRY MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
EGLContext EGLAPIENTRY GetCurrentContext(void);
EGLSurface EGLAPIENTRY GetCurrentSurface(EGLint readdraw);
EGLDisplay EGLAPIENTRY GetCurrentDisplay(void);
EGLBoolean EGLAPIENTRY QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
EGLBoolean EGLAPIENTRY WaitGL(void);
EGLBoolean EGLAPIENTRY WaitNative(EGLint engine);
EGLBoolean EGLAPIENTRY SwapBuffers(EGLDisplay dpy, EGLSurface surface);
EGLBoolean EGLAPIENTRY CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
EGLImageKHR EGLAPIENTRY CreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
EGLImageKHR EGLAPIENTRY CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
EGLBoolean EGLAPIENTRY DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image);
EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list);
EGLDisplay EGLAPIENTRY GetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
EGLSurface EGLAPIENTRY CreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);
EGLSurface EGLAPIENTRY CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
EGLSurface EGLAPIENTRY CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);
EGLSurface EGLAPIENTRY CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
EGLSyncKHR EGLAPIENTRY CreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
EGLSyncKHR EGLAPIENTRY CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
EGLBoolean EGLAPIENTRY DestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
EGLint EGLAPIENTRY ClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
EGLBoolean EGLAPIENTRY GetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
EGLBoolean EGLAPIENTRY GetSyncAttrib(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLAttrib *value);
__eglMustCastToProperFunctionPointerType EGLAPIENTRY GetProcAddress(const char *procname);
}
extern "C"
{
EGLAPI EGLint EGLAPIENTRY eglGetError(void)
{
return egl::GetError();
}
EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)
{
return egl::GetDisplay(display_id);
}
EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
{
return egl::Initialize(dpy, major, minor);
}
EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)
{
return egl::Terminate(dpy);
}
EGLAPI const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)
{
return egl::QueryString(dpy, name);
}
EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
return egl::GetConfigs(dpy, configs, config_size, num_config);
}
EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
return egl::ChooseConfig(dpy, attrib_list, configs, config_size, num_config);
}
EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
{
return egl::GetConfigAttrib(dpy, config, attribute, value);
}
EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list)
{
return egl::CreateWindowSurface(dpy, config, window, attrib_list);
}
EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
{
return egl::CreatePbufferSurface(dpy, config, attrib_list);
}
EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
{
return egl::CreatePixmapSurface(dpy, config, pixmap, attrib_list);
}
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
{
return egl::DestroySurface(dpy, surface);
}
EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
{
return egl::QuerySurface(dpy, surface, attribute, value);
}
EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)
{
return egl::BindAPI(api);
}
EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void)
{
return egl::QueryAPI();
}
EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void)
{
return egl::WaitClient();
}
EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void)
{
return egl::ReleaseThread();
}
EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
{
return egl::CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
}
EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
{
return egl::SurfaceAttrib(dpy, surface, attribute, value);
}
EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
return egl::BindTexImage(dpy, surface, buffer);
}
EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
return egl::ReleaseTexImage(dpy, surface, buffer);
}
EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)
{
return egl::SwapInterval(dpy, interval);
}
EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
{
return egl::CreateContext(dpy, config, share_context, attrib_list);
}
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
{
return egl::DestroyContext(dpy, ctx);
}
EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{
return egl::MakeCurrent(dpy, draw, read, ctx);
}
EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void)
{
return egl::GetCurrentContext();
}
EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)
{
return egl::GetCurrentSurface(readdraw);
}
EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)
{
return egl::GetCurrentDisplay();
}
EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
{
return egl::QueryContext(dpy, ctx, attribute, value);
}
EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void)
{
return egl::WaitClient();
}
EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)
{
return egl::WaitNative(engine);
}
EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
{
return egl::SwapBuffers(dpy, surface);
}
EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
{
return egl::CopyBuffers(dpy, surface, target);
}
EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
{
return egl::CreateImageKHR(dpy, ctx, target, buffer, attrib_list);
}
EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list)
{
return egl::CreateImage(dpy, ctx, target, buffer, attrib_list);
}
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
{
return egl::DestroyImageKHR(dpy, image);
}
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImage(EGLDisplay dpy, EGLImageKHR image)
{
return egl::DestroyImageKHR(dpy, image);
}
EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list)
{
return egl::GetPlatformDisplayEXT(platform, native_display, attrib_list);
}
EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list)
{
return egl::GetPlatformDisplay(platform, native_display, attrib_list);
}
EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list)
{
return egl::CreatePlatformWindowSurfaceEXT(dpy, config, native_window, attrib_list);
}
EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list)
{
return egl::CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
}
EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list)
{
return egl::CreatePlatformPixmapSurfaceEXT(dpy, config, native_pixmap, attrib_list);
}
EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list)
{
return egl::CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
}
EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
{
return egl::CreateSyncKHR(dpy, type, attrib_list);
}
EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
{
return egl::CreateSync(dpy, type, attrib_list);
}
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
{
return egl::DestroySyncKHR(dpy, sync);
}
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySync(EGLDisplay dpy, EGLSyncKHR sync)
{
return egl::DestroySyncKHR(dpy, sync);
}
EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)
{
return egl::ClientWaitSyncKHR(dpy, sync, flags, timeout);
}
EGLAPI EGLint EGLAPIENTRY eglClientWaitSync(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)
{
return egl::ClientWaitSyncKHR(dpy, sync, flags, timeout);
}
EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value)
{
return egl::GetSyncAttribKHR(dpy, sync, attribute, value);
}
EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttrib(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLAttrib *value)
{
return egl::GetSyncAttrib(dpy, sync, attribute, value);
}
EGLAPI EGLint EGLAPIENTRY eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags)
{
return egl::ClientWaitSyncKHR(dpy, sync, flags, EGL_FOREVER_KHR);
}
EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
{
return egl::ClientWaitSyncKHR(dpy, sync, flags, EGL_FOREVER_KHR);
}
EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)
{
return egl::GetProcAddress(procname);
}
}
LibEGLexports::LibEGLexports()
{
this->eglGetError = egl::GetError;
this->eglGetDisplay = egl::GetDisplay;
this->eglInitialize = egl::Initialize;
this->eglTerminate = egl::Terminate;
this->eglQueryString = egl::QueryString;
this->eglGetConfigs = egl::GetConfigs;
this->eglChooseConfig = egl::ChooseConfig;
this->eglGetConfigAttrib = egl::GetConfigAttrib;
this->eglCreateWindowSurface = egl::CreateWindowSurface;
this->eglCreatePbufferSurface = egl::CreatePbufferSurface;
this->eglCreatePixmapSurface = egl::CreatePixmapSurface;
this->eglDestroySurface = egl::DestroySurface;
this->eglQuerySurface = egl::QuerySurface;
this->eglBindAPI = egl::BindAPI;
this->eglQueryAPI = egl::QueryAPI;
this->eglWaitClient = egl::WaitClient;
this->eglReleaseThread = egl::ReleaseThread;
this->eglCreatePbufferFromClientBuffer = egl::CreatePbufferFromClientBuffer;
this->eglSurfaceAttrib = egl::SurfaceAttrib;
this->eglBindTexImage = egl::BindTexImage;
this->eglReleaseTexImage = egl::ReleaseTexImage;
this->eglSwapInterval = egl::SwapInterval;
this->eglCreateContext = egl::CreateContext;
this->eglDestroyContext = egl::DestroyContext;
this->eglMakeCurrent = egl::MakeCurrent;
this->eglGetCurrentContext = egl::GetCurrentContext;
this->eglGetCurrentSurface = egl::GetCurrentSurface;
this->eglGetCurrentDisplay = egl::GetCurrentDisplay;
this->eglQueryContext = egl::QueryContext;
this->eglWaitGL = egl::WaitGL;
this->eglWaitNative = egl::WaitNative;
this->eglSwapBuffers = egl::SwapBuffers;
this->eglCopyBuffers = egl::CopyBuffers;
this->eglCreateImageKHR = egl::CreateImageKHR;
this->eglDestroyImageKHR = egl::DestroyImageKHR;
this->eglGetProcAddress = egl::GetProcAddress;
this->eglCreateSyncKHR = egl::CreateSyncKHR;
this->eglDestroySyncKHR = egl::DestroySyncKHR;
this->eglClientWaitSyncKHR = egl::ClientWaitSyncKHR;
this->eglGetSyncAttribKHR = egl::GetSyncAttribKHR;
this->clientGetCurrentContext = egl::getCurrentContext;
}
extern "C" EGLAPI LibEGLexports *libEGL_swiftshader()
{
static LibEGLexports libEGL;
return &libEGL;
}
LibGLESv2 libGLESv2;