Example #1
0
        public EGLSurface CreateSurface(int width, int height)
        {
            IntPtr surface;

            EglWindowInfo.CreatePbufferSurface(
                EglContext.GraphicsMode.Index.Value,
                width, height,
                out surface);
            return(surface);
        }
Example #2
0
        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 = GetSharedEglContext(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)
            {
                switch (major)
                {
                case 3:
                    Renderable = RenderableFlags.ES3;
                    break;

                case 2:
                    Renderable = RenderableFlags.ES2;
                    break;

                default:
                    Renderable = RenderableFlags.ES;
                    break;
                }
            }

            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());
            }

            bool offscreen = (flags & GraphicsContextFlags.Offscreen) != 0;

            SurfaceType surface_type = offscreen
                ? SurfaceType.PBUFFER_BIT
                : SurfaceType.WINDOW_BIT;

            Mode = new EglGraphicsMode().SelectGraphicsMode(surface_type,
                                                            window.Display, mode.ColorFormat, mode.Depth, mode.Stencil,
                                                            mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo,
                                                            Renderable, (flags & GraphicsContextFlags.AngleFullscreen) > 0);

            if (!Mode.Index.HasValue)
            {
                throw new GraphicsModeException("Invalid or unsupported GraphicsMode.");
            }
            IntPtr config = Mode.Index.Value;

            if (window.Surface == IntPtr.Zero)
            {
                if (!offscreen)
                {
                    window.CreateWindowSurface(config);
                }
                else
                {
                    window.CreatePbufferSurface(config);
                }
            }

            int[] attrib_list   = new int[] { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE };
            var   share_context = shared != null ? shared.HandleAsEGLContext : IntPtr.Zero;

            try
            {
                HandleAsEGLContext = Egl.CreateContext(window.Display, config, share_context, attrib_list);

                GraphicsContextFlags = flags;
                MakeCurrent(window);
            }
            catch
            {
                window.DestroySurface();
                throw;
            }
        }