public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags)
 {
     WinWindowInfo winWindowInfo = (WinWindowInfo) window;
       IntPtr display = this.GetDisplay(winWindowInfo.DeviceContext);
       EglWindowInfo window1 = new EglWindowInfo(winWindowInfo.WindowHandle, display);
       return (IGraphicsContext) new EglContext(handle, window1, shareContext, major, minor, flags);
 }

 public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags)
 {
     X11WindowInfo x11_win = (X11WindowInfo)window;
     //EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(x11_win.WindowHandle, Egl.GetDisplay(x11_win.Display));
     EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(x11_win.WindowHandle, Egl.GetDisplay(new IntPtr(0)));
     return new EglContext(handle, egl_win, shareContext, major, minor, flags);
 }

 public static void InitialSetup()
 {
     // FOR THE LOVE OF GOD PLEASE LET THIS WORK
     AudioDevice = Alc.OpenDevice (null); // Default device
     if (AudioDevice != null) {
         AudioCtx = Alc.CreateContext(AudioDevice, (int[])null);
         if(AudioCtx != ContextHandle.Zero)
         {
             Alc.GetError(AudioDevice);
             if(Alc.MakeContextCurrent( AudioCtx ))
             {
                 //LoadWaveFile ("camprespite_loop", "camprespite_loop.wav");
                 LoadWaveFile ("last_human_loop", "last_human_loop_limited.wav");//.DurationAdjust(0.01);
                 LoadWaveFile ("induction_loop", "induction_loop.wav");
                 LoadWaveFile ("sfx_bullet_impact", "sfx_bullet_impact.wav");
                 LoadWaveFile ("sfx_player_land_two_feet", "sfx_player_land_two_feet.wav");
                 LoadWaveFile ("sfx_shoot_gun", "sfx_shoot_gun.wav");
                 LoadWaveFile ("win", "win.wav");
             }
             else
                 throw new Exception("Failed to set current audio context");
         }
         else
             throw new Exception("Failed to create audio context.");
     }
     else
         throw new Exception("Failed to open default audio device.");
 }

        public void CreateContext(bool direct, IGLContext source)
        {
            Debug.WriteLine(String.Format("OpenGL context is bound to handle: {0}", this.windowInfo.Handle));

            Debug.Write("Creating render context... ");
            // Do not rely on OpenTK.Platform.Windows.Wgl - the context is not ready yet,
            // and Wgl extensions will fail to load.
            renderContext = new ContextHandle(Wgl.Imports.CreateContext(deviceContext));
            if (renderContext == IntPtr.Zero)
                throw new ApplicationException("Could not create OpenGL render context (Wgl.CreateContext() return 0).");
            
            Debug.WriteLine(String.Format("done! (id: {0})", renderContext));

            Wgl.Imports.MakeCurrent(deviceContext, renderContext);
            Wgl.LoadAll();
            GL.LoadAll();
            Glu.LoadAll();

            vsync_supported = Wgl.Arb.SupportsExtension(this.deviceContext, "WGL_EXT_swap_control") &&
                Wgl.Load("wglGetSwapIntervalEXT") && Wgl.Load("wglSwapIntervalEXT");

            if (source != null)
            {
                Debug.Print("Sharing state with context {0}", (source as IGLContextInternal).Context);
                Wgl.Imports.ShareLists(renderContext, (source as IGLContextInternal).Context);
            }
        }

 public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags)
 {
     WinWindowInfo win_win = (WinWindowInfo)window;
     IntPtr egl_display = GetDisplay(win_win.DeviceContext);
     EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(win_win.WindowHandle, egl_display);
     return new EglContext(handle, egl_win, shareContext, major, minor, flags);
 }

        static WinGLContext()
        {
            // Dynamically load the OpenGL32.dll in order to use the extension loading capabilities of Wgl.
            if (opengl32Handle == IntPtr.Zero)
            {
                opengl32Handle = Functions.LoadLibrary(opengl32Name);
                if (opengl32Handle == IntPtr.Zero)
                    throw new ApplicationException(String.Format("LoadLibrary(\"{0}\") call failed with code {1}",
                                                                 opengl32Name, Marshal.GetLastWin32Error()));
                Debug.WriteLine(String.Format("Loaded opengl32.dll: {0}", opengl32Handle));
            }

            // We need to create a temp context in order to load
            // wgl extensions (e.g. for multisampling or GL3).
            // We cannot rely on OpenTK.Platform.Wgl until we
            // create the context and call Wgl.LoadAll().
            Debug.Print("Creating temporary context for wgl extensions.");
            using (INativeWindow native = new NativeWindow())
            {
                // Create temporary context and load WGL entry points
                WinWindowInfo window = native.WindowInfo as WinWindowInfo;
                ContextHandle temp_context = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext));
                Wgl.Imports.MakeCurrent(window.DeviceContext, temp_context.Handle);
                Wgl.LoadAll();

                // Query graphics modes
                ModeSelector = new WinGraphicsMode(temp_context, window.DeviceContext);
                
                // Destroy temporary context
                Wgl.Imports.MakeCurrent(IntPtr.Zero, IntPtr.Zero);
                Wgl.Imports.DeleteContext(temp_context.Handle);
                wgl_loaded = true;
            }
        }

        internal iPhoneOSGraphicsContext(ContextHandle handle, IWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags)
        {
            // ignore mode, window

            iPhoneOSGraphicsContext shared = sharedContext as iPhoneOSGraphicsContext;

            EAGLRenderingAPI version = 0;
            if (major == 1 && minor == 1)
                version = EAGLRenderingAPI.OpenGLES1;
            else if (major == 2 && minor == 0)
                version = EAGLRenderingAPI.OpenGLES2;
            else if (major == 3 && minor == 0)
                version = EAGLRenderingAPI.OpenGLES3;
            else
                throw new ArgumentException (string.Format("Unsupported GLES version {0}.{1}.", major, minor));

            if (handle.Handle == IntPtr.Zero) {
                EAGLContext = shared != null && shared.EAGLContext != null
                    ? new EAGLContext(version, shared.EAGLContext.ShareGroup)
                    : new EAGLContext(version);
                contextHandle = new ContextHandle(EAGLContext.Handle);
            } else {
                EAGLContext = (EAGLContext) Runtime.GetNSObject (handle.Handle);
                contextHandle = handle;
            }
        }

		// initialize
		internal static void Initialize() {
			// openal
			OpenAlDevice = Alc.OpenDevice(null);
			if (OpenAlDevice != IntPtr.Zero) {
                OpenAlContext = Alc.CreateContext(OpenAlDevice, (int[])null);
				if (OpenAlContext != ContextHandle.Zero) {
					Alc.MakeContextCurrent(OpenAlContext);
					AL.SpeedOfSound(343.0f);
					AL.DistanceModel(ALDistanceModel.None);
				} else {
					Alc.CloseDevice(OpenAlDevice);
					OpenAlDevice = IntPtr.Zero;
					System.Windows.Forms.MessageBox.Show("The sound device could be opened, but the sound context could not be created.", "openBVE", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Hand);
				}
			} else {
				OpenAlContext = ContextHandle.Zero;
				System.Windows.Forms.MessageBox.Show("The sound device could not be opened.", "openBVE", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Hand);
			}
			// outer radius
			switch (Interface.CurrentOptions.SoundRange) {
				case Interface.SoundRange.Low:
					OuterRadiusFactorMinimum = 2.0;
					OuterRadiusFactorMaximum = 8.0;
					break;
				case Interface.SoundRange.Medium:
					OuterRadiusFactorMinimum = 4.0;
					OuterRadiusFactorMaximum = 16.0;
					break;
				case Interface.SoundRange.High:
					OuterRadiusFactorMinimum = 8.0;
					OuterRadiusFactorMaximum = 32.0;
					break;
			}
			OuterRadiusFactor = OuterRadiusFactorMaximum;
		}

		private OpenALSoundController ()
		{
			alcMacOSXMixerOutputRate(PREFERRED_MIX_RATE);
			_device = Alc.OpenDevice (string.Empty);
			CheckALError ("Could not open AL device");
			if (_device != IntPtr.Zero) {
				int[] attribute = new int[0];
				_context = Alc.CreateContext (_device, attribute);
				CheckALError ("Could not open AL context");

				if (_context != ContextHandle.Zero) {
					Alc.MakeContextCurrent (_context);
					CheckALError ("Could not make AL context current");
				}
			} else {
				return;
			}

			allSourcesArray = new int[MAX_NUMBER_OF_SOURCES];
			AL.GenSources (allSourcesArray);

			availableSourcesCollection = new HashSet<int> ();
			inUseSourcesCollection = new HashSet<OALSoundBuffer> ();
			playingSourcesCollection = new HashSet<OALSoundBuffer> ();


			for (int x=0; x < MAX_NUMBER_OF_SOURCES; x++) {
				availableSourcesCollection.Add (allSourcesArray [x]);
			}
		}

 public EglContext(ContextHandle handle, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags)
 {
     if (handle == ContextHandle.Zero)
     throw new ArgumentException("handle");
       if (window == null)
     throw new ArgumentNullException("window");
       this.Handle = handle;
 }

 // Necessary to allow creation of dummy GraphicsContexts (see CreateDummyContext static method).
 GraphicsContext(ContextHandle handle)
 {
     implementation = new OpenTK.Platform.Dummy.DummyGLContext(handle);
     lock (SyncRoot)
     {
         available_contexts.Add((implementation as IGraphicsContextInternal).Context, new WeakReference(this));
     }
 }

 public void CreateContext(bool direct, IGraphicsContext source)
 {
     if (Handle == ContextHandle.Zero)
     {
         ++handle_count;
         Handle = new ContextHandle((IntPtr)handle_count);
     }
 }

        // Necessary to allow creation of dummy GraphicsContexts (see CreateDummyContext static method).
        GraphicsContext(ContextHandle handle)
        {
            implementation = new OpenTK.Platform.Dummy.DummyGLContext(handle);

            lock (SyncRoot)
            {
                AddContext(this);
            }
        }

 public AglContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext)
 {
     if (handle == ContextHandle.Zero)
     throw new ArgumentException("handle");
       if (window == null)
     throw new ArgumentNullException("window");
       this.Handle = handle;
       this.carbonWindow = (CarbonWindowInfo) window;
 }

        public SDL2GLContext(IntPtr ctxhandle, IWindowInfo windowInfo)
        {
			Console.WriteLine("WARNING! Creating context in a way we don't quite understand.");
            SDL2WindowInfo currentWindow = (SDL2WindowInfo)windowInfo;
			window = currentWindow.WindowHandle;
			context = ctxhandle;
			Handle = new ContextHandle(context);
			MakeCurrent(windowInfo);
        }

 public DummyGLContext(ContextHandle handle, GraphicsContext.GetAddressDelegate loader)
     : this()
 {
     if (handle != ContextHandle.Zero)
     {
         Handle = handle;
     }
     Loader = loader;
     Mode = new GraphicsMode(new IntPtr(2), 32, 16, 0, 0, 0, 2, false);
 }

 public AglContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext)
     : base(DesktopBackend.OpenGL)
 {
     if (handle == ContextHandle.Zero)
         throw new ArgumentException("handle");
     if (window == null)
         throw new ArgumentNullException("window");
     Handle = handle;
     carbonWindow = (CarbonWindowInfo)window;
 }

 public CocoaContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, int majorVersion, int minorVersion)
 {
     if (handle == ContextHandle.Zero)
         throw new ArgumentException("handle");
     if (window == null)
         throw new ArgumentNullException("window");
     
     Handle = handle;
     cocoaWindow = (CocoaWindowInfo)window;
 }

 public X11GLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shared, bool direct,
     int major, int minor, GraphicsContextFlags flags)
     : base(DesktopBackend.OpenGL)
 {
     if (handle == ContextHandle.Zero)
         throw new ArgumentException("handle");
     if (window == null)
         throw new ArgumentNullException("window");
     Handle = handle;
     currentWindow = (X11WindowInfo)window;
     Display = currentWindow.Display;
 }

 public WinGraphicsMode(ContextHandle context, IntPtr device)
 {
     lock (SyncRoot)
     {
         modes.AddRange(GetModesARB(context, device));
         if (modes.Count == 0)
             modes.AddRange(GetModesPFD(context, device));
         if (modes.Count == 0)
             throw new GraphicsModeException(
                 "No GraphicsMode available. This should never happen, please report a bug at http://www.opentk.com");
         modes.Sort(new GraphicsModeComparer());
     }
 }