Missed the video interface files.

12 files changed, 1423 insertions, 0 deletions

diff --git a/Source/Core/DolphinWX/Src/GLVideoInterface.h b/Source/Core/DolphinWX/Src/GLVideoInterface.h
new file mode 100644
index 0000000000..3469b1d3c1
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/GLVideoInterface.h
@@ -0,0 +1,75 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+#ifndef _VIDEOINTERFACE_H_
+#define _VIDEOINTERFACE_H_
+
+#include "Thread.h"
+
+#if defined(USE_EGL) && USE_EGL
+#include "VideoInterface/EGL.h"
+#elif defined(USE_WX) && USE_WX
+#include "VideoInterface/WX.h"
+#elif defined(__APPLE__)
+#include "VideoInterface/AGL.h"
+#elif defined(_WIN32)
+#include "VideoInterface/GLW.h"
+#elif defined(HAVE_X11) && HAVE_X11
+#include "VideoInterface/GLX.h"
+#endif
+
+typedef struct {
+#if defined(USE_EGL) && USE_EGL // This is currently a X11/EGL implementation for desktop
+	int screen;
+	Display *x_dpy;
+	Display *x_evdpy;
+	Window win;
+	Window parent;
+	EGLSurface egl_surf;
+	EGLContext egl_ctx;
+	EGLDisplay egl_dpy;
+	XVisualInfo *vi;
+	XSetWindowAttributes attr;
+	std::thread xEventThread;
+	int x, y;
+	unsigned int width, height;
+#elif defined(USE_WX) && USE_WX
+	wxGLCanvas *glCanvas;
+	wxGLContext *glCtxt;
+	wxPanel *panel;
+#elif defined(__APPLE__)
+	NSWindow *cocoaWin;
+	NSOpenGLContext *cocoaCtx;
+#elif defined(HAVE_X11) && HAVE_X11
+	int screen;
+	Window win;
+	Window parent;
+	// dpy used for glx stuff, evdpy for window events etc.
+	// evdpy is to be used by XEventThread only
+	Display *dpy, *evdpy;
+	XVisualInfo *vi;
+	GLXContext ctx;
+	XSetWindowAttributes attr;
+	std::thread xEventThread;
+	int x, y;
+	unsigned int width, height;
+#endif
+} GLWindow;
+
+extern cInterfaceBase *GLInterface;
+extern GLWindow GLWin;
+
+#endif
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/AGL.cpp b/Source/Core/DolphinWX/Src/VideoInterface/AGL.cpp
new file mode 100644
index 0000000000..465f77c972
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/AGL.cpp
@@ -0,0 +1,123 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "VideoConfig.h"
+#include "Host.h"
+#include "RenderBase.h"
+
+#include "VertexShaderManager.h"
+#include "../GLVideoInterface.h"
+#include "AGL.h"
+
+void cInterfaceAGL::SwapBuffers()
+{
+	[GLWin.cocoaCtx flushBuffer];
+}
+
+// Show the current FPS
+void cInterfaceAGL::UpdateFPSDisplay(const char *text)
+{
+	[GLWin.cocoaWin setTitle: [NSString stringWithUTF8String: text]];
+}
+
+// Create rendering window.
+//		Call browser: Core.cpp:EmuThread() > main.cpp:Video_Initialize()
+bool cInterfaceAGL::Create(void *&window_handle)
+{
+	int _tx, _ty, _twidth, _theight;
+	Host_GetRenderWindowSize(_tx, _ty, _twidth, _theight);
+
+	// Control window size and picture scaling
+	s_backbuffer_width = _twidth;
+	s_backbuffer_height = _theight;
+
+	NSRect size;
+	NSUInteger style = NSMiniaturizableWindowMask;
+	NSOpenGLPixelFormatAttribute attr[2] = { NSOpenGLPFADoubleBuffer, 0 };
+	NSOpenGLPixelFormat *fmt = [[NSOpenGLPixelFormat alloc]
+		initWithAttributes: attr];
+	if (fmt == nil) {
+		ERROR_LOG(VIDEO, "failed to create pixel format");
+		return NULL;
+	}
+
+	GLWin.cocoaCtx = [[NSOpenGLContext alloc]
+		initWithFormat: fmt shareContext: nil];
+	[fmt release];
+	if (GLWin.cocoaCtx == nil) {
+		ERROR_LOG(VIDEO, "failed to create context");
+		return NULL;
+	}
+
+	if (SConfig::GetInstance().m_LocalCoreStartupParameter.bFullscreen) {
+		size = [[NSScreen mainScreen] frame];
+		style |= NSBorderlessWindowMask;
+	} else {
+		size = NSMakeRect(_tx, _ty, _twidth, _theight);
+		style |= NSResizableWindowMask | NSTitledWindowMask;
+	}
+
+	GLWin.cocoaWin = [[NSWindow alloc] initWithContentRect: size
+		styleMask: style backing: NSBackingStoreBuffered defer: NO];
+	if (GLWin.cocoaWin == nil) {
+		ERROR_LOG(VIDEO, "failed to create window");
+		return NULL;
+	}
+
+	if (SConfig::GetInstance().m_LocalCoreStartupParameter.bFullscreen) {
+		CGDisplayCapture(CGMainDisplayID());
+		[GLWin.cocoaWin setLevel: CGShieldingWindowLevel()];
+	}
+
+	[GLWin.cocoaCtx setView: [GLWin.cocoaWin contentView]];
+	[GLWin.cocoaWin makeKeyAndOrderFront: nil];
+
+	return true;
+}
+
+bool cInterfaceAGL::MakeCurrent()
+{
+	[GLWin.cocoaCtx makeCurrentContext];
+	return true;
+}
+
+// Update window width, size and etc. Called from Render.cpp
+void cInterfaceAGL::Update()
+{
+	int width, height;
+
+	width = [[GLWin.cocoaWin contentView] frame].size.width;
+	height = [[GLWin.cocoaWin contentView] frame].size.height;
+	if (width == s_backbuffer_width && height == s_backbuffer_height)
+		return;
+
+	[GLWin.cocoaCtx setView: [GLWin.cocoaWin contentView]];
+	[GLWin.cocoaCtx update];
+	[GLWin.cocoaCtx makeCurrentContext];
+	s_backbuffer_width = width;
+	s_backbuffer_height = height;
+}
+
+// Close backend
+void cInterfaceAGL::Shutdown()
+{
+	[GLWin.cocoaWin close];
+	[GLWin.cocoaCtx clearDrawable];
+	[GLWin.cocoaCtx release];
+}
+
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/AGL.h b/Source/Core/DolphinWX/Src/VideoInterface/AGL.h
new file mode 100644
index 0000000000..1e73f3c6b8
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/AGL.h
@@ -0,0 +1,37 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+#ifndef _INTERFACEAGL_H_
+#define _INTERFACEAGL_H_
+
+#ifdef __APPLE__
+#include <GL/glew.h>
+#import <AppKit/AppKit.h>
+#endif
+
+#include "InterfaceBase.h"
+
+class cInterfaceAGL : public cInterfaceBase
+{
+public:
+	void SwapBuffers();
+	void UpdateFPSDisplay(const char *Text);
+	bool CreateWindow(void *&window_handle);
+	bool MakeCurrent();
+	void Shutdown(); 
+};
+#endif
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/EGL.cpp b/Source/Core/DolphinWX/Src/VideoInterface/EGL.cpp
new file mode 100644
index 0000000000..bcf7acaff5
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/EGL.cpp
@@ -0,0 +1,383 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "VideoConfig.h"
+#include "Host.h"
+#include "RenderBase.h"
+
+#include "VertexShaderManager.h"
+#include "../GLVideoInterface.h"
+#include "EGL.h"
+
+void cInterfaceEGL::CreateXWindow(void)
+{
+	Atom wmProtocols[1];
+
+	// Setup window attributes
+	GLWin.attr.colormap = XCreateColormap(GLWin.x_evdpy,
+			GLWin.parent, GLWin.vi->visual, AllocNone);
+	GLWin.attr.event_mask = KeyPressMask | StructureNotifyMask | FocusChangeMask;
+	GLWin.attr.background_pixel = BlackPixel(GLWin.x_evdpy, GLWin.screen);
+	GLWin.attr.border_pixel = 0;
+
+	// Create the window
+	GLWin.win = XCreateWindow(GLWin.x_evdpy, GLWin.parent,
+			GLWin.x, GLWin.y, GLWin.width, GLWin.height, 0,
+			GLWin.vi->depth, InputOutput, GLWin.vi->visual,
+			CWBorderPixel | CWBackPixel | CWColormap | CWEventMask, &GLWin.attr);
+	wmProtocols[0] = XInternAtom(GLWin.x_evdpy, "WM_DELETE_WINDOW", True);
+	XSetWMProtocols(GLWin.x_evdpy, GLWin.win, wmProtocols, 1);
+	XSetStandardProperties(GLWin.x_evdpy, GLWin.win, "GPU", "GPU", None, NULL, 0, NULL);
+	XMapRaised(GLWin.x_evdpy, GLWin.win);
+	XSync(GLWin.x_evdpy, True);
+
+	GLWin.xEventThread = std::thread(&cInterfaceEGL::XEventThread, this);
+}
+
+void cInterfaceEGL::DestroyXWindow(void)
+{
+	XUnmapWindow(GLWin.x_dpy, GLWin.win);
+	GLWin.win = 0;
+	if (GLWin.xEventThread.joinable())
+		GLWin.xEventThread.join();
+	XFreeColormap(GLWin.x_dpy, GLWin.attr.colormap);
+}
+
+void cInterfaceEGL::XEventThread()
+{
+	// Free look variables
+	static bool mouseLookEnabled = false;
+	static bool mouseMoveEnabled = false;
+	static float lastMouse[2];
+	while (GLWin.win)
+	{
+		XEvent event;
+		KeySym key;
+		for (int num_events = XPending(GLWin.x_evdpy); num_events > 0; num_events--)
+		{
+			XNextEvent(GLWin.x_evdpy, &event);
+			switch(event.type) {
+				case KeyPress:
+					key = XLookupKeysym((XKeyEvent*)&event, 0);
+					switch (key)
+					{
+						case XK_3:
+							OSDChoice = 1;
+							// Toggle native resolution
+							g_Config.iEFBScale = g_Config.iEFBScale + 1;
+							if (g_Config.iEFBScale > 7) g_Config.iEFBScale = 0;
+							break;
+						case XK_4:
+							OSDChoice = 2;
+							// Toggle aspect ratio
+							g_Config.iAspectRatio = (g_Config.iAspectRatio + 1) & 3;
+							break;
+						case XK_5:
+							OSDChoice = 3;
+							// Toggle EFB copy
+							if (!g_Config.bEFBCopyEnable || g_Config.bCopyEFBToTexture)
+							{
+								g_Config.bEFBCopyEnable ^= true;
+								g_Config.bCopyEFBToTexture = false;
+							}
+							else
+							{
+								g_Config.bCopyEFBToTexture = !g_Config.bCopyEFBToTexture;
+							}
+							break;
+						case XK_6:
+							OSDChoice = 4;
+							g_Config.bDisableFog = !g_Config.bDisableFog;
+							break;
+						default:
+							break;
+					}
+					if (g_Config.bFreeLook)
+					{
+						static float debugSpeed = 1.0f;
+						switch (key)
+						{
+							case XK_parenleft:
+								debugSpeed /= 2.0f;
+								break;
+							case XK_parenright:
+								debugSpeed *= 2.0f;
+								break;
+							case XK_w:
+								VertexShaderManager::TranslateView(0.0f, debugSpeed);
+								break;
+							case XK_s:
+								VertexShaderManager::TranslateView(0.0f, -debugSpeed);
+								break;
+							case XK_a:
+								VertexShaderManager::TranslateView(debugSpeed, 0.0f);
+								break;
+							case XK_d:
+								VertexShaderManager::TranslateView(-debugSpeed, 0.0f);
+								break;
+							case XK_r:
+								VertexShaderManager::ResetView();
+								break;
+						}
+					}
+					break;
+				case ButtonPress:
+					if (g_Config.bFreeLook)
+					{
+						switch (event.xbutton.button)
+						{
+							case 2: // Middle button
+								lastMouse[0] = event.xbutton.x;
+								lastMouse[1] = event.xbutton.y;
+								mouseMoveEnabled = true;
+								break;
+							case 3: // Right button
+								lastMouse[0] = event.xbutton.x;
+								lastMouse[1] = event.xbutton.y;
+								mouseLookEnabled = true;
+								break;
+						}
+					}
+					break;
+				case ButtonRelease:
+					if (g_Config.bFreeLook)
+					{
+						switch (event.xbutton.button)
+						{
+							case 2: // Middle button
+								mouseMoveEnabled = false;
+								break;
+							case 3: // Right button
+								mouseLookEnabled = false;
+								break;
+						}
+					}
+					break;
+				case MotionNotify:
+					if (g_Config.bFreeLook)
+					{
+						if (mouseLookEnabled)
+						{
+							VertexShaderManager::RotateView((event.xmotion.x - lastMouse[0]) / 200.0f,
+									(event.xmotion.y - lastMouse[1]) / 200.0f);
+							lastMouse[0] = event.xmotion.x;
+							lastMouse[1] = event.xmotion.y;
+						}
+
+						if (mouseMoveEnabled)
+						{
+							VertexShaderManager::TranslateView((event.xmotion.x - lastMouse[0]) / 50.0f,
+									(event.xmotion.y - lastMouse[1]) / 50.0f);
+							lastMouse[0] = event.xmotion.x;
+							lastMouse[1] = event.xmotion.y;
+						}
+					}
+					break;
+				case ConfigureNotify:
+					Window winDummy;
+					unsigned int borderDummy, depthDummy;
+					XGetGeometry(GLWin.x_dpy, GLWin.win, &winDummy, &GLWin.x, &GLWin.y,
+							&GLWin.width, &GLWin.height, &borderDummy, &depthDummy);
+					s_backbuffer_width = GLWin.width;
+					s_backbuffer_height = GLWin.height;
+					break;
+				case ClientMessage:
+					if ((unsigned long) event.xclient.data.l[0] ==
+							XInternAtom(GLWin.x_dpy, "WM_DELETE_WINDOW", False))
+						Host_Message(WM_USER_STOP);
+					if ((unsigned long) event.xclient.data.l[0] ==
+							XInternAtom(GLWin.x_dpy, "RESIZE", False))
+						XMoveResizeWindow(GLWin.x_dpy, GLWin.win,
+								event.xclient.data.l[1], event.xclient.data.l[2],
+								event.xclient.data.l[3], event.xclient.data.l[4]);
+					break;
+				default:
+					break;
+			}
+		}
+		Common::SleepCurrentThread(20);
+	}
+}
+
+// Show the current FPS
+void cInterfaceEGL::UpdateFPSDisplay(const char *text)
+{
+	XStoreName(GLWin.x_dpy, GLWin.win, text);
+}
+void cInterfaceEGL::SwapBuffers()
+{
+	eglSwapBuffers(GLWin.egl_dpy, GLWin.egl_surf);
+}
+
+// Create rendering window.
+//		Call browser: Core.cpp:EmuThread() > main.cpp:Video_Initialize()
+bool cInterfaceEGL::CreateWindow(void *&window_handle)
+{
+	int _tx, _ty, _twidth, _theight;
+	Host_GetRenderWindowSize(_tx, _ty, _twidth, _theight);
+
+	// Control window size and picture scaling
+	s_backbuffer_width = _twidth;
+	s_backbuffer_height = _theight;
+
+	const char *s;
+   EGLint egl_major, egl_minor;
+
+   GLWin.x_dpy = XOpenDisplay(NULL);
+
+   if (!GLWin.x_dpy) {
+      printf("Error: couldn't open display\n");
+      return false;
+   }
+
+   GLWin.egl_dpy = eglGetDisplay(GLWin.x_dpy);
+   if (!GLWin.egl_dpy) {
+      printf("Error: eglGetDisplay() failed\n");
+      return false;
+   }
+
+   if (!eglInitialize(GLWin.egl_dpy, &egl_major, &egl_minor)) {
+      printf("Error: eglInitialize() failed\n");
+      return false;
+   }
+
+   s = eglQueryString(GLWin.egl_dpy, EGL_VERSION);
+   printf("EGL_VERSION = %s\n", s);
+
+   s = eglQueryString(GLWin.egl_dpy, EGL_VENDOR);
+   printf("EGL_VENDOR = %s\n", s);
+
+   s = eglQueryString(GLWin.egl_dpy, EGL_EXTENSIONS);
+   printf("EGL_EXTENSIONS = %s\n", s);
+
+   s = eglQueryString(GLWin.egl_dpy, EGL_CLIENT_APIS);
+   printf("EGL_CLIENT_APIS = %s\n", s);
+
+	// attributes for a visual in RGBA format with at least
+	// 8 bits per color and a 24 bit depth buffer
+	int attribs[] = {
+		EGL_RED_SIZE, 8,
+		EGL_GREEN_SIZE, 8,
+		EGL_BLUE_SIZE, 8,
+		EGL_DEPTH_SIZE, 24,
+#ifdef USE_GLES
+		EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+#else
+		EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+#endif
+		EGL_NONE };
+
+	static const EGLint ctx_attribs[] = {
+#ifdef USE_GLES
+		EGL_CONTEXT_CLIENT_VERSION, 2,
+#endif
+		EGL_NONE
+	};
+	
+	GLWin.x_evdpy = XOpenDisplay(NULL);
+	GLWin.parent = (Window)window_handle;
+	GLWin.screen = DefaultScreen(GLWin.x_dpy);
+	if (GLWin.parent == 0)
+		GLWin.parent = RootWindow(GLWin.x_dpy, GLWin.screen);
+
+   unsigned long mask;
+   XVisualInfo  visTemplate;
+   int num_visuals;
+   EGLConfig config;
+   EGLint num_configs;
+   EGLint vid;
+
+   if (!eglChooseConfig( GLWin.egl_dpy, attribs, &config, 1, &num_configs)) {
+      printf("Error: couldn't get an EGL visual config\n");
+      exit(1);
+   }
+
+   if (!eglGetConfigAttrib(GLWin.egl_dpy, config, EGL_NATIVE_VISUAL_ID, &vid)) {
+      printf("Error: eglGetConfigAttrib() failed\n");
+      exit(1);
+   }
+
+   /* The X window visual must match the EGL config */
+   visTemplate.visualid = vid;
+   GLWin.vi = XGetVisualInfo(GLWin.x_dpy, VisualIDMask, &visTemplate, &num_visuals);
+   if (!GLWin.vi) {
+      printf("Error: couldn't get X visual\n");
+      exit(1);
+   }
+	
+	GLWin.x = _tx;
+	GLWin.y = _ty;
+	GLWin.width = _twidth;
+	GLWin.height = _theight;
+
+	CreateXWindow();
+#ifdef USE_GLES
+	eglBindAPI(EGL_OPENGL_ES_API);
+#else
+	eglBindAPI(EGL_OPENGL_API);
+#endif
+	GLWin.egl_ctx = eglCreateContext(GLWin.egl_dpy, config, EGL_NO_CONTEXT, ctx_attribs );
+   if (!GLWin.egl_ctx) {
+      printf("Error: eglCreateContext failed\n");
+      exit(1);
+   }
+
+   GLWin.egl_surf = eglCreateWindowSurface(GLWin.egl_dpy, config, GLWin.win, NULL);
+   if (!GLWin.egl_surf) {
+      printf("Error: eglCreateWindowSurface failed\n");
+      exit(1);
+   }
+
+   if (!eglMakeCurrent(GLWin.egl_dpy, GLWin.egl_surf, GLWin.egl_surf, GLWin.egl_ctx)) {
+
+      printf("Error: eglMakeCurrent() failed\n");
+      return false;
+   }
+	
+
+	printf("GL_VENDOR: %s\n", glGetString(GL_VENDOR));
+	printf("GL_RENDERER: %s\n", glGetString(GL_RENDERER));
+	printf("GL_VERSION: %s\n", glGetString(GL_VERSION));
+	printf("GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS));
+   /* Set initial projection/viewing transformation.
+    * We can't be sure we'll get a ConfigureNotify event when the window
+    * first appears.
+    */
+	glViewport(0, 0, (GLint) _twidth, (GLint) _theight);
+	window_handle = (void *)GLWin.win;
+	return true;
+}
+
+bool cInterfaceEGL::MakeCurrent()
+{
+	return eglMakeCurrent(GLWin.egl_dpy, GLWin.egl_surf, GLWin.egl_surf, GLWin.egl_ctx);
+}
+// Close backend
+void cInterfaceEGL::Shutdown()
+{
+	DestroyXWindow();
+	if (GLWin.egl_ctx && !eglMakeCurrent(GLWin.egl_dpy, GLWin.egl_surf, GLWin.egl_surf, GLWin.egl_ctx))
+		NOTICE_LOG(VIDEO, "Could not release drawing context.");
+	if (GLWin.egl_ctx)
+	{
+		eglDestroyContext(GLWin.egl_dpy, GLWin.egl_ctx);
+		eglDestroySurface(GLWin.egl_dpy, GLWin.egl_surf);
+		eglTerminate(GLWin.egl_dpy);
+		GLWin.egl_ctx = NULL;
+	}
+}
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/EGL.h b/Source/Core/DolphinWX/Src/VideoInterface/EGL.h
new file mode 100644
index 0000000000..afb57b2ac2
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/EGL.h
@@ -0,0 +1,43 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+#ifndef _INTERFACEGLX_H_
+#define _INTERFACEGLX_H_
+
+#include <EGL/egl.h>
+#ifdef USE_GLES
+#include <GLES2/gl2.h>
+#else
+#include <GL/glxew.h>
+#include <GL/gl.h>
+#endif
+#include "InterfaceBase.h"
+
+class cInterfaceEGL : public cInterfaceBase
+{
+private:
+	void CreateXWindow();
+	void DestroyXWindow();
+	void XEventThread(); 
+public:
+	void SwapBuffers();
+	void UpdateFPSDisplay(const char *Text);
+	bool CreateWindow(void *&window_handle);
+	bool MakeCurrent();
+	void Shutdown(); 
+};
+#endif
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/GLX.cpp b/Source/Core/DolphinWX/Src/VideoInterface/GLX.cpp
new file mode 100644
index 0000000000..63458f7a4d
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/GLX.cpp
@@ -0,0 +1,342 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "VideoConfig.h"
+#include "Host.h"
+#include "RenderBase.h"
+
+#include "VertexShaderManager.h"
+#include "../GLVideoInterface.h"
+#include "GLX.h"
+
+void cInterfaceGLX::CreateXWindow(void)
+{
+	Atom wmProtocols[1];
+
+	// Setup window attributes
+	GLWin.attr.colormap = XCreateColormap(GLWin.evdpy,
+			GLWin.parent, GLWin.vi->visual, AllocNone);
+	GLWin.attr.event_mask = KeyPressMask | StructureNotifyMask | FocusChangeMask;
+	GLWin.attr.background_pixel = BlackPixel(GLWin.evdpy, GLWin.screen);
+	GLWin.attr.border_pixel = 0;
+
+	// Create the window
+	GLWin.win = XCreateWindow(GLWin.evdpy, GLWin.parent,
+			GLWin.x, GLWin.y, GLWin.width, GLWin.height, 0,
+			GLWin.vi->depth, InputOutput, GLWin.vi->visual,
+			CWBorderPixel | CWBackPixel | CWColormap | CWEventMask, &GLWin.attr);
+	wmProtocols[0] = XInternAtom(GLWin.evdpy, "WM_DELETE_WINDOW", True);
+	XSetWMProtocols(GLWin.evdpy, GLWin.win, wmProtocols, 1);
+	XSetStandardProperties(GLWin.evdpy, GLWin.win, "GPU", "GPU", None, NULL, 0, NULL);
+	XMapRaised(GLWin.evdpy, GLWin.win);
+	XSync(GLWin.evdpy, True);
+
+	GLWin.xEventThread = std::thread(&cInterfaceGLX::XEventThread, this);
+}
+
+void cInterfaceGLX::DestroyXWindow(void)
+{
+	XUnmapWindow(GLWin.dpy, GLWin.win);
+	GLWin.win = 0;
+	if (GLWin.xEventThread.joinable())
+		GLWin.xEventThread.join();
+	XFreeColormap(GLWin.evdpy, GLWin.attr.colormap);
+}
+
+void cInterfaceGLX::XEventThread()
+{
+	// Free look variables
+	static bool mouseLookEnabled = false;
+	static bool mouseMoveEnabled = false;
+	static float lastMouse[2];
+	while (GLWin.win)
+	{
+		XEvent event;
+		KeySym key;
+		for (int num_events = XPending(GLWin.evdpy); num_events > 0; num_events--)
+		{
+			XNextEvent(GLWin.evdpy, &event);
+			switch(event.type) {
+				case KeyPress:
+					key = XLookupKeysym((XKeyEvent*)&event, 0);
+					switch (key)
+					{
+						case XK_3:
+							OSDChoice = 1;
+							// Toggle native resolution
+							g_Config.iEFBScale = g_Config.iEFBScale + 1;
+							if (g_Config.iEFBScale > 7) g_Config.iEFBScale = 0;
+							break;
+						case XK_4:
+							OSDChoice = 2;
+							// Toggle aspect ratio
+							g_Config.iAspectRatio = (g_Config.iAspectRatio + 1) & 3;
+							break;
+						case XK_5:
+							OSDChoice = 3;
+							// Toggle EFB copy
+							if (!g_Config.bEFBCopyEnable || g_Config.bCopyEFBToTexture)
+							{
+								g_Config.bEFBCopyEnable ^= true;
+								g_Config.bCopyEFBToTexture = false;
+							}
+							else
+							{
+								g_Config.bCopyEFBToTexture = !g_Config.bCopyEFBToTexture;
+							}
+							break;
+						case XK_6:
+							OSDChoice = 4;
+							g_Config.bDisableFog = !g_Config.bDisableFog;
+							break;
+						default:
+							break;
+					}
+					if (g_Config.bFreeLook)
+					{
+						static float debugSpeed = 1.0f;
+						switch (key)
+						{
+							case XK_parenleft:
+								debugSpeed /= 2.0f;
+								break;
+							case XK_parenright:
+								debugSpeed *= 2.0f;
+								break;
+							case XK_w:
+								VertexShaderManager::TranslateView(0.0f, debugSpeed);
+								break;
+							case XK_s:
+								VertexShaderManager::TranslateView(0.0f, -debugSpeed);
+								break;
+							case XK_a:
+								VertexShaderManager::TranslateView(debugSpeed, 0.0f);
+								break;
+							case XK_d:
+								VertexShaderManager::TranslateView(-debugSpeed, 0.0f);
+								break;
+							case XK_r:
+								VertexShaderManager::ResetView();
+								break;
+						}
+					}
+					break;
+				case ButtonPress:
+					if (g_Config.bFreeLook)
+					{
+						switch (event.xbutton.button)
+						{
+							case 2: // Middle button
+								lastMouse[0] = event.xbutton.x;
+								lastMouse[1] = event.xbutton.y;
+								mouseMoveEnabled = true;
+								break;
+							case 3: // Right button
+								lastMouse[0] = event.xbutton.x;
+								lastMouse[1] = event.xbutton.y;
+								mouseLookEnabled = true;
+								break;
+						}
+					}
+					break;
+				case ButtonRelease:
+					if (g_Config.bFreeLook)
+					{
+						switch (event.xbutton.button)
+						{
+							case 2: // Middle button
+								mouseMoveEnabled = false;
+								break;
+							case 3: // Right button
+								mouseLookEnabled = false;
+								break;
+						}
+					}
+					break;
+				case MotionNotify:
+					if (g_Config.bFreeLook)
+					{
+						if (mouseLookEnabled)
+						{
+							VertexShaderManager::RotateView((event.xmotion.x - lastMouse[0]) / 200.0f,
+									(event.xmotion.y - lastMouse[1]) / 200.0f);
+							lastMouse[0] = event.xmotion.x;
+							lastMouse[1] = event.xmotion.y;
+						}
+
+						if (mouseMoveEnabled)
+						{
+							VertexShaderManager::TranslateView((event.xmotion.x - lastMouse[0]) / 50.0f,
+									(event.xmotion.y - lastMouse[1]) / 50.0f);
+							lastMouse[0] = event.xmotion.x;
+							lastMouse[1] = event.xmotion.y;
+						}
+					}
+					break;
+				case ConfigureNotify:
+					Window winDummy;
+					unsigned int borderDummy, depthDummy;
+					XGetGeometry(GLWin.evdpy, GLWin.win, &winDummy, &GLWin.x, &GLWin.y,
+							&GLWin.width, &GLWin.height, &borderDummy, &depthDummy);
+					s_backbuffer_width = GLWin.width;
+					s_backbuffer_height = GLWin.height;
+					break;
+				case ClientMessage:
+					if ((unsigned long) event.xclient.data.l[0] ==
+							XInternAtom(GLWin.evdpy, "WM_DELETE_WINDOW", False))
+						Host_Message(WM_USER_STOP);
+					if ((unsigned long) event.xclient.data.l[0] ==
+							XInternAtom(GLWin.evdpy, "RESIZE", False))
+						XMoveResizeWindow(GLWin.evdpy, GLWin.win,
+								event.xclient.data.l[1], event.xclient.data.l[2],
+								event.xclient.data.l[3], event.xclient.data.l[4]);
+					break;
+				default:
+					break;
+			}
+		}
+		Common::SleepCurrentThread(20);
+	}
+}
+
+// Show the current FPS
+void cInterfaceGLX::UpdateFPSDisplay(const char *text)
+{
+	XStoreName(GLWin.dpy, GLWin.win, text);
+}
+void cInterfaceGLX::SwapBuffers()
+{
+	glXSwapBuffers(GLWin.dpy, GLWin.win);
+}
+
+// Create rendering window.
+//		Call browser: Core.cpp:EmuThread() > main.cpp:Video_Initialize()
+bool cInterfaceGLX::CreateWindow(void *&window_handle)
+{
+	int _tx, _ty, _twidth, _theight;
+	Host_GetRenderWindowSize(_tx, _ty, _twidth, _theight);
+
+	// Control window size and picture scaling
+	s_backbuffer_width = _twidth;
+	s_backbuffer_height = _theight;
+
+	int glxMajorVersion, glxMinorVersion;
+
+	// attributes for a single buffered visual in RGBA format with at least
+	// 8 bits per color and a 24 bit depth buffer
+	int attrListSgl[] = {GLX_RGBA, GLX_RED_SIZE, 8,
+		GLX_GREEN_SIZE, 8,
+		GLX_BLUE_SIZE, 8,
+		GLX_DEPTH_SIZE, 24,
+		None};
+
+	// attributes for a double buffered visual in RGBA format with at least
+	// 8 bits per color and a 24 bit depth buffer
+	int attrListDbl[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
+		GLX_RED_SIZE, 8,
+		GLX_GREEN_SIZE, 8,
+		GLX_BLUE_SIZE, 8,
+		GLX_DEPTH_SIZE, 24,
+		GLX_SAMPLE_BUFFERS_ARB, g_Config.iMultisampleMode != MULTISAMPLE_OFF?1:0,
+		GLX_SAMPLES_ARB, g_Config.iMultisampleMode != MULTISAMPLE_OFF?1:0, 
+		None };
+
+	int attrListDefault[] = {
+		GLX_RGBA,
+		GLX_RED_SIZE, 1,
+		GLX_GREEN_SIZE, 1,
+		GLX_BLUE_SIZE, 1,
+		GLX_DOUBLEBUFFER,
+		GLX_DEPTH_SIZE, 1,
+		None };
+
+	GLWin.dpy = XOpenDisplay(0);
+	GLWin.evdpy = XOpenDisplay(0);
+	GLWin.parent = (Window)window_handle;
+	GLWin.screen = DefaultScreen(GLWin.dpy);
+	if (GLWin.parent == 0)
+		GLWin.parent = RootWindow(GLWin.dpy, GLWin.screen);
+
+	glXQueryVersion(GLWin.dpy, &glxMajorVersion, &glxMinorVersion);
+	NOTICE_LOG(VIDEO, "glX-Version %d.%d", glxMajorVersion, glxMinorVersion);
+
+	// Get an appropriate visual
+	GLWin.vi = glXChooseVisual(GLWin.dpy, GLWin.screen, attrListDbl);
+	if (GLWin.vi == NULL)
+	{
+		GLWin.vi = glXChooseVisual(GLWin.dpy, GLWin.screen, attrListSgl);
+		if (GLWin.vi != NULL)
+		{
+			ERROR_LOG(VIDEO, "Only single buffered visual!");
+		}
+		else
+		{
+			GLWin.vi = glXChooseVisual(GLWin.dpy, GLWin.screen, attrListDefault);
+			if (GLWin.vi == NULL)
+			{
+				ERROR_LOG(VIDEO, "Could not choose visual (glXChooseVisual)");
+				return false;
+			}
+		}
+	}
+	else
+		NOTICE_LOG(VIDEO, "Got double buffered visual!");
+
+	// Create a GLX context.
+	GLWin.ctx = glXCreateContext(GLWin.dpy, GLWin.vi, 0, GL_TRUE);
+	if (!GLWin.ctx)
+	{
+		PanicAlert("Unable to create GLX context.");
+		return false;
+	}
+
+	GLWin.x = _tx;
+	GLWin.y = _ty;
+	GLWin.width = _twidth;
+	GLWin.height = _theight;
+
+	CreateXWindow();
+	window_handle = (void *)GLWin.win;
+	return true;
+}
+
+bool cInterfaceGLX::MakeCurrent()
+{
+	// connect the glx-context to the window
+	#if defined(HAVE_WX) && (HAVE_WX)
+	Host_GetRenderWindowSize(GLWin.x, GLWin.y,
+			(int&)GLWin.width, (int&)GLWin.height);
+	XMoveResizeWindow(GLWin.dpy, GLWin.win, GLWin.x, GLWin.y,
+			GLWin.width, GLWin.height);
+	#endif
+	return glXMakeCurrent(GLWin.dpy, GLWin.win, GLWin.ctx);
+}
+// Close backend
+void cInterfaceGLX::Shutdown()
+{
+	DestroyXWindow();
+	if (GLWin.ctx && !glXMakeCurrent(GLWin.dpy, None, NULL))
+		NOTICE_LOG(VIDEO, "Could not release drawing context.");
+	if (GLWin.ctx)
+	{
+		glXDestroyContext(GLWin.dpy, GLWin.ctx);
+		XCloseDisplay(GLWin.dpy);
+		XCloseDisplay(GLWin.evdpy);
+		GLWin.ctx = NULL;
+	}
+}
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/GLX.h b/Source/Core/DolphinWX/Src/VideoInterface/GLX.h
new file mode 100644
index 0000000000..bea58cb862
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/GLX.h
@@ -0,0 +1,41 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+#ifndef _INTERFACEGLX_H_
+#define _INTERFACEGLX_H_
+
+#include <GL/glxew.h>
+#include <GL/gl.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+
+#include "InterfaceBase.h"
+
+class cInterfaceGLX : public cInterfaceBase
+{
+private:
+	void CreateXWindow();
+	void DestroyXWindow();
+	void XEventThread(); 
+public:
+	void SwapBuffers();
+	void UpdateFPSDisplay(const char *Text);
+	bool CreateWindow(void *&window_handle);
+	bool MakeCurrent();
+	void Shutdown(); 
+};
+#endif
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/InterfaceBase.h b/Source/Core/DolphinWX/Src/VideoInterface/InterfaceBase.h
new file mode 100644
index 0000000000..8fa4cc1b12
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/InterfaceBase.h
@@ -0,0 +1,36 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+class cInterfaceBase
+{
+protected:
+	// Window dimensions.
+	u32 s_backbuffer_width;
+	u32 s_backbuffer_height;
+public:
+	virtual void SwapBuffers() = 0;
+	virtual void UpdateFPSDisplay(const char *Text) = 0;
+	virtual bool CreateWindow(void *&window_handle) = 0;
+	virtual bool MakeCurrent() = 0;
+	virtual void Shutdown() = 0; 
+
+	virtual u32 GetBackBufferWidth() { return s_backbuffer_width; }
+	virtual u32 GetBackBufferHeight() { return s_backbuffer_height; }
+	virtual void Update() { } 
+	virtual bool PeekMessages() { return false; }
+};
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/WGL.cpp b/Source/Core/DolphinWX/Src/VideoInterface/WGL.cpp
new file mode 100644
index 0000000000..9abcd52fc6
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/WGL.cpp
@@ -0,0 +1,179 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "VideoConfig.h"
+#include "Host.h"
+#include "RenderBase.h"
+
+#include "VertexShaderManager.h"
+#include "../GLVideoInterface.h"
+#include "WGL.h"
+
+#include "EmuWindow.h"
+static HDC hDC = NULL;       // Private GDI Device Context
+static HGLRC hRC = NULL;     // Permanent Rendering Context
+
+void cInterfaceWGL::SwapBuffers()
+{
+	SwapBuffers(hDC);
+}
+
+// Draw messages on top of the screen
+bool cInterfaceWGL::PeekMessages()
+{
+	// TODO: peekmessage
+	MSG msg;
+	while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
+	{
+		if (msg.message == WM_QUIT)
+			return FALSE;
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+	}
+	return TRUE;
+}
+
+// Show the current FPS
+void cInterfaceWGL::UpdateFPSDisplay(const char *text)
+{
+	TCHAR temp[512];
+	swprintf_s(temp, sizeof(temp)/sizeof(TCHAR), _T("%hs"), text);
+	EmuWindow::SetWindowText(temp);
+}
+
+// Create rendering window.
+//		Call browser: Core.cpp:EmuThread() > main.cpp:Video_Initialize()
+bool cInterfaceWGL::CreateWindow(void *&window_handle)
+{
+	int _tx, _ty, _twidth, _theight;
+	Host_GetRenderWindowSize(_tx, _ty, _twidth, _theight);
+
+	// Control window size and picture scaling
+	s_backbuffer_width = _twidth;
+	s_backbuffer_height = _theight;
+
+	window_handle = (void*)EmuWindow::Create((HWND)window_handle, GetModuleHandle(0), _T("Please wait..."));
+	if (window_handle == NULL)
+	{
+		Host_SysMessage("failed to create window");
+		return false;
+	}
+
+	// Show the window
+	EmuWindow::Show();
+
+	PIXELFORMATDESCRIPTOR pfd =         // pfd Tells Windows How We Want Things To Be
+	{
+		sizeof(PIXELFORMATDESCRIPTOR),  // Size Of This Pixel Format Descriptor
+		1,                              // Version Number
+		PFD_DRAW_TO_WINDOW |            // Format Must Support Window
+			PFD_SUPPORT_OPENGL |        // Format Must Support OpenGL
+			PFD_DOUBLEBUFFER,           // Must Support Double Buffering
+		PFD_TYPE_RGBA,                  // Request An RGBA Format
+		32,                             // Select Our Color Depth
+		0, 0, 0, 0, 0, 0,               // Color Bits Ignored
+		0,                              // 8bit Alpha Buffer
+		0,                              // Shift Bit Ignored
+		0,                              // No Accumulation Buffer
+		0, 0, 0, 0,                     // Accumulation Bits Ignored
+		24,                             // 24Bit Z-Buffer (Depth Buffer)  
+		8,                              // 8bit Stencil Buffer
+		0,                              // No Auxiliary Buffer
+		PFD_MAIN_PLANE,                 // Main Drawing Layer
+		0,                              // Reserved
+		0, 0, 0                         // Layer Masks Ignored
+	};
+
+	GLuint      PixelFormat;            // Holds The Results After Searching For A Match
+
+	if (!(hDC=GetDC(EmuWindow::GetWnd()))) {
+		PanicAlert("(1) Can't create an OpenGL Device context. Fail.");
+		return false;
+	}
+	if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd))) {
+		PanicAlert("(2) Can't find a suitable PixelFormat.");
+		return false;
+	}
+	if (!SetPixelFormat(hDC, PixelFormat, &pfd)) {
+		PanicAlert("(3) Can't set the PixelFormat.");
+		return false;
+	}
+	if (!(hRC = wglCreateContext(hDC))) {
+		PanicAlert("(4) Can't create an OpenGL rendering context.");
+		return false;
+	}
+	return true;
+}
+
+bool cInterfaceWGL::MakeCurrent()
+{
+	return wglMakeCurrent(hDC, hRC) ? true : false;
+}
+
+// Update window width, size and etc. Called from Render.cpp
+void cInterfaceWGL::Update()
+{
+	RECT rcWindow;
+	if (!EmuWindow::GetParentWnd())
+	{
+		// We are not rendering to a child window - use client size.
+		GetClientRect(EmuWindow::GetWnd(), &rcWindow);
+	}
+	else
+	{
+		// We are rendering to a child window - use parent size.
+		GetWindowRect(EmuWindow::GetParentWnd(), &rcWindow);
+	}
+
+	// Get the new window width and height
+	// See below for documentation
+	int width = rcWindow.right - rcWindow.left;
+	int height = rcWindow.bottom - rcWindow.top;
+
+	// If we are rendering to a child window
+	if (EmuWindow::GetParentWnd() != 0 &&
+			(s_backbuffer_width != width || s_backbuffer_height != height) &&
+			width >= 4 && height >= 4)
+	{
+		::MoveWindow(EmuWindow::GetWnd(), 0, 0, width, height, FALSE);
+		s_backbuffer_width = width;
+		s_backbuffer_height = height;
+	}
+}
+
+// Close backend
+void cInterfaceWGL::Shutdown()
+{
+	if (hRC)
+	{
+		if (!wglMakeCurrent(NULL, NULL))
+			NOTICE_LOG(VIDEO, "Could not release drawing context.");
+
+		if (!wglDeleteContext(hRC))
+			ERROR_LOG(VIDEO, "Release Rendering Context Failed.");
+
+		hRC = NULL;
+	}
+
+	if (hDC && !ReleaseDC(EmuWindow::GetWnd(), hDC))
+	{
+		ERROR_LOG(VIDEO, "Release Device Context Failed.");
+		hDC = NULL;
+	}
+}
+
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/WGL.h b/Source/Core/DolphinWX/Src/VideoInterface/WGL.h
new file mode 100644
index 0000000000..4ef6943623
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/WGL.h
@@ -0,0 +1,41 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+#ifndef _INTERFACEWGL_H_
+#define _INTERFACEWGL_H_
+
+#ifdef _WIN32
+#define GLEW_STATIC
+#include <GL/glew.h>
+#include <GL/wglew.h>
+#endif
+
+#include "InterfaceBase.h"
+
+class cInterfaceWGL : public cInterfaceBase
+{
+public:
+	void SwapBuffers();
+	void UpdateFPSDisplay(const char *Text);
+	bool CreateWindow(void *&window_handle);
+	bool MakeCurrent();
+	void Shutdown(); 
+
+	void Update();
+	bool PeekMessages();
+};
+#endif
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/WX.cpp b/Source/Core/DolphinWX/Src/VideoInterface/WX.cpp
new file mode 100644
index 0000000000..7126ccb8ba
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/WX.cpp
@@ -0,0 +1,82 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "VideoConfig.h"
+#include "Host.h"
+#include "RenderBase.h"
+
+#include "VertexShaderManager.h"
+#include "../GLVideoInterface.h"
+#include "WX.h"
+
+void cInterfaceWX::SwapBuffers()
+{
+	GLWin.glCanvas->SwapBuffers();
+}
+
+void cInterfaceWX::UpdateFPSDisplay(const char *text)
+{
+	// Handled by Host_UpdateTitle()
+}
+
+// Create rendering window.
+//		Call browser: Core.cpp:EmuThread() > main.cpp:Video_Initialize()
+bool cInterfaceWX::CreateCreate(void *&window_handle)
+{
+	int _tx, _ty, _twidth, _theight;
+	Host_GetRenderWindowSize(_tx, _ty, _twidth, _theight);
+
+	// Control window size and picture scaling
+	s_backbuffer_width = _twidth;
+	s_backbuffer_height = _theight;
+
+	GLWin.panel = (wxPanel *)window_handle;
+	GLWin.glCanvas = new wxGLCanvas(GLWin.panel, wxID_ANY, NULL,
+		wxPoint(0, 0), wxSize(_twidth, _theight));
+	GLWin.glCanvas->Show(true);
+	if (GLWin.glCtxt == NULL) // XXX dirty hack
+		GLWin.glCtxt = new wxGLContext(GLWin.glCanvas);
+}
+
+bool cInterfaceWX::MakeCurrent()
+{
+	return GLWin.glCanvas->SetCurrent(*GLWin.glCtxt);
+}
+
+// Update window width, size and etc. Called from Render.cpp
+void cInterfaceWX::Update()
+{
+	int width, height;
+
+	GLWin.panel->GetSize(&width, &height);
+	if (width == s_backbuffer_width && height == s_backbuffer_height)
+		return;
+
+	GLWin.glCanvas->SetFocus();
+	GLWin.glCanvas->SetSize(0, 0, width, height);
+	GLWin.glCtxt->SetCurrent(*GLWin.glCanvas);
+	s_backbuffer_width = width;
+	s_backbuffer_height = height;
+}
+
+// Close backend
+void cInterfaceWX::Shutdown()
+{
+	GLWin.glCanvas->Hide();
+}
+
+
diff --git a/Source/Core/DolphinWX/Src/VideoInterface/WX.h b/Source/Core/DolphinWX/Src/VideoInterface/WX.h
new file mode 100644
index 0000000000..290b0262ed
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/VideoInterface/WX.h
@@ -0,0 +1,41 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+#ifndef _INTERFACEWX_H_
+#define _INTERFACEWX_H_
+
+#include <GL/glxew.h>
+#include <GL/gl.h>
+#if defined USE_WX && USE_WX
+#include "wx/wx.h"
+#include "wx/glcanvas.h"
+#endif
+
+#include "InterfaceBase.h"
+
+class cInterfaceWX : public cInterfaceBase
+{
+public:
+	void SwapBuffers();
+	void UpdateFPSDisplay(const char *Text);
+	bool CreateWindow(void *&window_handle);
+	bool MakeCurrent();
+	void Shutdown(); 
+
+	void Update();
+};
+#endif
+