// SwiftShader Software Renderer | |
// | |
// Copyright(c) 2005-2013 TransGaming Inc. | |
// | |
// All rights reserved. No part of this software may be copied, distributed, transmitted, | |
// transcribed, stored in a retrieval system, translated into any human or computer | |
// language by any means, or disclosed to third parties without the explicit written | |
// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express | |
// or implied, including but not limited to any patent rights, are granted to you. | |
// | |
// main.cpp: DLL entry point and management of thread-local data. | |
#include "main.h" | |
#include "Surface.h" | |
#include "Common/Thread.hpp" | |
#include "Common/SharedLibrary.hpp" | |
#include "common/debug.h" | |
#include "resource.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 | |
static void eglAttachThread() | |
{ | |
TRACE("()"); | |
egl::Current *current = new egl::Current; | |
if(current) | |
{ | |
sw::Thread::setLocalStorage(currentTLS, current); | |
current->error = EGL_SUCCESS; | |
current->API = EGL_OPENGL_ES_API; | |
current->display = EGL_NO_DISPLAY; | |
current->drawSurface = EGL_NO_SURFACE; | |
current->readSurface = EGL_NO_SURFACE; | |
current->context = EGL_NO_CONTEXT; | |
} | |
} | |
static void eglDetachThread() | |
{ | |
TRACE("()"); | |
egl::Current *current = (egl::Current*)sw::Thread::getLocalStorage(currentTLS); | |
if(current) | |
{ | |
delete current; | |
} | |
} | |
CONSTRUCTOR static void eglAttachProcess() | |
{ | |
TRACE("()"); | |
#if !defined(ANGLE_DISABLE_TRACE) | |
FILE *debug = fopen(TRACE_OUTPUT_FILE, "rt"); | |
if(debug) | |
{ | |
fclose(debug); | |
debug = fopen(TRACE_OUTPUT_FILE, "wt"); // Erase | |
fclose(debug); | |
} | |
#endif | |
currentTLS = sw::Thread::allocateLocalStorageKey(); | |
if(currentTLS == TLS_OUT_OF_INDEXES) | |
{ | |
return; | |
} | |
eglAttachThread(); | |
} | |
DESTRUCTOR static void eglDetachProcess() | |
{ | |
TRACE("()"); | |
eglDetachThread(); | |
sw::Thread::freeLocalStorageKey(currentTLS); | |
} | |
#if defined(_WIN32) | |
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); | |
} | |
} | |
extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved) | |
{ | |
switch(reason) | |
{ | |
case DLL_PROCESS_ATTACH: | |
#ifndef NDEBUG | |
WaitForDebugger(instance); | |
#endif | |
eglAttachProcess(); | |
break; | |
case DLL_THREAD_ATTACH: | |
eglAttachThread(); | |
break; | |
case DLL_THREAD_DETACH: | |
eglDetachThread(); | |
break; | |
case DLL_PROCESS_DETACH: | |
eglDetachProcess(); | |
break; | |
default: | |
break; | |
} | |
return TRUE; | |
} | |
#endif | |
namespace egl | |
{ | |
static Current *eglGetCurrent(void) | |
{ | |
Current *current = (Current*)sw::Thread::getLocalStorage(currentTLS); | |
if(!current) | |
{ | |
eglAttachThread(); | |
} | |
return (Current*)sw::Thread::getLocalStorage(currentTLS); | |
} | |
void setCurrentError(EGLint error) | |
{ | |
Current *current = eglGetCurrent(); | |
current->error = error; | |
} | |
EGLint getCurrentError() | |
{ | |
Current *current = eglGetCurrent(); | |
return current->error; | |
} | |
void setCurrentAPI(EGLenum API) | |
{ | |
Current *current = eglGetCurrent(); | |
current->API = API; | |
} | |
EGLenum getCurrentAPI() | |
{ | |
Current *current = eglGetCurrent(); | |
return current->API; | |
} | |
void setCurrentDisplay(EGLDisplay dpy) | |
{ | |
Current *current = eglGetCurrent(); | |
current->display = dpy; | |
} | |
EGLDisplay getCurrentDisplay() | |
{ | |
Current *current = eglGetCurrent(); | |
return current->display; | |
} | |
void setCurrentContext(EGLContext ctx) | |
{ | |
Current *current = eglGetCurrent(); | |
current->context = ctx; | |
} | |
EGLContext getCurrentContext() | |
{ | |
Current *current = eglGetCurrent(); | |
return current->context; | |
} | |
void setCurrentDrawSurface(EGLSurface surface) | |
{ | |
Current *current = eglGetCurrent(); | |
current->drawSurface = surface; | |
} | |
EGLSurface getCurrentDrawSurface() | |
{ | |
Current *current = eglGetCurrent(); | |
return current->drawSurface; | |
} | |
void setCurrentReadSurface(EGLSurface surface) | |
{ | |
Current *current = eglGetCurrent(); | |
current->readSurface = surface; | |
} | |
EGLSurface getCurrentReadSurface() | |
{ | |
Current *current = eglGetCurrent(); | |
return current->readSurface; | |
} | |
} | |
namespace egl | |
{ | |
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; | |
} | |
} | |
} | |
} | |
extern "C" | |
{ | |
EGLContext clientGetCurrentContext() | |
{ | |
return egl::getCurrentContext(); | |
} | |
EGLContext clientGetCurrentDisplay() | |
{ | |
return egl::getCurrentDisplay(); | |
} | |
} | |
namespace es2 | |
{ | |
es2::Context *getContext() | |
{ | |
egl::Context *context = static_cast<egl::Context*>(egl::getCurrentContext()); | |
if(context && context->getClientVersion() == 2) | |
{ | |
return static_cast<es2::Context*>(context); | |
} | |
return 0; | |
} | |
egl::Display *getDisplay() | |
{ | |
return static_cast<egl::Display*>(egl::getCurrentDisplay()); | |
} | |
Device *getDevice() | |
{ | |
Context *context = getContext(); | |
return context ? context->getDevice() : 0; | |
} | |
} | |
namespace egl | |
{ | |
GLint getClientVersion() | |
{ | |
Context *context = static_cast<egl::Context*>(egl::getCurrentContext()); | |
return context ? context->getClientVersion() : 0; | |
} | |
} | |
namespace rad | |
{ | |
// Records an error code | |
void error(GLenum errorCode) | |
{ | |
es2::Context *context = es2::getContext(); | |
if(context) | |
{ | |
switch(errorCode) | |
{ | |
case GL_INVALID_ENUM: | |
context->recordInvalidEnum(); | |
TRACE("\t! Error generated: invalid enum\n"); | |
break; | |
case GL_INVALID_VALUE: | |
context->recordInvalidValue(); | |
TRACE("\t! Error generated: invalid value\n"); | |
break; | |
case GL_INVALID_OPERATION: | |
context->recordInvalidOperation(); | |
TRACE("\t! Error generated: invalid operation\n"); | |
break; | |
case GL_OUT_OF_MEMORY: | |
context->recordOutOfMemory(); | |
TRACE("\t! Error generated: out of memory\n"); | |
break; | |
case GL_INVALID_FRAMEBUFFER_OPERATION: | |
context->recordInvalidFramebufferOperation(); | |
TRACE("\t! Error generated: invalid framebuffer operation\n"); | |
break; | |
default: UNREACHABLE(); | |
} | |
} | |
} | |
} |