~FrameBufferAndroid();
- void flip(void *source, Format sourceFormat, size_t sourceStride) override {blit(source, 0, 0, sourceFormat, sourceStride);};\r
- void blit(void *source, const Rect *sourceRect, const Rect *destRect, Format sourceFormat, size_t sourceStride) override;\r
-\r
- void *lock() override;\r
+ void flip(void *source, Format sourceFormat, size_t sourceStride) override {blit(source, 0, 0, sourceFormat, sourceStride);};
+ void blit(void *source, const Rect *sourceRect, const Rect *destRect, Format sourceFormat, size_t sourceStride) override;
+
+ void *lock() override;
void unlock() override;
bool setSwapRectangle(int l, int t, int w, int h);
return 0;\r
}\r
\r
-sw::FrameBuffer *createFrameBuffer(HDC display, HWND window, int width, int height)\r
+sw::FrameBuffer *createFrameBuffer(void *display, HWND window, int width, int height)\r
{\r
return createFrameBufferWin(window, width, height, false, false);\r
}\r
-// SwiftShader Software Renderer\r
-//\r
-// Copyright(c) 2005-2012 TransGaming Inc.\r
-//\r
-// All rights reserved. No part of this software may be copied, distributed, transmitted,\r
-// transcribed, stored in a retrieval system, translated into any human or computer\r
-// language by any means, or disclosed to third parties without the explicit written\r
-// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
-// or implied, including but not limited to any patent rights, are granted to you.\r
-//\r
-\r
-// Surface.cpp: Implements the egl::Surface class, representing a drawing surface\r
-// such as the client area of a window, including any back buffers.\r
-// Implements EGLSurface and related functionality. [EGL 1.4] section 2.2 page 3.\r
-\r
-#include "FrameBufferX11.hpp"\r
-\r
-#include "libX11.hpp"\r
-\r
-#include <sys/ipc.h>\r
-#include <sys/shm.h>\r
-#include <string.h>\r
-#include <assert.h>\r
-\r
-namespace sw\r
-{\r
- static int (*PreviousXErrorHandler)(Display *display, XErrorEvent *event) = 0;\r
- static bool shmBadAccess = false;\r
-\r
- // Catches BadAcces errors so we can fall back to not using MIT-SHM\r
- static int XShmErrorHandler(Display *display, XErrorEvent *event)\r
- {\r
- if(event->error_code == BadAccess)\r
- {\r
- shmBadAccess = true;\r
- return 0;\r
- }\r
- else\r
- {\r
- return PreviousXErrorHandler(display, event);\r
- }\r
- }\r
-\r
- FrameBufferX11::FrameBufferX11(Display *display, Window window, int width, int height) : FrameBuffer(width, height, false, false), ownX11(!display), x_display(display), x_window(window)\r
- {\r
- if(!x_display)\r
- {\r
- x_display = libX11->XOpenDisplay(0);\r
- }\r
-\r
- int screen = DefaultScreen(x_display);\r
- x_gc = libX11->XDefaultGC(x_display, screen);\r
- int depth = libX11->XDefaultDepth(x_display, screen);\r
-\r
- Status status = libX11->XMatchVisualInfo(x_display, screen, 32, TrueColor, &x_visual);\r
- bool match = (status != 0 && x_visual.blue_mask == 0xFF); // Prefer X8R8G8B8\r
- Visual *visual = match ? x_visual.visual : libX11->XDefaultVisual(x_display, screen);\r
-\r
- mit_shm = (libX11->XShmQueryExtension && libX11->XShmQueryExtension(x_display) == True);\r
-\r
- if(mit_shm)\r
- {\r
- x_image = libX11->XShmCreateImage(x_display, visual, depth, ZPixmap, 0, &shminfo, width, height);\r
-\r
- shminfo.shmid = shmget(IPC_PRIVATE, x_image->bytes_per_line * x_image->height, IPC_CREAT | SHM_R | SHM_W);\r
- shminfo.shmaddr = x_image->data = buffer = (char*)shmat(shminfo.shmid, 0, 0);\r
- shminfo.readOnly = False;\r
-\r
- PreviousXErrorHandler = libX11->XSetErrorHandler(XShmErrorHandler);\r
- libX11->XShmAttach(x_display, &shminfo); // May produce a BadAccess error\r
- libX11->XSync(x_display, False);\r
- libX11->XSetErrorHandler(PreviousXErrorHandler);\r
-\r
- if(shmBadAccess)\r
- {\r
- mit_shm = false;\r
-\r
- XDestroyImage(x_image);\r
- shmdt(shminfo.shmaddr);\r
- shmctl(shminfo.shmid, IPC_RMID, 0);\r
-\r
- shmBadAccess = false;\r
- }\r
- }\r
-\r
- if(!mit_shm)\r
- {\r
- buffer = new char[width * height * 4];\r
- x_image = libX11->XCreateImage(x_display, visual, depth, ZPixmap, 0, buffer, width, height, 32, width * 4);\r
- }\r
- }\r
-\r
- FrameBufferX11::~FrameBufferX11()\r
- {\r
- if(!mit_shm)\r
- {\r
- x_image->data = 0;\r
- XDestroyImage(x_image);\r
-\r
- delete[] buffer;\r
- buffer = 0;\r
- }\r
- else\r
- {\r
- libX11->XShmDetach(x_display, &shminfo);\r
- XDestroyImage(x_image);\r
- shmdt(shminfo.shmaddr);\r
- shmctl(shminfo.shmid, IPC_RMID, 0);\r
- }\r
-\r
- if(ownX11)\r
- {\r
- libX11->XCloseDisplay(x_display);\r
- }\r
- }\r
-\r
- void *FrameBufferX11::lock()\r
- {\r
- stride = x_image->bytes_per_line;\r
- locked = buffer;\r
-\r
- return locked;\r
- }\r
-\r
- void FrameBufferX11::unlock()\r
- {\r
- locked = 0;\r
- }\r
-\r
- void FrameBufferX11::blit(void *source, const Rect *sourceRect, const Rect *destRect, Format sourceFormat, size_t sourceStride)\r
- {\r
- copy(source, sourceFormat, sourceStride);\r
-\r
- if(!mit_shm)\r
- {\r
- libX11->XPutImage(x_display, x_window, x_gc, x_image, 0, 0, 0, 0, width, height);\r
- }\r
- else\r
- {\r
- libX11->XShmPutImage(x_display, x_window, x_gc, x_image, 0, 0, 0, 0, width, height, False);\r
- }\r
-\r
- libX11->XSync(x_display, False);\r
- }\r
-}\r
-\r
-sw::FrameBuffer *createFrameBuffer(Display *display, Window window, int width, int height)\r
-{\r
- return new sw::FrameBufferX11(display, window, width, height);\r
-}\r
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 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.
+//
+
+// Surface.cpp: Implements the egl::Surface class, representing a drawing surface
+// such as the client area of a window, including any back buffers.
+// Implements EGLSurface and related functionality. [EGL 1.4] section 2.2 page 3.
+
+#include "FrameBufferX11.hpp"
+
+#include "libX11.hpp"
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <string.h>
+#include <assert.h>
+
+namespace sw
+{
+ static int (*PreviousXErrorHandler)(Display *display, XErrorEvent *event) = 0;
+ static bool shmBadAccess = false;
+
+ // Catches BadAcces errors so we can fall back to not using MIT-SHM
+ static int XShmErrorHandler(Display *display, XErrorEvent *event)
+ {
+ if(event->error_code == BadAccess)
+ {
+ shmBadAccess = true;
+ return 0;
+ }
+ else
+ {
+ return PreviousXErrorHandler(display, event);
+ }
+ }
+
+ FrameBufferX11::FrameBufferX11(Display *display, Window window, int width, int height) : FrameBuffer(width, height, false, false), ownX11(!display), x_display(display), x_window(window)
+ {
+ if(!x_display)
+ {
+ x_display = libX11->XOpenDisplay(0);
+ }
+
+ int screen = DefaultScreen(x_display);
+ x_gc = libX11->XDefaultGC(x_display, screen);
+ int depth = libX11->XDefaultDepth(x_display, screen);
+
+ Status status = libX11->XMatchVisualInfo(x_display, screen, 32, TrueColor, &x_visual);
+ bool match = (status != 0 && x_visual.blue_mask == 0xFF); // Prefer X8R8G8B8
+ Visual *visual = match ? x_visual.visual : libX11->XDefaultVisual(x_display, screen);
+
+ mit_shm = (libX11->XShmQueryExtension && libX11->XShmQueryExtension(x_display) == True);
+
+ if(mit_shm)
+ {
+ x_image = libX11->XShmCreateImage(x_display, visual, depth, ZPixmap, 0, &shminfo, width, height);
+
+ shminfo.shmid = shmget(IPC_PRIVATE, x_image->bytes_per_line * x_image->height, IPC_CREAT | SHM_R | SHM_W);
+ shminfo.shmaddr = x_image->data = buffer = (char*)shmat(shminfo.shmid, 0, 0);
+ shminfo.readOnly = False;
+
+ PreviousXErrorHandler = libX11->XSetErrorHandler(XShmErrorHandler);
+ libX11->XShmAttach(x_display, &shminfo); // May produce a BadAccess error
+ libX11->XSync(x_display, False);
+ libX11->XSetErrorHandler(PreviousXErrorHandler);
+
+ if(shmBadAccess)
+ {
+ mit_shm = false;
+
+ XDestroyImage(x_image);
+ shmdt(shminfo.shmaddr);
+ shmctl(shminfo.shmid, IPC_RMID, 0);
+
+ shmBadAccess = false;
+ }
+ }
+
+ if(!mit_shm)
+ {
+ buffer = new char[width * height * 4];
+ x_image = libX11->XCreateImage(x_display, visual, depth, ZPixmap, 0, buffer, width, height, 32, width * 4);
+ }
+ }
+
+ FrameBufferX11::~FrameBufferX11()
+ {
+ if(!mit_shm)
+ {
+ x_image->data = 0;
+ XDestroyImage(x_image);
+
+ delete[] buffer;
+ buffer = 0;
+ }
+ else
+ {
+ libX11->XShmDetach(x_display, &shminfo);
+ XDestroyImage(x_image);
+ shmdt(shminfo.shmaddr);
+ shmctl(shminfo.shmid, IPC_RMID, 0);
+ }
+
+ if(ownX11)
+ {
+ libX11->XCloseDisplay(x_display);
+ }
+ }
+
+ void *FrameBufferX11::lock()
+ {
+ stride = x_image->bytes_per_line;
+ locked = buffer;
+
+ return locked;
+ }
+
+ void FrameBufferX11::unlock()
+ {
+ locked = 0;
+ }
+
+ void FrameBufferX11::blit(void *source, const Rect *sourceRect, const Rect *destRect, Format sourceFormat, size_t sourceStride)
+ {
+ copy(source, sourceFormat, sourceStride);
+
+ if(!mit_shm)
+ {
+ libX11->XPutImage(x_display, x_window, x_gc, x_image, 0, 0, 0, 0, width, height);
+ }
+ else
+ {
+ libX11->XShmPutImage(x_display, x_window, x_gc, x_image, 0, 0, 0, 0, width, height, False);
+ }
+
+ libX11->XSync(x_display, False);
+ }
+}
+
+sw::FrameBuffer *createFrameBuffer(void *display, Window window, int width, int height)
+{
+ return new sw::FrameBufferX11((::Display*)display, window, width, height);
+}
-// SwiftShader Software Renderer\r
-//\r
-// Copyright(c) 2005-2012 TransGaming Inc.\r
-//\r
-// All rights reserved. No part of this software may be copied, distributed, transmitted,\r
-// transcribed, stored in a retrieval system, translated into any human or computer\r
-// language by any means, or disclosed to third parties without the explicit written\r
-// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
-// or implied, including but not limited to any patent rights, are granted to you.\r
-//\r
-\r
-// Surface.cpp: Implements the egl::Surface class, representing a drawing surface\r
-// such as the client area of a window, including any back buffers.\r
-// Implements EGLSurface and related functionality. [EGL 1.4] section 2.2 page 3.\r
-\r
-#ifndef sw_FrameBufferX11_hpp\r
-#define sw_FrameBufferX11_hpp\r
-\r
-#include "Main/FrameBuffer.hpp"\r
-#include "Common/Debug.hpp"\r
-\r
-#include <X11/Xlib.h>\r
-#include <X11/Xutil.h>\r
-#include <X11/extensions/XShm.h>\r
-\r
-namespace sw\r
-{\r
- class FrameBufferX11 : public FrameBuffer\r
- {\r
- public:\r
- FrameBufferX11(Display *display, Window window, int width, int height);\r
-\r
- ~FrameBufferX11();\r
-\r
- void flip(void *source, Format sourceFormat, size_t sourceStride) override {blit(source, 0, 0, sourceFormat, sourceStride);};\r
- void blit(void *source, const Rect *sourceRect, const Rect *destRect, Format sourceFormat, size_t sourceStride) override;\r
-\r
- void *lock() override;\r
- void unlock() override;\r
-\r
- private:\r
- bool ownX11;\r
- Display *x_display;\r
- Window x_window;\r
- XImage *x_image;\r
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 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.
+//
+
+// Surface.cpp: Implements the egl::Surface class, representing a drawing surface
+// such as the client area of a window, including any back buffers.
+// Implements EGLSurface and related functionality. [EGL 1.4] section 2.2 page 3.
+
+#ifndef sw_FrameBufferX11_hpp
+#define sw_FrameBufferX11_hpp
+
+#include "Main/FrameBuffer.hpp"
+#include "Common/Debug.hpp"
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/XShm.h>
+
+namespace sw
+{
+ class FrameBufferX11 : public FrameBuffer
+ {
+ public:
+ FrameBufferX11(Display *display, Window window, int width, int height);
+
+ ~FrameBufferX11();
+
+ void flip(void *source, Format sourceFormat, size_t sourceStride) override {blit(source, 0, 0, sourceFormat, sourceStride);};
+ void blit(void *source, const Rect *sourceRect, const Rect *destRect, Format sourceFormat, size_t sourceStride) override;
+
+ void *lock() override;
+ void unlock() override;
+
+ private:
+ bool ownX11;
+ Display *x_display;
+ Window x_window;
+ XImage *x_image;
GC x_gc;
- XVisualInfo x_visual;\r
-\r
- bool mit_shm;\r
- XShmSegmentInfo shminfo;\r
-\r
- char *buffer;\r
- };\r
-}\r
-\r
-#endif // sw_FrameBufferX11_hpp\r
+ XVisualInfo x_visual;
+
+ bool mit_shm;
+ XShmSegmentInfo shminfo;
+
+ char *buffer;
+ };
+}
+
+#endif // sw_FrameBufferX11_hpp
namespace egl
{
-typedef std::map<EGLNativeDisplayType, Display*> DisplayMap;
-// Protects the global displays map.
-sw::BackoffLock displays_lock;
-
-// The order of construction of globals is undefined in C++.
-// This function ensures that construction has completed before we attempt
-// to access displays.
-DisplayMap* getDisplays() {
- static DisplayMap displays;
- return &displays;
-}
-
-egl::Display *Display::getPlatformDisplay(EGLenum platform, EGLNativeDisplayType displayId)
+egl::Display *Display::getPlatformDisplay(EGLenum platform, void *nativeDisplay)
{
#ifndef __ANDROID__
- if(platform == EGL_UNKNOWN) // Default
+ if(platform == EGL_UNKNOWN) // Default platform
{
#if defined(__unix__)
if(libX11)
#endif
}
- if(displayId == EGL_DEFAULT_DISPLAY)
+ if(!nativeDisplay) // Default display
{
if(platform == EGL_PLATFORM_X11_EXT)
{
#if defined(__unix__)
if(libX11->XOpenDisplay)
{
- displayId = libX11->XOpenDisplay(NULL);
+ nativeDisplay = libX11->XOpenDisplay(NULL);
}
else
{
}
else
{
- // FIXME: Check if
displayId is a valid display device context for <platform>
+ // FIXME: Check if
nativeDisplay is a valid display device context for <platform>
}
#endif
- egl::Display *rval;
- displays_lock.lock();
- DisplayMap* displays = getDisplays();
- if (displays->find(displayId) != displays->end())
- {
- rval = (*displays)[displayId];
- } else {
- rval = new egl::Display(platform, displayId);
+ static std::map<void*, Display*> displays;
+ static sw::BackoffLock displaysMutex;
+
+ displaysMutex.lock();
- (*displays)[displayId] = rval;
+ egl::Display *display = displays[nativeDisplay];
+
+ if(!display)
+ {
+ display = new egl::Display(platform, nativeDisplay);
+ displays[nativeDisplay] = display;
}
- displays_lock.unlock();
- return rval;
+
+ displaysMutex.unlock();
+
+ return display;
}
-Display::Display(EGLenum platform, EGLNativeDisplayType displayId) : platform(platform), displayId(displayId)
+Display::Display(EGLenum platform, void *nativeDisplay) : platform(platform), nativeDisplay(nativeDisplay)
{
mMinSwapInterval = 1;
mMaxSwapInterval = 1;
Display::~Display()
{
terminate();
-
- displays_lock.lock();
- getDisplays()->erase(displayId);
- displays_lock.unlock();
}
static void cpuid(int registers[4], int info)
if(platform == EGL_PLATFORM_X11_EXT)
{
XWindowAttributes windowAttributes;
- Status status = libX11->XGetWindowAttributes(displayId, window, &windowAttributes);
+ Status status = libX11->XGetWindowAttributes((::Display*)nativeDisplay, window, &windowAttributes);
return status == True;
}
return mMaxSwapInterval;
}
-EGLNativeDisplayType Display::getNativeDisplay() const
+void *Display::getNativeDisplay() const
{
- return displayId;
+ return nativeDisplay;
}
sw::Format Display::getDisplayFormat() const
#else
if(platform == EGL_PLATFORM_X11_EXT)
{
- Screen *screen = libX11->XDefaultScreenOfDisplay(displayId);
+ Screen *screen = libX11->XDefaultScreenOfDisplay((::Display*)nativeDisplay);
unsigned int bpp = libX11->XPlanesOfScreen(screen);
switch(bpp)
class Display\r
{\r
public:\r
- ~Display();\r
-\r
- static egl::Display *getPlatformDisplay(EGLenum platform, EGLNativeDisplayType displayId);\r
+ static egl::Display *getPlatformDisplay(EGLenum platform, void *nativeDisplay);\r
\r
bool initialize();\r
void terminate();\r
EGLint getMinSwapInterval() const;\r
EGLint getMaxSwapInterval() const;\r
\r
- EGLNativeDisplayType getNativeDisplay() const;\r
+ void *getNativeDisplay() const;\r
const char *getExtensionString() const;\r
\r
private:\r
- Display(EGLenum platform, EGLNativeDisplayType displayId);\r
+ Display(EGLenum platform, void *nativeDisplay);\r
+ ~Display();\r
\r
sw::Format getDisplayFormat() const;\r
\r
const EGLenum platform;\r
- const EGLNativeDisplayType displayId;\r
+ void *const nativeDisplay;\r
\r
EGLint mMaxSwapInterval;\r
EGLint mMinSwapInterval;\r
- \r
+\r
typedef std::set<Surface*> SurfaceSet;\r
SurfaceSet mSurfaceSet;\r
\r
return reset(width, height);\r
#else\r
XWindowAttributes windowAttributes;\r
- libX11->XGetWindowAttributes(display->getNativeDisplay(), window, &windowAttributes);\r
+ libX11->XGetWindowAttributes((::Display*)display->getNativeDisplay(), window, &windowAttributes);\r
\r
return reset(windowAttributes.width, windowAttributes.height);\r
#endif\r
int clientHeight; window->query(window, NATIVE_WINDOW_HEIGHT, &clientHeight);\r
#else\r
XWindowAttributes windowAttributes;\r
- libX11->XGetWindowAttributes(display->getNativeDisplay(), window, &windowAttributes);\r
+ libX11->XGetWindowAttributes((::Display*)display->getNativeDisplay(), window, &windowAttributes);\r
\r
int clientWidth = windowAttributes.width;\r
int clientHeight = windowAttributes.height;\r
{\r
TRACE("(EGLNativeDisplayType display_id = %p)", display_id);\r
\r
- return egl::Display::getPlatformDisplay(EGL_UNKNOWN, display_id);\r
+ if(display_id == EGL_DEFAULT_DISPLAY)\r
+ {\r
+ return egl::Display::getPlatformDisplay(EGL_UNKNOWN, nullptr);\r
+ }\r
+ else\r
+ {\r
+ return egl::Display::getPlatformDisplay(EGL_UNKNOWN, reinterpret_cast<void*>((uintptr_t)display_id));\r
+ }\r
}\r
\r
EGLBoolean Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor)\r
{\r
TRACE("(EGLenum platform = 0x%X, void *native_display = %p, const EGLint *attrib_list = %p)", platform, native_display, attrib_list);\r
\r
- return egl::Display::getPlatformDisplay(platform, (EGLNativeDisplayType)native_display);\r
+ return egl::Display::getPlatformDisplay(platform, native_display);\r
}\r
\r
EGLSurface CreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list)\r
-// SwiftShader Software Renderer
-//
-// Copyright(c) 2005-2012 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.h: Management of thread-local data.
-
-#ifndef LIBGL_MAIN_H_
-#define LIBGL_MAIN_H_
-
-#include "Context.h"
-#include "Device.hpp"
-#include "common/debug.h"
-#include "Display.h"
-
-#define _GDI32_
-#include <windows.h>
-#include <GL/GL.h>
-#include <GL/glext.h>
-
-namespace gl
-{
- struct Current
- {
- Context *context;
- Display *display;
- Surface *drawSurface;
- Surface *readSurface;
- };
-
- void makeCurrent(Context *context, Display *display, Surface *surface);
-
- Context *getContext();
- Display *getDisplay();
- Device *getDevice();
- Surface *getCurrentDrawSurface();
- Surface *getCurrentReadSurface();
-
- void setCurrentDisplay(Display *dpy);
- void setCurrentContext(gl::Context *ctx);
- void setCurrentDrawSurface(Surface *surface);
- void setCurrentReadSurface(Surface *surface);
-}
-
-void error(GLenum errorCode);
-
-template<class T>
-T &error(GLenum errorCode, T &returnValue)
-{
- error(errorCode);
-
- return returnValue;
-}
-
-template<class T>
-const T &error(GLenum errorCode, const T &returnValue)
-{
- error(errorCode);
-
- return returnValue;
-}
-
-extern sw::FrameBuffer *createFrameBuffer(NativeDisplayType display, NativeWindowType window, int width, int height);
-
-#endif // LIBGL_MAIN_H_
+// SwiftShader Software Renderer\r
+//\r
+// Copyright(c) 2005-2012 TransGaming Inc.\r
+//\r
+// All rights reserved. No part of this software may be copied, distributed, transmitted,\r
+// transcribed, stored in a retrieval system, translated into any human or computer\r
+// language by any means, or disclosed to third parties without the explicit written\r
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
+// or implied, including but not limited to any patent rights, are granted to you.\r
+//\r
+\r
+// main.h: Management of thread-local data.\r
+\r
+#ifndef LIBGL_MAIN_H_\r
+#define LIBGL_MAIN_H_\r
+\r
+#include "Context.h"\r
+#include "Device.hpp"\r
+#include "common/debug.h"\r
+#include "Display.h"\r
+\r
+#define _GDI32_\r
+#include <windows.h>\r
+#include <GL/GL.h>\r
+#include <GL/glext.h>\r
+\r
+namespace gl\r
+{\r
+ struct Current\r
+ {\r
+ Context *context;\r
+ Display *display;\r
+ Surface *drawSurface;\r
+ Surface *readSurface;\r
+ };\r
+\r
+ void makeCurrent(Context *context, Display *display, Surface *surface);\r
+\r
+ Context *getContext();\r
+ Display *getDisplay();\r
+ Device *getDevice();\r
+ Surface *getCurrentDrawSurface();\r
+ Surface *getCurrentReadSurface();\r
+ \r
+ void setCurrentDisplay(Display *dpy);\r
+ void setCurrentContext(gl::Context *ctx);\r
+ void setCurrentDrawSurface(Surface *surface);\r
+ void setCurrentReadSurface(Surface *surface);\r
+}\r
+\r
+void error(GLenum errorCode);\r
+\r
+template<class T>\r
+T &error(GLenum errorCode, T &returnValue)\r
+{\r
+ error(errorCode);\r
+\r
+ return returnValue;\r
+}\r
+\r
+template<class T>\r
+const T &error(GLenum errorCode, const T &returnValue)\r
+{\r
+ error(errorCode);\r
+\r
+ return returnValue;\r
+}\r
+\r
+extern sw::FrameBuffer *createFrameBuffer(void *display, NativeWindowType window, int width, int height);\r
+\r
+#endif // LIBGL_MAIN_H_\r
__eglMustCastToProperFunctionPointerType (*es1GetProcAddress)(const char *procname);
egl::Image *(*createBackBuffer)(int width, int height, const egl::Config *config);
egl::Image *(*createDepthStencil)(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);
- sw::FrameBuffer *(*createFrameBuffer)(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);
+ sw::FrameBuffer *(*createFrameBuffer)(void *display, EGLNativeWindowType window, int width, int height);
};
class LibGLES_CM
extern "C" __eglMustCastToProperFunctionPointerType es1GetProcAddress(const char *procname);\r
egl::Image *createBackBuffer(int width, int height, const egl::Config *config);\r
egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);\r
-sw::FrameBuffer *createFrameBuffer(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);\r
+sw::FrameBuffer *createFrameBuffer(void *display, EGLNativeWindowType window, int width, int height);\r
\r
extern "C"\r
{\r
__eglMustCastToProperFunctionPointerType (*es2GetProcAddress)(const char *procname);
egl::Image *(*createBackBuffer)(int width, int height, const egl::Config *config);
egl::Image *(*createDepthStencil)(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);
- sw::FrameBuffer *(*createFrameBuffer)(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);
+ sw::FrameBuffer *(*createFrameBuffer)(void *display, EGLNativeWindowType window, int width, int height);
};
class LibGLESv2
extern "C" __eglMustCastToProperFunctionPointerType es2GetProcAddress(const char *procname);\r
egl::Image *createBackBuffer(int width, int height, const egl::Config *config);\r
egl::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);\r
-sw::FrameBuffer *createFrameBuffer(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);\r
+sw::FrameBuffer *createFrameBuffer(void *display, EGLNativeWindowType window, int width, int height);\r
\r
LibGLESv2exports::LibGLESv2exports()\r
{\r
OSDN Git Service
