int swap_interval = 1; // Default interval is defined as 1 in EGL. #endregion #region Constructors public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (mode == null) throw new ArgumentNullException("mode"); if (window == null) throw new ArgumentNullException("window"); EglContext shared = (EglContext)sharedContext; int dummy_major, dummy_minor; if (!Egl.Initialize(window.Display, out dummy_major, out dummy_minor)) throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError())); WindowInfo = window; // Select an EGLConfig that matches the desired mode. We cannot use the 'mode' // parameter directly, since it may have originated on a different system (e.g. GLX) // and it may not support the desired renderer. Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo, major > 1 ? RenderableFlags.ES2 : RenderableFlags.ES); if (!Mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); IntPtr config = Mode.Index.Value; if (window.Surface == IntPtr.Zero) window.CreateWindowSurface(config); int[] attrib_list = new int[] { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE }; HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : IntPtr.Zero, attrib_list); MakeCurrent(window); }
public static IGraphicsContext CreateGraphicsContext(GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) { GraphicsContext graphicsContext = new GraphicsContext(mode, window, major, minor, flags); graphicsContext.MakeCurrent(window); graphicsContext.LoadAll(); return (IGraphicsContext) graphicsContext; }
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); }
bool vsync = true; // Default vsync value is defined as 1 (true) in EGL. #endregion #region Constructors public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (mode == null) throw new ArgumentNullException("mode"); if (window == null) throw new ArgumentNullException("window"); EglContext shared = (EglContext)sharedContext; int dummy_major, dummy_minor; if (!Egl.Initialize(window.Display, out dummy_major, out dummy_minor)) throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError())); WindowInfo = window; Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo); if (!Mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); IntPtr config = Mode.Index.Value; if (window.Surface == IntPtr.Zero) window.CreateWindowSurface(config); int[] attrib_list = new int[] { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE }; HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : IntPtr.Zero, attrib_list); MakeCurrent(window); }
public override OpenTK.Graphics.IGraphicsContext CreateGLContext( GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { flags |= GraphicsContextFlags.Embedded; return base.CreateGLContext(mode, window, shareContext, directRendering, major, minor, flags); }
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); }
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; } }
public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (mode == null) throw new ArgumentNullException("mode"); if (window == null) throw new ArgumentNullException("window"); EglContext eglContext = (EglContext) sharedContext; int major1; int minor1; if (!Egl.Initialize(window.Display, out major1, out minor1)) throw new GraphicsContextException(string.Format("Failed to initialize EGL, error {0}.", (object) Egl.GetError())); this.WindowInfo = window; this.Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo, major > 1 ? RenderableFlags.ES2 : RenderableFlags.ES); if (!this.Mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); IntPtr config = this.Mode.Index.Value; if (window.Surface == IntPtr.Zero) window.CreateWindowSurface(config); int[] attrib_list = new int[3] { 12440, major, 12344 }; this.HandleAsEGLContext = Egl.CreateContext(window.Display, config, eglContext != null ? eglContext.HandleAsEGLContext : IntPtr.Zero, attrib_list); this.MakeCurrent((IWindowInfo) window); }
public override IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { WinWindowInfo win_win = (WinWindowInfo)window; EGLDisplay egl_display = Egl.GetDisplay(EGLNativeDisplayType.Default); // Egl.GetDisplay(new EGLNativeDisplayType(win_win.DeviceContext)); EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(win_win.WindowHandle, egl_display); return new EglContext(mode, egl_win, shareContext, major, minor, flags); }
public AndroidGraphicsContext (GraphicsMode mode, IWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (major < 1 || major > 3) throw new ArgumentException (string.Format("Unsupported GLES version {0}.{1}.", major, minor)); Init (mode, window, sharedContext, major, minor, flags); }
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; }
public BaseGame(string projectName, int glVersionMajor, int glVersionMinor, GraphicsContextFlags flags) : base(Settings.Width, Settings.Height, new GraphicsMode(Settings.Bpp, Settings.DepthBpp, 0, Settings.FSAA, 0, 2, false), projectName, 0, DisplayDevice.Default, glVersionMajor, glVersionMinor, flags) { Init(); Running = true; }
/// <summary> /// Creates an IGraphicsContext instance for the specified window. /// </summary> /// <param name="mode">The GraphicsMode for the GraphicsContext.</param> /// <param name="window">An IWindowInfo instance describing the parent window for this IGraphicsContext.</param> /// <param name="major">The major OpenGL version number for this IGraphicsContext.</param> /// <param name="minor">The minor OpenGL version number for this IGraphicsContext.</param> /// <param name="flags">A bitwise collection of GraphicsContextFlags with specific options for this IGraphicsContext.</param> /// <returns>A new IGraphicsContext instance.</returns> public static IGraphicsContext CreateGraphicsContext( GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) { GraphicsContext context = new GraphicsContext(mode, window, major, minor, flags); context.MakeCurrent(window); (context as IGraphicsContextInternal).LoadAll(); return context; }
public LinuxGraphicsContext(GraphicsMode mode, LinuxWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) : base(mode, window, sharedContext, major, minor, flags) { if (mode.Buffers < 1) throw new ArgumentException(); fd = window.FD; PageFlip = HandlePageFlip; PageFlipPtr = Marshal.GetFunctionPointerForDelegate(PageFlip); }
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; }
/// <summary> /// Constructs a new GLControl with the specified GraphicsMode. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the control.</param> /// <param name="major">The major version for the OpenGL GraphicsContext.</param> /// <param name="minor">The minor version for the OpenGL GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags for the OpenGL GraphicsContext.</param> public GLControl(GraphicsMode mode, int major, int minor, GraphicsContextFlags flags) { if (mode == null) throw new ArgumentNullException("mode"); SetStyle(ControlStyles.Opaque, true); SetStyle(ControlStyles.UserPaint, true); SetStyle(ControlStyles.AllPaintingInWmPaint, true); DoubleBuffered = false; this.format = mode; this.major = major; this.minor = minor; this.flags = flags; InitializeComponent(); }
public GraphicsContext(GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) { lock (GraphicsContext.SyncRoot) { bool local_0 = false; if (mode == null && window == null) { local_0 = true; } else { if (mode == null) throw new ArgumentNullException("mode", "Must be a valid GraphicsMode."); if (window == null) throw new ArgumentNullException("window", "Must point to a valid window."); } if (major <= 0) major = 1; if (minor < 0) minor = 0; IGraphicsContext local_1_1 = GraphicsContext.FindSharedContext(); if (local_0) { this.implementation = (IGraphicsContext) new DummyGLContext(); } else { IPlatformFactory local_2 = (IPlatformFactory) null; switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: local_2 = Factory.Default; break; case true: local_2 = Factory.Embedded; break; } this.implementation = local_2.CreateGLContext(mode, window, local_1_1, GraphicsContext.direct_rendering, major, minor, flags); if (GraphicsContext.GetCurrentContext == null) { GraphicsContext.GetCurrentContextDelegate local_3 = local_2.CreateGetCurrentGraphicsContext(); if (local_3 != null) GraphicsContext.GetCurrentContext = local_3; } } GraphicsContext.available_contexts.Add(this.Context, new WeakReference((object) this)); } }
int swap_interval = 1; // Default interval is defined as 1 in EGL. #endregion #region Constructors public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (mode == null) throw new ArgumentNullException("mode"); if (window == null) throw new ArgumentNullException("window"); EglContext shared = (EglContext)sharedContext; WindowInfo = window; // Select an EGLConfig that matches the desired mode. We cannot use the 'mode' // parameter directly, since it may have originated on a different system (e.g. GLX) // and it may not support the desired renderer. Renderable = RenderableFlags.GL; if ((flags & GraphicsContextFlags.Embedded) != 0) { Renderable = major > 1 ? RenderableFlags.ES2 : RenderableFlags.ES; } RenderApi api = (Renderable & RenderableFlags.GL) != 0 ? RenderApi.GL : RenderApi.ES; Debug.Print("[EGL] Binding {0} rendering API.", api); if (!Egl.BindAPI(api)) { Debug.Print("[EGL] Failed to bind rendering API. Error: {0}", Egl.GetError()); } Mode = new EglGraphicsMode().SelectGraphicsMode(window, mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo, Renderable); if (!Mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); IntPtr config = Mode.Index.Value; if (window.Surface == IntPtr.Zero) window.CreateWindowSurface(config); int[] attrib_list = new int[] { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE }; HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : IntPtr.Zero, attrib_list); MakeCurrent(window); }
/// <summary> /// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the specified window. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param> /// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param> /// <param name="major">The major version of the new GraphicsContext.</param> /// <param name="minor">The minor version of the new GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param> /// <remarks> /// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored. /// </remarks> public GraphicsContext(GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) { lock (SyncRoot) { bool designMode = false; if (mode == null && window == null) designMode = true; else if (mode == null) throw new ArgumentNullException("mode", "Must be a valid GraphicsMode."); else if (window == null) throw new ArgumentNullException("window", "Must point to a valid window."); // Silently ignore invalid major and minor versions. if (major <= 0) major = 1; if (minor < 0) minor = 0; Debug.Print("Creating GraphicsContext."); try { Debug.Indent(); Debug.Print("GraphicsMode: {0}", mode); Debug.Print("IWindowInfo: {0}", window); Debug.Print("GraphicsContextFlags: {0}", flags); Debug.Print("Requested version: {0}.{1}", major, minor); IGraphicsContext shareContext = shareContext = FindSharedContext(); // Todo: Add a DummyFactory implementing IPlatformFactory. if (designMode) implementation = new Platform.Dummy.DummyGLContext(); else switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: implementation = Factory.Default.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); break; case true: implementation = Factory.Embedded.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); break; } available_contexts.Add((this as IGraphicsContextInternal).Context, new WeakReference(this)); } finally { Debug.Unindent(); } } }
public DesktopViewController(Type rootClass, int windowWidth, int windowHeight, string windowTitle, GameWindowFlags windowFlags, DisplayDevice device, GraphicsContextFlags flags) : base(windowWidth, windowHeight, GraphicsMode.Default, windowTitle, windowFlags, device, -1, -1, flags) { Console.WriteLine("Sparrow-sharp: Starting"); _rootClass = rootClass; Load += HandleLoad; RenderFrame += HandleRenderFrame; Mouse.Move += OnMouseMove; Mouse.ButtonDown += OnMouseButtonChange; Mouse.ButtonUp += OnMouseButtonChange; // Run the game at 60 updates per second Run(60.0); }
public Program(int width, int height, GraphicsMode mode, string title, GameWindowFlags options, DisplayDevice device, int major, int minor, GraphicsContextFlags flags, IGraphicsContext sharedContext) : base(width, height, title, options, mode == null ? GraphicsMode.Default : mode, device == null ? DisplayDevice.Default : device) { try { glContext = new GraphicsContext(mode == null ? GraphicsMode.Default : mode, WindowInfo, major, minor, flags); glContext.MakeCurrent(WindowInfo); (glContext as IGraphicsContextInternal).LoadAll(); } catch (Exception e) { Debug.Print(e.ToString()); base.Dispose(); throw; } }
public SDL2GLContext (GraphicsMode mode, IWindowInfo windowInfo, IGraphicsContext shared, bool direct, int major, int minor, GraphicsContextFlags flags) { SDL2WindowInfo currentWindow = (SDL2WindowInfo)windowInfo; window = currentWindow.WindowHandle; if (shared != null) { shared.MakeCurrent (windowInfo); lock (API.sdl_api_lock) { API.GL_SetAttribute (API.GLAttr.ShareWithCurrentContext, 1); } } lock (API.sdl_api_lock) { context = API.GL_CreateContext (currentWindow.WindowHandle); } MakeCurrent (windowInfo); if (shared != null) { shared.MakeCurrent (windowInfo); } Handle = new ContextHandle(context); }
public abstract IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags);
/// <summary>Constructs a new GameWindow with the specified attributes.</summary> /// <param name="width">The width of the GameWindow in pixels.</param> /// <param name="height">The height of the GameWindow in pixels.</param> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GameWindow.</param> /// <param name="title">The title of the GameWindow.</param> /// <param name="options">GameWindow options regarding window appearance and behavior.</param> /// <param name="device">The OpenTK.Graphics.DisplayDevice to construct the GameWindow in.</param> /// <param name="major">The major version for the OpenGL GraphicsContext.</param> /// <param name="minor">The minor version for the OpenGL GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags version for the OpenGL GraphicsContext.</param> public GameWindow(int width, int height, GraphicsMode mode, string title, GameWindowFlags options, DisplayDevice device, int major, int minor, GraphicsContextFlags flags) : this(width, height, mode, title, options, device, major, minor, flags, null) { }
public NxTransparentGameWindow(int width, int height, GraphicsMode mode, string title, GameWindowFlags options, DisplayDevice device, int major, int minor, GraphicsContextFlags flags, IGraphicsContext sharedContext, bool isSingleThreaded) : base(width, height, mode, title, options, device, major, minor, flags, sharedContext, isSingleThreaded) { init(); }
static GraphicsMode GetGLAttributes(ContextHandle sdlContext, out GraphicsContextFlags context_flags) { context_flags = 0; int accum_red, accum_green, accum_blue, accum_alpha; SDL.GL.GetAttribute(ContextAttribute.ACCUM_RED_SIZE, out accum_red); SDL.GL.GetAttribute(ContextAttribute.ACCUM_GREEN_SIZE, out accum_green); SDL.GL.GetAttribute(ContextAttribute.ACCUM_BLUE_SIZE, out accum_blue); SDL.GL.GetAttribute(ContextAttribute.ACCUM_ALPHA_SIZE, out accum_alpha); int buffers; SDL.GL.GetAttribute(ContextAttribute.DOUBLEBUFFER, out buffers); // DOUBLEBUFFER return a boolean (0-false, 1-true), so we need // to adjust the buffer count (false->1 buffer, true->2 buffers) buffers++; int red, green, blue, alpha; SDL.GL.GetAttribute(ContextAttribute.RED_SIZE, out red); SDL.GL.GetAttribute(ContextAttribute.GREEN_SIZE, out green); SDL.GL.GetAttribute(ContextAttribute.BLUE_SIZE, out blue); SDL.GL.GetAttribute(ContextAttribute.ALPHA_SIZE, out alpha); int depth, stencil; SDL.GL.GetAttribute(ContextAttribute.DEPTH_SIZE, out depth); SDL.GL.GetAttribute(ContextAttribute.STENCIL_SIZE, out stencil); int samples; SDL.GL.GetAttribute(ContextAttribute.MULTISAMPLESAMPLES, out samples); int stereo; SDL.GL.GetAttribute(ContextAttribute.STEREO, out stereo); int major, minor; SDL.GL.GetAttribute(ContextAttribute.CONTEXT_MAJOR_VERSION, out major); SDL.GL.GetAttribute(ContextAttribute.CONTEXT_MINOR_VERSION, out minor); int flags; SDL.GL.GetAttribute(ContextAttribute.CONTEXT_FLAGS, out flags); int egl; SDL.GL.GetAttribute(ContextAttribute.CONTEXT_EGL, out egl); int profile; SDL.GL.GetAttribute(ContextAttribute.CONTEXT_PROFILE_MASK, out profile); if (egl != 0 && (profile & (int)ContextProfileFlags.ES) != 0) { context_flags |= GraphicsContextFlags.Embedded; } if ((flags & (int)ContextFlags.DEBUG) != 0) { context_flags |= GraphicsContextFlags.Debug; } if ((profile & (int)ContextProfileFlags.CORE) != 0) { context_flags |= GraphicsContextFlags.ForwardCompatible; } return(new GraphicsMode( new ColorFormat(red, green, blue, alpha), depth, stencil, samples, new ColorFormat(accum_red, accum_green, accum_blue, accum_alpha), buffers, stereo != 0 ? true : false)); }
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 osuTK.Platform.Egl.EglWindowInfo(win_win.Handle, egl_display); return(new EglWinContext(handle, egl_win, shareContext, major, minor, flags)); }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { throw new PlatformNotSupportedException(error_string); }
internal iPhoneOSGraphicsContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { // ignore mode, window iPhoneOSGraphicsContext shared = sharedContext as iPhoneOSGraphicsContext; EAGLRenderingAPI version = 0; 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)); } EAGLContext = shared != null && shared.EAGLContext != null ? new EAGLContext(version, shared.EAGLContext.ShareGroup) : new EAGLContext(version); Handle = new ContextHandle(EAGLContext.Handle); }
public IGraphicsContext CreateContext(int major, int minor, GraphicsContextFlags flags) { return(new GraphicsContext(mode, WindowInfo, major, minor, flags)); }
/// <summary> /// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the specified window. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param> /// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param> /// <param name="major">The major version of the new GraphicsContext.</param> /// <param name="minor">The minor version of the new GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param> /// <remarks> /// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored. /// </remarks> public GraphicsContext(GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) { lock (SyncRoot) { bool designMode = false; if (mode == null && window == null) designMode = true; else if (mode == null) throw new ArgumentNullException("mode", "Must be a valid GraphicsMode."); else if (window == null) throw new ArgumentNullException("window", "Must point to a valid window."); // Silently ignore invalid major and minor versions. if (major <= 0) major = 1; if (minor < 0) minor = 0; Debug.Print("Creating GraphicsContext."); try { Debug.Indent(); Debug.Print("GraphicsMode: {0}", mode); Debug.Print("IWindowInfo: {0}", window); Debug.Print("GraphicsContextFlags: {0}", flags); Debug.Print("Requested version: {0}.{1}", major, minor); IGraphicsContext shareContext = FindSharedContext(); // Todo: Add a DummyFactory implementing IPlatformFactory. if (designMode) { #if !IPHONE implementation = new Platform.Dummy.DummyGLContext(); #else implementation = Factory.Embedded.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); GetCurrentContext = Factory.Embedded.CreateGetCurrentGraphicsContext(); #endif } else { #if !IPHONE IPlatformFactory factory = null; #else Factory factory = null; GetCurrentContext = null; #endif switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: factory = Factory.Default; break; case true: factory = Factory.Embedded; break; } implementation = factory.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); // Note: this approach does not allow us to mix native and EGL contexts in the same process. // This should not be a problem, as this use-case is not interesting for regular applications. // Note 2: some platforms may not support a direct way of getting the current context // (this happens e.g. with DummyGLContext). In that case, we use a slow fallback which // iterates through all known contexts and checks if any is current (check GetCurrentContext // declaration). if (GetCurrentContext == null) { GetCurrentContextDelegate temp = factory.CreateGetCurrentGraphicsContext(); if (temp != null) { GetCurrentContext = temp; } } } available_contexts.Add((this as IGraphicsContextInternal).Context, new WeakReference(this)); } finally { Debug.Unindent(); } } }
public virtual IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return new X11GLContext(handle, window, shareContext, directRendering, major, minor, flags); }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return(new WinGLContext(handle, (WinWindowInfo)window, shareContext, major, minor, flags)); }
protected override BasicGameForm CreateGameForm(GraphicsContextFlags flags) { return(new WindowsGameForm(flags)); }
public WindowsGameWindow(GraphicsContextFlags flags) : base(flags) { }
protected abstract BasicGameForm CreateGameForm(GraphicsContextFlags flags);
public CustomApplicationWindow(AutoResetEvent updateEvent, int width, int height, GraphicsMode mode, string title, GameWindowFlags options, DisplayDevice device, int major, int minor, GraphicsContextFlags flags, IGraphicsContext sharedContext) : base(width, height, mode, title, options, device, major, minor, flags, sharedContext) { this.updateEvent = updateEvent; }
public virtual IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return(new X11GLContext(handle, window, shareContext, directRendering, major, minor, flags)); }
public X11GLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shared, bool direct, int major, int minor, GraphicsContextFlags flags) { if (mode == null) { throw new ArgumentNullException("mode"); } if (window == null) { throw new ArgumentNullException("window"); } // Do not move this lower, as almost everything requires the Display // property to be correctly set. Display = ((X11WindowInfo)window).Display; // Check that GLX is supported. We cannot proceed to create // an OpenGL context without the GLX extension. int error_base; int event_base; int glx_major; int glx_minor; using (new XLock(Display)) { bool supported = Glx.QueryExtension(Display, out error_base, out event_base); supported &= Glx.QueryVersion(Display, out glx_major, out glx_minor); if (supported) { Debug.Print("[X11] GLX supported. Version is {0}.{1}", glx_major, glx_minor); } else { throw new NotSupportedException("[X11] GLX extension is not supported."); } } IntPtr visual = IntPtr.Zero; IntPtr fbconfig = IntPtr.Zero; // Once a window has a visual, we cannot use a different // visual on the OpenGL context, or glXMakeCurrent might fail. // Note: we should only check X11WindowInfo.Visual, as that // is the only property that can be set by Utilities.CreateX11WindowInfo. currentWindow = (X11WindowInfo)window; if (currentWindow.Visual != IntPtr.Zero) { visual = currentWindow.Visual; fbconfig = currentWindow.FBConfig; Mode = currentWindow.GraphicsMode; } if (Mode == null || !Mode.Index.HasValue) { Mode = ModeSelector.SelectGraphicsMode(mode, out visual, out fbconfig); } ContextHandle shareHandle = shared != null ? (shared as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; Debug.Write("Creating X11GLContext context: "); Debug.Write(direct ? "direct, " : "indirect, "); Debug.WriteLine(shareHandle.Handle == IntPtr.Zero ? "not shared... " : String.Format("shared with ({0})... ", shareHandle)); // Try using the new context creation method. If it fails, fall back to the old one. // For each of these methods, we try two times to create a context: // one with the "direct" flag intact, the other with the flag inversed. // HACK: It seems that Catalyst 9.1 - 9.4 on Linux have problems with contexts created through // GLX_ARB_create_context, including hideous input lag, no vsync and other madness. // Use legacy context creation if the user doesn't request a 3.0+ context. if (fbconfig != IntPtr.Zero && (major * 10 + minor >= 30) && SupportsCreateContextAttribs(Display, currentWindow)) { Handle = CreateContextAttribs(Display, currentWindow.Screen, fbconfig, direct, major, minor, flags, shareHandle); } if (Handle == ContextHandle.Zero) { Handle = CreateContextLegacy(Display, visual, direct, shareHandle); } if (Handle != ContextHandle.Zero) { Debug.Print("Context created (id: {0}).", Handle); } else { throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0."); } using (new XLock(Display)) { if (!Glx.IsDirect(Display, Handle.Handle)) { Debug.Print("Warning: Context is not direct."); } } }
/// <summary> /// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the specified window. A dummy context will be created if both /// the handle and the window are null. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param> /// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param> /// <param name="shareContext">The GraphicsContext to share resources with, or null for explicit non-sharing.</param> /// <param name="major">The major version of the new GraphicsContext.</param> /// <param name="minor">The minor version of the new GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param> /// <remarks> /// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored. /// </remarks> public GraphicsContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags) { lock (SyncRoot) { bool designMode = false; if (mode == null && window == null) { designMode = true; } else if (mode == null) { throw new ArgumentNullException("mode", "Must be a valid GraphicsMode."); } else if (window == null) { throw new ArgumentNullException("window", "Must point to a valid window."); } // Silently ignore invalid major and minor versions. if (major <= 0) { major = 1; } if (minor < 0) { minor = 0; } // Angle needs an embedded context const GraphicsContextFlags useAngleFlag = GraphicsContextFlags.Angle | GraphicsContextFlags.AngleD3D9 | GraphicsContextFlags.AngleD3D11 | GraphicsContextFlags.AngleOpenGL; var useAngle = false; if ((flags & useAngleFlag) != 0) { flags |= GraphicsContextFlags.Embedded; useAngle = true; } Debug.Print("Creating GraphicsContext."); try { Debug.Indent(); Debug.Print("GraphicsMode: {0}", mode); Debug.Print("IWindowInfo: {0}", window); Debug.Print("GraphicsContextFlags: {0}", flags); Debug.Print("Requested version: {0}.{1}", major, minor); // Todo: Add a DummyFactory implementing IPlatformFactory. if (designMode) { implementation = new Platform.Dummy.DummyGLContext(); } else { IPlatformFactory factory = null; switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: factory = Factory.Default; break; case true: factory = useAngle ? Factory.Angle : Factory.Embedded; break; } // Note: this approach does not allow us to mix native and EGL contexts in the same process. // This should not be a problem, as this use-case is not interesting for regular applications. // Note 2: some platforms may not support a direct way of getting the current context // (this happens e.g. with DummyGLContext). In that case, we use a slow fallback which // iterates through all known contexts and checks if any is current (check GetCurrentContext // declaration). if (GetCurrentContext == null) { GetCurrentContext = factory.CreateGetCurrentGraphicsContext(); } implementation = factory.CreateGLContext(mode, window, shareContext, DirectRendering, major, minor, flags); handle_cached = ((IGraphicsContextInternal)implementation).Context; factory.RegisterResource(this); } AddContext(this); } finally { Debug.Unindent(); } } }
public SimpleES20Window(GraphicsContextFlags flags) : base(800, 600, GraphicsMode.Default, "", GameWindowFlags.Default, DisplayDevice.Default, 2, 0, flags) { }
/// <summary> /// Constructs a new GraphicsContext from a pre-existing context created outside of OpenTK. /// </summary> /// <param name="handle">The handle of the existing context. This must be a valid, unique handle that is not known to OpenTK.</param> /// <param name="window">This parameter is reserved.</param> /// <param name="shareContext">This parameter is reserved.</param> /// <param name="major">This parameter is reserved.</param> /// <param name="minor">This parameter is reserved.</param> /// <param name="flags">This parameter is reserved..</param> public GraphicsContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags) : this(handle, Platform.Utilities.CreateGetAddress(), Factory.Default.CreateGetCurrentGraphicsContext()) { }
public IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return(Default.CreateGLContext(mode, window, shareContext, directRendering, major, minor, flags)); }
public GLSurface(GraphicsMode mode, int major, int minor, GraphicsContextFlags flags) { Handler.CreateWithParams(mode, major, minor, flags); Initialize(); }
public NxTransparentGameWindow(int width, int height, GraphicsMode mode, string title, GameWindowFlags options, DisplayDevice device, int major, int minor, GraphicsContextFlags flags) : base(width, height, mode, title, options, device, major, minor, flags) { init(); }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { throw new NotImplementedException(); }
static void SetGLAttributes(GraphicsMode mode, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags) { ContextProfileFlags cpflags = 0; ClearGLAttributes(); if (mode.AccumulatorFormat.BitsPerPixel > 0) { SDL.GL.SetAttribute(ContextAttribute.ACCUM_ALPHA_SIZE, mode.AccumulatorFormat.Alpha); SDL.GL.SetAttribute(ContextAttribute.ACCUM_RED_SIZE, mode.AccumulatorFormat.Red); SDL.GL.SetAttribute(ContextAttribute.ACCUM_GREEN_SIZE, mode.AccumulatorFormat.Green); SDL.GL.SetAttribute(ContextAttribute.ACCUM_BLUE_SIZE, mode.AccumulatorFormat.Blue); } if (mode.Buffers > 0) { SDL.GL.SetAttribute(ContextAttribute.DOUBLEBUFFER, mode.Buffers > 1 ? 1 : 0); } if (mode.ColorFormat > 0) { SDL.GL.SetAttribute(ContextAttribute.ALPHA_SIZE, mode.ColorFormat.Alpha); SDL.GL.SetAttribute(ContextAttribute.RED_SIZE, mode.ColorFormat.Red); SDL.GL.SetAttribute(ContextAttribute.GREEN_SIZE, mode.ColorFormat.Green); SDL.GL.SetAttribute(ContextAttribute.BLUE_SIZE, mode.ColorFormat.Blue); } if (mode.Depth > 0) { SDL.GL.SetAttribute(ContextAttribute.DEPTH_SIZE, mode.Depth); } if (mode.Samples > 0) { SDL.GL.SetAttribute(ContextAttribute.MULTISAMPLEBUFFERS, 1); SDL.GL.SetAttribute(ContextAttribute.MULTISAMPLESAMPLES, mode.Samples); } if (mode.Stencil > 0) { SDL.GL.SetAttribute(ContextAttribute.STENCIL_SIZE, mode.Stereo ? 1 : 0); } if (mode.Stereo) { SDL.GL.SetAttribute(ContextAttribute.STEREO, 1); } if (major > 0) { // Workaround for https://github.com/opentk/opentk/issues/44 // Mac OS X desktop OpenGL 3.x/4.x contexts require require // ContextProfileFlags.Core, otherwise they will fail to construct. if (Configuration.RunningOnMacOS && major >= 3 && (flags & GraphicsContextFlags.Embedded) == 0) { cpflags |= ContextProfileFlags.CORE; // According to https://developer.apple.com/graphicsimaging/opengl/capabilities/GLInfo_1075_Core.html // Mac OS X supports 3.2+. Indeed, requesting 3.0 or 3.1 results in failure. if (major == 3 && minor < 2) { minor = 2; } } SDL.GL.SetAttribute(ContextAttribute.CONTEXT_MAJOR_VERSION, major); SDL.GL.SetAttribute(ContextAttribute.CONTEXT_MINOR_VERSION, minor); } if ((flags & GraphicsContextFlags.Debug) != 0) { SDL.GL.SetAttribute(ContextAttribute.CONTEXT_FLAGS, ContextFlags.DEBUG); } /* * if ((flags & GraphicsContextFlags.Robust) != 0) * { * SDL.GL.SetAttribute(ContextAttribute.CONTEXT_FLAGS, ContextFlags.ROBUST_ACCESS_FLAG); * } * * if ((flags & GraphicsContextFlags.ResetIsolation) != 0) * { * SDL.GL.SetAttribute(ContextAttribute.CONTEXT_FLAGS, ContextFlags.RESET_ISOLATION_FLAG); * } */ { if ((flags & GraphicsContextFlags.Embedded) != 0) { cpflags |= ContextProfileFlags.ES; SDL.GL.SetAttribute(ContextAttribute.CONTEXT_EGL, 1); } if ((flags & GraphicsContextFlags.ForwardCompatible) != 0) { cpflags |= ContextProfileFlags.CORE; } if (cpflags != 0) { SDL.GL.SetAttribute(ContextAttribute.CONTEXT_PROFILE_MASK, cpflags); } } if (shareContext != null) { if (shareContext.IsCurrent) { SDL.GL.SetAttribute(ContextAttribute.SHARE_WITH_CURRENT_CONTEXT, 1); } else { Trace.WriteLine("Warning: SDL2 requires a shared context to be current before sharing. Sharing failed."); } } }
public override IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return(new Sdl2GraphicsContext(mode, window, shareContext, major, minor, flags)); }
/// <summary>Constructs a new GLWidget</summary> public GLWidget(GraphicsMode graphicsMode, int glVersionMajor, int glVersionMinor, GraphicsContextFlags graphicsContextFlags) { this.DoubleBuffered = false; SingleBuffer = graphicsMode.Buffers == 1; ColorBPP = graphicsMode.ColorFormat.BitsPerPixel; AccumulatorBPP = graphicsMode.AccumulatorFormat.BitsPerPixel; DepthBPP = graphicsMode.Depth; StencilBPP = graphicsMode.Stencil; Samples = graphicsMode.Samples; Stereo = graphicsMode.Stereo; GlVersionMajor = glVersionMajor; GlVersionMinor = glVersionMinor; GraphicsContextFlags = graphicsContextFlags; }
public void CreateWithParams(GraphicsMode mode, int major, int minor, GraphicsContextFlags flags) { Control = new OtkWpfWFControl(mode, major, minor, flags); }
/// <summary>Constructs a new GameWindow with the specified attributes.</summary> /// <param name="width">The width of the GameWindow in pixels.</param> /// <param name="height">The height of the GameWindow in pixels.</param> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GameWindow.</param> /// <param name="title">The title of the GameWindow.</param> /// <param name="options">GameWindow options regarding window appearance and behavior.</param> /// <param name="device">The OpenTK.Graphics.DisplayDevice to construct the GameWindow in.</param> /// <param name="major">The major version for the OpenGL GraphicsContext.</param> /// <param name="minor">The minor version for the OpenGL GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags version for the OpenGL GraphicsContext.</param> /// <param name="sharedContext">An IGraphicsContext to share resources with.</param> public GameWindow(int width, int height, GraphicsMode mode, string title, GameWindowFlags options, DisplayDevice device, int major, int minor, GraphicsContextFlags flags, IGraphicsContext sharedContext) : base(width, height, title, options, mode == null ? GraphicsMode.Default : mode, device == null ? DisplayDevice.Default : device) { try { glContext = new GraphicsContext(mode == null ? GraphicsMode.Default : mode, WindowInfo, major, minor, flags); glContext.MakeCurrent(WindowInfo); (glContext as IGraphicsContextInternal).LoadAll(); VSync = VSyncMode.On; //glWindow.WindowInfoChanged += delegate(object sender, EventArgs e) { OnWindowInfoChangedInternal(e); }; } catch (Exception e) { Debug.Print(e.ToString()); base.Dispose(); throw; } }
public override IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { WinWindowInfo win_win = (WinWindowInfo)window; EGLDisplay egl_display = Egl.GetDisplay(EGLNativeDisplayType.Default); // Egl.GetDisplay(new EGLNativeDisplayType(win_win.DeviceContext)); EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(win_win.WindowHandle, egl_display); return(new EglContext(mode, egl_win, shareContext, major, minor, flags)); }
/// <summary> /// Constructs a new GraphicsContext from a pre-existing context created outside of OpenTK. /// </summary> /// <param name="handle">The handle of the existing context. This must be a valid, unique handle that is not known to OpenTK.</param> /// <param name="window">The window this context is bound to. This must be a valid window obtained through Utilities.CreateWindowInfo.</param> /// <param name="shareContext">A different context that shares resources with this instance, if any. /// Pass null if the context is not shared or if this is the first GraphicsContext instruct you construct.</param> /// <param name="major">The major version of the context (e.g. "2" for "2.1").</param> /// <param name="minor">The minor version of the context (e.g. "1" for "2.1").</param> /// <param name="flags">A bitwise combination of <see cref="GraphicsContextFlags"/> that describe this context.</param> /// <exception cref="GraphicsContextException">Occurs if handle is identical to a context already registered with OpenTK.</exception> public GraphicsContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags) { lock (SyncRoot) { IsExternal = true; if (handle == ContextHandle.Zero) { #if !IPHONE implementation = new OpenTK.Platform.Dummy.DummyGLContext(handle); #else implementation = new OpenTK.Platform.iPhoneOS.iPhoneOSGraphicsContext(handle); #endif } else if (available_contexts.ContainsKey(handle)) { throw new GraphicsContextException("Context already exists."); } else { switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: implementation = Factory.Default.CreateGLContext(handle, window, shareContext, direct_rendering, major, minor, flags); break; case true: implementation = Factory.Embedded.CreateGLContext(handle, window, shareContext, direct_rendering, major, minor, flags); break; } } available_contexts.Add((implementation as IGraphicsContextInternal).Context, new WeakReference(this)); (this as IGraphicsContextInternal).LoadAll(); } }
public LinuxGameWindow(GraphicsContextFlags flags) : base(flags) { }
public WinGLContext(GraphicsMode format, WinWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { // There are many ways this code can break when accessed by multiple threads. The biggest offender is // the sharedContext stuff, which will only become valid *after* this constructor returns. // The easiest solution is to serialize all context construction - hence the big lock, below. lock (SyncRoot) { if (window == null) throw new ArgumentNullException("window", "Must point to a valid window."); if (window.WindowHandle == IntPtr.Zero) throw new ArgumentException("window", "Must be a valid window."); Mode = format; Debug.Print("OpenGL will be bound to window:{0} on thread:{1}", window.WindowHandle, System.Threading.Thread.CurrentThread.ManagedThreadId); this.SetGraphicsModePFD(format, (WinWindowInfo)window); lock (LoadLock) { if (!wgl_loaded) { // 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."); ContextHandle temp_context = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext)); Wgl.Imports.MakeCurrent(window.DeviceContext, temp_context.Handle); Wgl.LoadAll(); Wgl.Imports.MakeCurrent(IntPtr.Zero, IntPtr.Zero); Wgl.Imports.DeleteContext(temp_context.Handle); wgl_loaded = true; } if (Wgl.Delegates.wglCreateContextAttribsARB != null) { try { Debug.Write("Using WGL_ARB_create_context... "); List<int> attributes = new List<int>(); attributes.Add((int)ArbCreateContext.MajorVersion); attributes.Add(major); attributes.Add((int)ArbCreateContext.MinorVersion); attributes.Add(minor); if (flags != 0) { attributes.Add((int)ArbCreateContext.Flags); #warning "This is not entirely correct: Embedded is not a valid flag! We need to add a GetARBContextFlags(GraphicsContextFlags) method." attributes.Add((int)flags); } // According to the docs, " <attribList> specifies a list of attributes for the context. // The list consists of a sequence of <name,value> pairs terminated by the // value 0. [...]" // Is this a single 0, or a <0, 0> pair? (Defensive coding: add two zeroes just in case). attributes.Add(0); attributes.Add(0); Handle = new ContextHandle( Wgl.Arb.CreateContextAttribs( window.DeviceContext, sharedContext != null ? (sharedContext as IGraphicsContextInternal).Context.Handle : IntPtr.Zero, attributes.ToArray())); if (Handle == ContextHandle.Zero) Debug.Print("failed. (Error: {0})", Marshal.GetLastWin32Error()); } catch (EntryPointNotFoundException e) { Debug.Print(e.ToString()); } catch (NullReferenceException e) { Debug.Print(e.ToString()); } } } if (Handle == ContextHandle.Zero) { // Failed to create GL3-level context, fall back to GL2. Debug.Write("Falling back to GL2... "); Handle = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext)); if (Handle == ContextHandle.Zero) Handle = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext)); if (Handle == ContextHandle.Zero) throw new GraphicsContextException( String.Format("Context creation failed. Wgl.CreateContext() error: {0}.", Marshal.GetLastWin32Error())); } Debug.WriteLine(String.Format("success! (id: {0})", Handle)); if (sharedContext != null) { Marshal.GetLastWin32Error(); Debug.Write(String.Format("Sharing state with context {0}: ", sharedContext)); bool result = Wgl.Imports.ShareLists((sharedContext as IGraphicsContextInternal).Context.Handle, Handle.Handle); Debug.WriteLine(result ? "success!" : "failed with win32 error " + Marshal.GetLastWin32Error()); } } }
public InternalWindow(NativeWindow parent, int w, int h, GraphicsMode mode, string title, GameWindowFlags flags, GraphicsContextFlags contextFlags) : base(w, h, mode, title, flags, DisplayDevice.Default, 2, 0, contextFlags) { this.parent = parent; }
public IGraphicsContext CreateContext(int major, int minor, GraphicsContextFlags flags) { return new GraphicsContext(null, null); }
public X11GLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shared, bool direct, int major, int minor, GraphicsContextFlags flags) { if (mode == null) { throw new ArgumentNullException("mode"); } if (window == null) { throw new ArgumentNullException("window"); } Mode = ModeSelector.SelectGraphicsMode( mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo); // Do not move this lower, as almost everything requires the Display // property to be correctly set. Display = ((X11WindowInfo)window).Display; currentWindow = (X11WindowInfo)window; currentWindow.VisualInfo = SelectVisual(Mode, currentWindow); ContextHandle shareHandle = shared != null ? (shared as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; Debug.Write("Creating X11GLContext context: "); Debug.Write(direct ? "direct, " : "indirect, "); Debug.WriteLine(shareHandle.Handle == IntPtr.Zero ? "not shared... " : String.Format("shared with ({0})... ", shareHandle)); // Try using the new context creation method. If it fails, fall back to the old one. // For each of these methods, we try two times to create a context: // one with the "direct" flag intact, the other with the flag inversed. // HACK: It seems that Catalyst 9.1 - 9.4 on Linux have problems with contexts created through // GLX_ARB_create_context, including hideous input lag, no vsync and other madness. // Use legacy context creation if the user doesn't request a 3.0+ context. if ((major * 10 + minor >= 30) && SupportsCreateContextAttribs(Display, currentWindow)) { Debug.Write("Using GLX_ARB_create_context... "); unsafe { // We need the FB config for the current GraphicsMode. int count; IntPtr *fbconfigs = Glx.ChooseFBConfig(Display, currentWindow.Screen, new int[] { (int)GLXAttribute.VISUAL_ID, (int)Mode.Index, 0 }, out count); if (count > 0) { List <int> attributes = new List <int>(); attributes.Add((int)ArbCreateContext.MajorVersion); attributes.Add(major); attributes.Add((int)ArbCreateContext.MinorVersion); attributes.Add(minor); if (flags != 0) { attributes.Add((int)ArbCreateContext.Flags); attributes.Add((int)GetARBContextFlags(flags)); attributes.Add((int)ArbCreateContext.ProfileMask); attributes.Add((int)GetARBProfileFlags(flags)); } // According to the docs, " <attribList> specifies a list of attributes for the context. // The list consists of a sequence of <name,value> pairs terminated by the // value 0. [...]" // Is this a single 0, or a <0, 0> pair? (Defensive coding: add two zeroes just in case). attributes.Add(0); attributes.Add(0); using (new XLock(Display)) { Handle = new ContextHandle(Glx.Arb.CreateContextAttribs(Display, *fbconfigs, shareHandle.Handle, direct, attributes.ToArray())); if (Handle == ContextHandle.Zero) { Debug.Write(String.Format("failed. Trying direct: {0}... ", !direct)); Handle = new ContextHandle(Glx.Arb.CreateContextAttribs(Display, *fbconfigs, shareHandle.Handle, !direct, attributes.ToArray())); } } if (Handle == ContextHandle.Zero) { Debug.WriteLine("failed."); } else { Debug.WriteLine("success!"); } using (new XLock(Display)) { Functions.XFree((IntPtr)fbconfigs); } } } } if (Handle == ContextHandle.Zero) { Debug.Write("Using legacy context creation... "); XVisualInfo info = currentWindow.VisualInfo; using (new XLock(Display)) { // Cannot pass a Property by reference. Handle = new ContextHandle(Glx.CreateContext(Display, ref info, shareHandle.Handle, direct)); if (Handle == ContextHandle.Zero) { Debug.WriteLine(String.Format("failed. Trying direct: {0}... ", !direct)); Handle = new ContextHandle(Glx.CreateContext(Display, ref info, IntPtr.Zero, !direct)); } } } if (Handle != ContextHandle.Zero) { Debug.Print("Context created (id: {0}).", Handle); } else { throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0."); } using (new XLock(Display)) { if (!Glx.IsDirect(Display, Handle.Handle)) { Debug.Print("Warning: Context is not direct."); } } }