public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, int samples, ColorFormat accum, int buffers, bool stereo, RenderableFlags renderable_flags) { IntPtr[] configs = new IntPtr[1]; int[] attribList = new int[] { //Egl.SURFACE_TYPE, Egl.WINDOW_BIT, Egl.RENDERABLE_TYPE, (int)renderable_flags, Egl.RED_SIZE, color.Red, Egl.GREEN_SIZE, color.Green, Egl.BLUE_SIZE, color.Blue, Egl.ALPHA_SIZE, color.Alpha, Egl.DEPTH_SIZE, depth > 0 ? depth : 0, Egl.STENCIL_SIZE, stencil > 0 ? stencil : 0, Egl.SAMPLE_BUFFERS, samples > 0 ? 1 : 0, Egl.SAMPLES, samples > 0 ? samples : 0, Egl.NONE, }; // Todo: what if we don't wish to use the default display? IntPtr display = Egl.GetDisplay(IntPtr.Zero); int major, minor; if (!Egl.Initialize(display, out major, out minor)) { throw new GraphicsModeException(String.Format("Failed to initialize display connection, error {0}", Egl.GetError())); } int num_configs; if (!Egl.ChooseConfig(display, attribList, configs, configs.Length, out num_configs) || num_configs == 0) { throw new GraphicsModeException(String.Format("Failed to retrieve GraphicsMode, error {0}", Egl.GetError())); } // See what we really got IntPtr active_config = configs[0]; int r, g, b, a; Egl.GetConfigAttrib(display, active_config, Egl.RED_SIZE, out r); Egl.GetConfigAttrib(display, active_config, Egl.GREEN_SIZE, out g); Egl.GetConfigAttrib(display, active_config, Egl.BLUE_SIZE, out b); Egl.GetConfigAttrib(display, active_config, Egl.ALPHA_SIZE, out a); int d, s; Egl.GetConfigAttrib(display, active_config, Egl.DEPTH_SIZE, out d); Egl.GetConfigAttrib(display, active_config, Egl.STENCIL_SIZE, out s); int sample_buffers; Egl.GetConfigAttrib(display, active_config, Egl.SAMPLES, out sample_buffers); Egl.GetConfigAttrib(display, active_config, Egl.SAMPLES, out samples); return(new GraphicsMode(active_config, new ColorFormat(r, g, b, a), d, s, sample_buffers > 0 ? samples : 0, 0, 2, false)); }
bool vsync = true; // Default vsync value is defined as 1 (true) in EGL. 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; //old version EglContext shared = sharedContext as EglContext; 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; Egl.BindAPI(0x30A0); //bind EGL_OPENGL_ES_API var eglGfxMode = new EglGraphicsMode(); eglGfxMode.window = window; Mode = eglGfxMode.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[] { //key,value Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE }; HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : IntPtr.Zero, attrib_list); MakeCurrent(window); }
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 EglWindowInfo(IntPtr handle, IntPtr display, IntPtr surface) { Handle = handle; Surface = surface; if (display == IntPtr.Zero) { display = Egl.GetDisplay(IntPtr.Zero); } Display = display; int dummyMajor, dummyMinor; if (!Egl.Initialize(Display, out dummyMajor, out dummyMinor)) { throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError())); } }
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."); } EGLConfig config = new EGLConfig(mode.Index.Value); if (window.Surface.Handle == EGLSurface.None.Handle) { 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 : EGLContext.None, attrib_list); MakeCurrent(window); }
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 GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, int samples, ColorFormat accum, int buffers, bool stereo, RenderableFlags renderable_flags) { IntPtr[] configs = new IntPtr[1]; int[] attrib_list = new int[17] { 12352, (int)renderable_flags, 12324, color.Red, 12323, color.Green, 12322, color.Blue, 12321, color.Alpha, 12325, depth > 0 ? depth : 0, 12326, stencil > 0 ? stencil : 0, 12337, samples > 0 ? samples : 0, 12344 }; IntPtr display = Egl.GetDisplay(IntPtr.Zero); int major; int minor; if (!Egl.Initialize(display, out major, out minor)) { throw new GraphicsModeException(string.Format("Failed to initialize display connection, error {0}", (object)Egl.GetError())); } int num_config; if (!Egl.ChooseConfig(display, attrib_list, configs, configs.Length, out num_config) || num_config == 0) { throw new GraphicsModeException(string.Format("Failed to retrieve GraphicsMode, error {0}", (object)Egl.GetError())); } IntPtr config = configs[0]; int red; Egl.GetConfigAttrib(display, config, 12324, out red); int green; Egl.GetConfigAttrib(display, config, 12323, out green); int blue; Egl.GetConfigAttrib(display, config, 12322, out blue); int alpha; Egl.GetConfigAttrib(display, config, 12321, out alpha); int depth1; Egl.GetConfigAttrib(display, config, 12325, out depth1); int stencil1; Egl.GetConfigAttrib(display, config, 12326, out stencil1); int num; Egl.GetConfigAttrib(display, config, 12337, out num); Egl.GetConfigAttrib(display, config, 12337, out samples); return(new GraphicsMode(new IntPtr?(config), new ColorFormat(red, green, blue, alpha), depth1, stencil1, num > 0 ? samples : 0, (ColorFormat)0, 2, false)); }
IntPtr TryInitEglDisplay(IWindowInfo window, ref int major, ref int minor, ref GraphicsContextFlags flags) { //see https://github.com/Microsoft/angle/wiki/Initializing-ANGLE-on-D3D11-Feature-Level-9 //IntPtr egl_display1 = Egl.GetPlatformDisplayEXT(Egl.PLATFORM_ANGLE_ANGLE, IntPtr.Zero, new int[]{ // Egl.PLATFORM_ANGLE_TYPE_ANGLE, // Egl.PLATFORM_ANGLE_TYPE_D3D11_ANGLE, // Egl.PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE, 9, // Egl.PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE, 3, // Egl.NONE, //}); //if (!Egl.Initialize(egl_display1, out int m1, out int m2)) //{ //} //1. use default openTK default WinWindowInfo win_win = (WinWindowInfo)window; bool success = false; int eglMajor, eglMinor; IntPtr egl_display = IntPtr.Zero; if (isFirstTimeEval) { isFirstTimeEval = false; egl_display = GetDisplay(win_win.DeviceContext); success = Egl.Initialize(egl_display, out eglMajor, out eglMinor); //------------------- //we found that some old machine can't init with D3D11 //so ... we use D3D9 instead if (!success) { egl_display = Egl.GetPlatformDisplayEXT(Egl.PLATFORM_ANGLE_ANGLE, IntPtr.Zero, new int[] { Egl.PLATFORM_ANGLE_TYPE_ANGLE, Egl.PLATFORM_ANGLE_TYPE_D3D9_ANGLE, Egl.NONE, }); if (Egl.Initialize(egl_display, out eglMajor, out eglMinor)) { useD3D9Only = true; success = true; //in this case major = 2; //GLES2 minor = 1; flags = flags & ~GraphicsContextFlags.AngleD3D11; //can't use D3D11 } else { throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError())); } } } else { //not first time if (useD3D9Only) { //no D3D11 egl_display = Egl.GetPlatformDisplayEXT(Egl.PLATFORM_ANGLE_ANGLE, IntPtr.Zero, new int[] { Egl.PLATFORM_ANGLE_TYPE_ANGLE, Egl.PLATFORM_ANGLE_TYPE_D3D9_ANGLE, Egl.NONE, }); if (Egl.Initialize(egl_display, out eglMajor, out eglMinor)) { useD3D9Only = true; success = true; //in this case major = 2; //GLES2 minor = 1; flags = flags & ~GraphicsContextFlags.AngleD3D11; //can't use D3D11 } else { throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError())); } } else { //use D3D11 egl_display = GetDisplay(win_win.DeviceContext); success = Egl.Initialize(egl_display, out eglMajor, out eglMinor); //------------------- //we found that some old machine can't init with D3D11 //so ... we use D3D9 instead if (!success) { //??? throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError())); } } } return(egl_display); }