Beispiel #1
0
 private void DestroyContext()
 {
     if (Handle != ContextHandle.Zero)
     {
         try
         {
             // This will fail if the user calls Dispose() on thread X when the context is current on thread Y.
             if (!Wgl.DeleteContext(Handle.Handle))
             {
                 Debug.Print("Failed to destroy OpenGL context {0}. Error: {1}",
                             Handle.ToString(), Marshal.GetLastWin32Error());
             }
         }
         catch (AccessViolationException e)
         {
             Debug.WriteLine("An access violation occured while destroying the OpenGL context. Please report at https://github.com/opentk/opentk/issues");
             Debug.Indent();
             Debug.Print("Marshal.GetLastWin32Error(): {0}", Marshal.GetLastWin32Error().ToString());
             Debug.WriteLine(e.ToString());
             Debug.Unindent();
         }
         Handle = ContextHandle.Zero;
     }
 }
Beispiel #2
0
        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 (LoadLock)
            {
                if (window == null)
                {
                    throw new ArgumentNullException("window", "Must point to a valid window.");
                }
                if (window.Handle == IntPtr.Zero)
                {
                    throw new ArgumentException("window", "Must be a valid window.");
                }

                IntPtr           current_context = Wgl.GetCurrentContext();
                INativeWindow    temp_window     = null;
                TemporaryContext temp_context    = null;
                try
                {
                    if (current_context == IntPtr.Zero)
                    {
                        // Create temporary context to load WGL extensions
                        temp_window     = new NativeWindow();
                        temp_context    = new TemporaryContext(temp_window);
                        current_context = Wgl.GetCurrentContext();
                        if (current_context != IntPtr.Zero && current_context == temp_context.Context.Handle)
                        {
                            new Wgl().LoadEntryPoints();
                        }
                    }

                    Debug.Print("OpenGL will be bound to window:{0} on thread:{1}", window.Handle,
                                System.Threading.Thread.CurrentThread.ManagedThreadId);

                    ModeSelector = new WinGraphicsMode(window.DeviceContext);
                    Mode         = SetGraphicsModePFD(ModeSelector, format, (WinWindowInfo)window);

                    if (Wgl.SupportsFunction("wglCreateContextAttribsARB"))
                    {
                        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.ContextFlags);
                                attributes.Add((int)GetARBContextFlags(flags));
                                attributes.Add((int)ArbCreateContext.ProfileMask);
                                attributes.Add((int)GetARBContextProfile(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 (Exception 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.CreateContext(window.DeviceContext));
                        if (Handle == ContextHandle.Zero)
                        {
                            Handle = new ContextHandle(Wgl.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));
                }
                finally
                {
                    if (temp_context != null)
                    {
                        temp_context.Dispose();
                        temp_context = null;
                    }
                    if (temp_window != null)
                    {
                        temp_window.Dispose();
                        temp_window = null;
                    }
                }
            }

            // Todo: is this comment still true?
            // On intel drivers, wgl entry points appear to change
            // when creating multiple contexts. As a workaround,
            // we reload Wgl entry points every time we create a
            // new context - this solves the issue without any apparent
            // side-effects (i.e. the old contexts can still be handled
            // using the new entry points.)
            // Sigh...
            MakeCurrent(window);
            new Wgl().LoadEntryPoints();

            if (sharedContext != null)
            {
                Marshal.GetLastWin32Error();
                Debug.Write(String.Format("Sharing state with context {0}: ", sharedContext));
                bool result = Wgl.ShareLists((sharedContext as IGraphicsContextInternal).Context.Handle, Handle.Handle);
                Debug.WriteLine(result ? "success!" : "failed with win32 error " + Marshal.GetLastWin32Error());
            }
        }
Beispiel #3
0
        // Queries pixel formats through the WGL_ARB_pixel_format extension
        // This method only returns accelerated formats. If no format offers
        // hardware acceleration (e.g. we are running in a VM or in a remote desktop
        // connection), this method will return 0 formats and we will fall back to
        // ChoosePixelFormatPFD.
        private GraphicsMode ChoosePixelFormatARB(IntPtr device, GraphicsMode desired_mode)
        {
            GraphicsMode created_mode = null;
            GraphicsMode mode         = new GraphicsMode(desired_mode);

            if (Wgl.SupportsExtension("WGL_ARB_pixel_format") &&
                Wgl.SupportsFunction("wglChoosePixelFormatARB"))
            {
                int[]      format = new int[1];
                int        count;
                List <int> attributes = new List <int>();
                bool       retry      = false;

                do
                {
                    attributes.Clear();
                    attributes.Add((int)WGL_ARB_pixel_format.AccelerationArb);
                    attributes.Add((int)WGL_ARB_pixel_format.FullAccelerationArb);
                    attributes.Add((int)WGL_ARB_pixel_format.DrawToWindowArb);
                    attributes.Add(1);

                    if (mode.ColorFormat.Red > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.RedBitsArb);
                        attributes.Add(mode.ColorFormat.Red);
                    }

                    if (mode.ColorFormat.Green > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.GreenBitsArb);
                        attributes.Add(mode.ColorFormat.Green);
                    }

                    if (mode.ColorFormat.Blue > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.BlueBitsArb);
                        attributes.Add(mode.ColorFormat.Blue);
                    }

                    if (mode.ColorFormat.Alpha > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.AlphaBitsArb);
                        attributes.Add(mode.ColorFormat.Alpha);
                    }

                    if (mode.Depth > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.DepthBitsArb);
                        attributes.Add(mode.Depth);
                    }

                    if (mode.Stencil > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.StencilBitsArb);
                        attributes.Add(mode.Stencil);
                    }

                    if (mode.AccumulatorFormat.Red > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.AccumRedBitsArb);
                        attributes.Add(mode.AccumulatorFormat.Red);
                    }

                    if (mode.AccumulatorFormat.Green > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.AccumGreenBitsArb);
                        attributes.Add(mode.AccumulatorFormat.Green);
                    }

                    if (mode.AccumulatorFormat.Blue > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.AccumBlueBitsArb);
                        attributes.Add(mode.AccumulatorFormat.Blue);
                    }

                    if (mode.AccumulatorFormat.Alpha > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.AccumAlphaBitsArb);
                        attributes.Add(mode.AccumulatorFormat.Alpha);
                    }

                    if (mode.Samples > 0 &&
                        Wgl.SupportsExtension("WGL_ARB_multisample"))
                    {
                        attributes.Add((int)WGL_ARB_multisample.SampleBuffersArb);
                        attributes.Add(1);
                        attributes.Add((int)WGL_ARB_multisample.SamplesArb);
                        attributes.Add(mode.Samples);
                    }

                    if (mode.Buffers > 0)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.DoubleBufferArb);
                        attributes.Add(mode.Buffers > 1 ? 1 : 0);
                    }

                    if (mode.Stereo)
                    {
                        attributes.Add((int)WGL_ARB_pixel_format.StereoArb);
                        attributes.Add(1);
                    }

                    attributes.Add(0);
                    attributes.Add(0);

                    if (Wgl.Arb.ChoosePixelFormat(device, attributes.ToArray(), null, format.Length, format, out count) &&
                        count > 0)
                    {
                        created_mode = DescribePixelFormatARB(device, format[0]);
                        retry        = false;
                    }
                    else
                    {
                        Debug.Print("[WGL] ChoosePixelFormatARB failed with {0}", Marshal.GetLastWin32Error());
                        retry = Utilities.RelaxGraphicsMode(ref mode);
                    }
                }while (retry);
            }
            else
            {
                Debug.WriteLine("[WGL] ChoosePixelFormatARB not supported on this context");
            }

            return(created_mode);
        }
Beispiel #4
0
 public static bool SupportsExtension(string name)
 {
     return(SupportsExtension(Wgl.GetCurrentDC(), name));
 }
Beispiel #5
0
        private GraphicsMode DescribePixelFormatARB(IntPtr device, int pixelformat)
        {
            GraphicsMode created_mode = null;

            // See http://www.opengl.org/registry/specs/ARB/wgl_pixel_format.txt for more details
            if (Wgl.SupportsFunction("wglGetPixelFormatAttribivARB"))
            {
                // Define the list of attributes we are interested in.
                // The results will be stored in the 'values' array below.
                int[] attribs = new int[]
                {
                    (int)WGL_ARB_pixel_format.AccelerationArb,

                    (int)WGL_ARB_pixel_format.RedBitsArb,
                    (int)WGL_ARB_pixel_format.GreenBitsArb,
                    (int)WGL_ARB_pixel_format.BlueBitsArb,
                    (int)WGL_ARB_pixel_format.AlphaBitsArb,
                    (int)WGL_ARB_pixel_format.ColorBitsArb,

                    (int)WGL_ARB_pixel_format.DepthBitsArb,
                    (int)WGL_ARB_pixel_format.StencilBitsArb,

                    (int)WGL_ARB_multisample.SampleBuffersArb,
                    (int)WGL_ARB_multisample.SamplesArb,

                    (int)WGL_ARB_pixel_format.AccumRedBitsArb,
                    (int)WGL_ARB_pixel_format.AccumGreenBitsArb,
                    (int)WGL_ARB_pixel_format.AccumBlueBitsArb,
                    (int)WGL_ARB_pixel_format.AccumAlphaBitsArb,
                    (int)WGL_ARB_pixel_format.AccumBitsArb,

                    (int)WGL_ARB_pixel_format.DoubleBufferArb,
                    (int)WGL_ARB_pixel_format.StereoArb,
                    0
                };

                // Allocate storage for the results of GetPixelFormatAttrib queries
                int[] values = new int[attribs.Length];

                // Get the format attributes for this pixel format
                if (!Wgl.Arb.GetPixelFormatAttrib(device, pixelformat, 0, attribs.Length - 1, attribs, values))
                {
                    Debug.Print("[Warning] Failed to detect attributes for PixelFormat: {0}.", pixelformat);
                }

                // Skip formats that don't offer full hardware acceleration
                WGL_ARB_pixel_format acceleration = (WGL_ARB_pixel_format)values[0];
                if (acceleration == WGL_ARB_pixel_format.FullAccelerationArb)
                {
                    // Construct a new GraphicsMode to describe this format
                    created_mode = new GraphicsMode(new IntPtr(pixelformat),
                                                    new ColorFormat(values[1], values[2], values[3], values[4]),
                                                    values[6],
                                                    values[7],
                                                    values[8] != 0 ? values[9] : 0,
                                                    new ColorFormat(values[10], values[11], values[12], values[13]),
                                                    values[15] == 1 ? 2 : 1,
                                                    values[16] == 1 ? true : false);
                }
            }
            return(created_mode);
        }