/// <summary> /// Construct a NativeWindow on an OS window. /// </summary> /// <param name="display"> /// A <see cref="IntPtr"/> that specifies the display handle to be passed to <see cref="Egl.GetDisplay(IntPtr)"/>. /// </param> /// <param name="windowHandle"> /// A <see cref="IntPtr"/> that specifies the handle of the OS window. /// </param> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> used for choosing the NativeWindow pixel format configuration. It can /// be null; in this case the pixel format will be set elsewhere. /// </param> public NativeWindow(IntPtr display, IntPtr windowHandle, DevicePixelFormat pixelFormat) : base(display) { try { // Hold the window handle in case pixel format will be set later _WindowHandle = windowHandle; // Choose appropriate pixel format if (pixelFormat != null) { pixelFormat.RenderWindow = true; IntPtr configId = ChoosePixelFormat(_Display, _EglVersion, pixelFormat); List <int> attribs = new List <int>(); if (pixelFormat.DoubleBuffer) { attribs.AddRange(new[] { Egl.RENDER_BUFFER, Egl.BACK_BUFFER }); } attribs.Add(Egl.NONE); CreateHandle(configId, attribs.ToArray()); } } catch { Dispose(); throw; } }
/// <summary> /// Construct a NativePBuffer with a specific pixel format and size. /// </summary> /// <param name="display"> /// /// </param> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format and the ancillary buffers required. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specifies the width of the P-Buffer, in pixels. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specifies the height of the P-Buffer, in pixels. /// </param> public NativePBuffer(IntPtr display, DevicePixelFormat pixelFormat, uint width, uint height) : base(display) { if (pixelFormat == null) { throw new ArgumentNullException(nameof(pixelFormat)); } try { // Choose appropriate pixel format pixelFormat.RenderWindow = false; // XXX pixelFormat.RenderPBuffer = true; IntPtr configId = ChoosePixelFormat(_Display, _EglVersion, pixelFormat); List <int> attribs = new List <int>(); attribs.AddRange(new[] { Egl.WIDTH, (int)width }); attribs.AddRange(new[] { Egl.HEIGHT, (int)height }); attribs.Add(Egl.NONE); CreateHandle(configId, attribs.ToArray()); } catch { Dispose(); throw; } }
/// <summary> /// Create the device context and set the pixel format. /// </summary> private void CreateDeviceContext(DevicePixelFormat controlReqFormat) { #region Support ES API if (_ProfileType == ProfileType.Embedded) { DeviceContext.DefaultApi = KhronosVersion.ApiGles2; } #endregion #region Create device context _DeviceContext = DeviceContext.Create(GetDisplay(), this.Handle); _DeviceContext.IncRef(); #endregion #region Set pixel format DevicePixelFormatCollection pixelFormats = _DeviceContext.PixelsFormats; List <DevicePixelFormat> matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if ((matchingPixelFormats.Count == 0) && controlReqFormat.DoubleBuffer) { // Try single buffered pixel formats controlReqFormat.DoubleBuffer = false; matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException(String.Format("unable to find a suitable pixel format: {0}", pixelFormats.GuessChooseError(controlReqFormat))); } } else if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException(String.Format("unable to find a suitable pixel format: {0}", pixelFormats.GuessChooseError(controlReqFormat))); } _DeviceContext.SetPixelFormat(matchingPixelFormats[0]); #endregion #region Set V-Sync if (Gl.PlatformExtensions.SwapControl) { int swapInterval = SwapInterval; // Mask value in case it is not supported if (!Gl.PlatformExtensions.SwapControlTear && swapInterval == -1) { swapInterval = 1; } _DeviceContext.SwapInterval(swapInterval); } #endregion }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } if (_PixelFormatSet == true) { throw new InvalidOperationException("pixel format already set"); } Wgl.PIXELFORMATDESCRIPTOR pDescriptor = new Wgl.PIXELFORMATDESCRIPTOR(); bool res; // Note (from MSDN): Setting the pixel format of a window more than once can lead to significant complications for the Window Manager // and for multithread applications, so it is not allowed. An application can only set the pixel format of a window one time. Once a // window's pixel format is set, it cannot be changed. res = Wgl.DescribePixelFormat(DeviceContext, pixelFormat.FormatIndex, (uint)pDescriptor.nSize, ref pDescriptor); Debug.Assert(res); // Set choosen pixel format res = Wgl.SetPixelFormat(DeviceContext, pixelFormat.FormatIndex, ref pDescriptor); Debug.Assert(res); // Unable to set pixel format again _PixelFormatSet = true; }
/// <summary> /// Set pixel format by letting the driver choose the best pixel format following the criteria. /// </summary> /// <param name="pixelFormat"> /// /// </param> private void SetDisplayablePixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } List <int> attribIList = new List <int>(); List <float> attribFList = new List <float>(); Wgl.PIXELFORMATDESCRIPTOR pDescriptor = new Wgl.PIXELFORMATDESCRIPTOR(); uint[] countFormatAttribsValues = new uint[1]; int[] choosenFormats = new int[4]; // Let choose pixel formats if (!Wgl.ChoosePixelFormatARB(_DeviceContext, attribIList.ToArray(), attribFList.ToArray(), (uint)choosenFormats.Length, choosenFormats, countFormatAttribsValues)) { Win32Exception innerException = new Win32Exception(Marshal.GetLastWin32Error()); throw new InvalidOperationException(String.Format("unable to choose pixel format: {0}", innerException.Message), innerException); } // Set choosen pixel format if (Wgl.SetPixelFormat(_DeviceContext, choosenFormats[0], ref pDescriptor) == false) { Win32Exception innerException = new Win32Exception(Marshal.GetLastWin32Error()); throw new InvalidOperationException(String.Format("unable to set pixel format {0}: {1}", pixelFormat.FormatIndex, innerException.Message), innerException); } }
/// <summary> /// Create the device context and set the pixel format. /// </summary> protected void CreateDeviceContext() { // Create device context _DeviceContext = DeviceContextFactory.Create(this); _DeviceContext.IncRef(); // Set pixel format DevicePixelFormatCollection pixelFormats = _DeviceContext.PixelsFormats; DevicePixelFormat controlReqFormat = new DevicePixelFormat(); controlReqFormat.ColorBits = (int)ColorBits; controlReqFormat.DepthBits = (int)DepthBits; controlReqFormat.StencilBits = (int)StencilBits; controlReqFormat.MultisampleBits = (int)MultisampleBits; controlReqFormat.DoubleBuffer = DoubleBuffer; List <DevicePixelFormat> matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException("unable to find a suitable pixel format"); } _DeviceContext.SetPixelFormat(matchingPixelFormats[0]); }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } if (_PixelFormatSet == true) { throw new InvalidOperationException("pixel format already set"); } Wgl.PIXELFORMATDESCRIPTOR pDescriptor = new Wgl.PIXELFORMATDESCRIPTOR(); // Note (from MSDN): Setting the pixel format of a window more than once can lead to significant complications for the Window Manager // and for multithread applications, so it is not allowed. An application can only set the pixel format of a window one time. Once a // window's pixel format is set, it cannot be changed. if (Wgl.DescribePixelFormat(DeviceContext, pixelFormat.FormatIndex, (uint)pDescriptor.nSize, ref pDescriptor) == false) { Win32Exception innerException = new Win32Exception(Marshal.GetLastWin32Error()); throw new InvalidOperationException(String.Format("unable to describe pixel format, {0}", innerException.Message), innerException); } // Set choosen pixel format if (Wgl.SetPixelFormat(DeviceContext, pixelFormat.FormatIndex, ref pDescriptor) == false) { Win32Exception innerException = new Win32Exception(Marshal.GetLastWin32Error()); throw new InvalidOperationException(String.Format("unable to set pixel format, {0}", innerException.Message), innerException); } // Unable to set pixel format again _PixelFormatSet = true; }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } List <int> configAttribs = new List <int>(); if (Version >= Egl.Version_120) { configAttribs.AddRange(new int[] { Egl.RENDERABLE_TYPE, Egl.OPENGL_ES2_BIT }); } configAttribs.AddRange(new int[] { Egl.CONFIG_ID, pixelFormat.FormatIndex, }); configAttribs.Add(Egl.NONE); int[] configCount = new int[1]; IntPtr[] configs = new IntPtr[1]; if (Egl.ChooseConfig(_Display, configAttribs.ToArray(), configs, 1, configCount) == false) { throw new InvalidOperationException("unable to choose configuration"); } if (configCount[0] == 0) { throw new InvalidOperationException("no available configuration"); } IntPtr config = configs[0]; _Config = config; }
/// <summary> /// Construct a NativePBuffer with a specific pixel format and size. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format and the ancillary buffers required. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specifies the width of the P-Buffer, in pixels. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specifies the height of the P-Buffer, in pixels. /// </param> public NativePBuffer(DevicePixelFormat pixelFormat, uint width, uint height) { if (pixelFormat == null) throw new ArgumentNullException("pixelFormat"); if (!Wgl.CurrentExtensions.Pbuffer_ARB && !Wgl.CurrentExtensions.Pbuffer_EXT) throw new NotSupportedException("WGL_(ARB|EXT)_pbuffer not implemented"); if (Gl._NativeWindow == null) throw new InvalidOperationException("no underlying native window", Gl._InitializationException); try { // Uses screen device context _DeviceContext = Wgl.GetDC(Gl._NativeWindow.Handle); // Choose appropriate pixel format pixelFormat.RenderWindow = false; // XXX pixelFormat.RenderPBuffer = true; pixelFormat.DoubleBuffer = true; int pixelFormatIndex = ChoosePixelFormat(_DeviceContext, pixelFormat); if (Wgl.CurrentExtensions.Pbuffer_ARB) _Handle = Wgl.CreatePbufferARB(_DeviceContext, pixelFormatIndex, (int)width, (int)height, new int[] { 0 }); else _Handle = Wgl.CreatePbufferEXT(_DeviceContext, pixelFormatIndex, (int)width, (int)height, new int[] { 0 }); if (_Handle == IntPtr.Zero) throw new InvalidOperationException("unable to create P-Buffer", GetPlatformExceptionCore()); } catch { Dispose(); throw; } }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) throw new ArgumentNullException("pixelFormat"); if (IsPixelFormatSet == true) throw new InvalidOperationException("pixel format already set"); #if CHOOSE_PIXEL_FORMAT_FALLBACK try { #endif Wgl.PIXELFORMATDESCRIPTOR pDescriptor = new Wgl.PIXELFORMATDESCRIPTOR(); // Note (from MSDN): Setting the pixel format of a window more than once can lead to significant complications for the Window Manager // and for multithread applications, so it is not allowed. An application can only set the pixel format of a window one time. Once a // window's pixel format is set, it cannot be changed. if (Wgl.DescribePixelFormat(_DeviceContext, pixelFormat.FormatIndex, (uint)pDescriptor.nSize, ref pDescriptor) == 0) throw new InvalidOperationException(String.Format("unable to describe pixel format {0}", pixelFormat.FormatIndex), GetPlatformException()); // Set choosen pixel format if (!Wgl.SetPixelFormat(_DeviceContext, pixelFormat.FormatIndex, ref pDescriptor)) throw new InvalidOperationException(String.Format("unable to set pixel format {0}: {1}", pixelFormat.FormatIndex), GetPlatformException()); #if CHOOSE_PIXEL_FORMAT_FALLBACK } catch (InvalidOperationException) { // Try using default ChoosePixelFormat* SetDisplayablePixelFormat(pixelFormat); } #endif IsPixelFormatSet = true; }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> private static int ChoosePixelFormat(IntPtr deviceContext, DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } List <int> attribIList = new List <int>(); List <float> attribFList = new List <float>(); uint[] countFormatAttribsValues = new uint[1]; int[] choosenFormats = new int[4]; attribIList.AddRange(new int[] { Wgl.SUPPORT_OPENGL_ARB, Gl.TRUE }); if (pixelFormat.RenderWindow) { attribIList.AddRange(new int[] { Wgl.DRAW_TO_WINDOW_ARB, Gl.TRUE }); } if (pixelFormat.RenderPBuffer) { attribIList.AddRange(new int[] { Wgl.DRAW_TO_PBUFFER_ARB, Gl.TRUE }); } if (pixelFormat.RgbaUnsigned) { attribIList.AddRange(new int[] { Wgl.PIXEL_TYPE_ARB, Wgl.TYPE_RGBA_ARB }); } if (pixelFormat.RgbaFloat) { attribIList.AddRange(new int[] { Wgl.PIXEL_TYPE_ARB, Wgl.TYPE_RGBA_FLOAT_ARB }); } if (pixelFormat.ColorBits > 0) { attribIList.AddRange(new int[] { Wgl.COLOR_BITS_ARB, pixelFormat.ColorBits }); } if (pixelFormat.DepthBits > 0) { attribIList.AddRange(new int[] { Wgl.DEPTH_BITS_ARB, pixelFormat.DepthBits }); } if (pixelFormat.StencilBits > 0) { attribIList.AddRange(new int[] { Wgl.STENCIL_BITS_ARB, pixelFormat.StencilBits }); } if (pixelFormat.DoubleBuffer) { attribIList.AddRange(new int[] { Wgl.DOUBLE_BUFFER_ARB, pixelFormat.StencilBits }); } attribIList.Add(0); // Let choose pixel formats if (!Wgl.ChoosePixelFormatARB(deviceContext, attribIList.ToArray(), attribFList.ToArray(), (uint)choosenFormats.Length, choosenFormats, countFormatAttribsValues)) { throw new InvalidOperationException("unable to choose pixel format", GetPlatformExceptionCore()); } return(choosenFormats[0]); }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> public override void ChoosePixelFormat(DevicePixelFormat pixelFormat) { if (_NativeSurface.Handle != IntPtr.Zero) { throw new InvalidOperationException("pixel format already set"); } _Config = ChoosePixelFormat(Display, Version, pixelFormat); }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } _FBConfig = pixelFormat.XFbConfig; _XVisualInfo = pixelFormat.XVisualInfo; }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } // Note: GLX does not really need a SetPixelFormat operation // Framebuffer configuration FBConfig = pixelFormat.XFbConfig; // X Visual Information XVisualInfo = pixelFormat.XVisualInfo; }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> public override void ChoosePixelFormat(DevicePixelFormat pixelFormat) { if (_NativeSurface == null) { return; // Support EGL_KHR_surfaceless_context } if (_NativeSurface.Handle != IntPtr.Zero) { throw new InvalidOperationException("pixel format already set"); } _Config = ChoosePixelFormat(Display, Version, pixelFormat); IsPixelFormatSet = true; }
/// <summary> /// This is called immediately after the surface is first created. /// </summary> /// <param name="holder"> /// The SurfaceHolder whose surface is being created. /// </param> public void SurfaceCreated(ISurfaceHolder holder) { // Problem with static constructors? Ensure manual initialization Egl.Initialize(); Gl.Initialize(); // Get actual native window handle _NativeWindowHandle = ANativeWindow_fromSurface(JNIEnv.Handle, holder.Surface.Handle); // Create device context _DeviceContext = DeviceContext.Create(IntPtr.Zero, _NativeWindowHandle); _DeviceContext.IncRef(); // Set pixel format DevicePixelFormatCollection pixelFormats = _DeviceContext.PixelsFormats; DevicePixelFormat controlReqFormat = new DevicePixelFormat(); controlReqFormat.RgbaUnsigned = true; controlReqFormat.RenderWindow = true; controlReqFormat.ColorBits = 24; //controlReqFormat.DepthBits = (int)DepthBits; //controlReqFormat.StencilBits = (int)StencilBits; //controlReqFormat.MultisampleBits = (int)MultisampleBits; //controlReqFormat.DoubleBuffer = true; List <DevicePixelFormat> matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException("unable to find a suitable pixel format"); } _DeviceContext.SetPixelFormat(matchingPixelFormats[0]); // Create OpenGL context using compatibility profile if ((_RenderContext = _DeviceContext.CreateContext(IntPtr.Zero)) == IntPtr.Zero) { throw new InvalidOperationException("unable to create render context"); } // Make context current if (_DeviceContext.MakeCurrent(_RenderContext) == false) { throw new InvalidOperationException("unable to make context current"); } // Raise relative event OnContextCreated(); StartRendering(30.0f); }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> public override void ChoosePixelFormat(DevicePixelFormat pixelFormat) { if (IsPixelFormatSet == true) throw new InvalidOperationException("pixel format already set"); // Choose pixel format int pixelFormatIndex = ChoosePixelFormat(_DeviceContext, pixelFormat); // Set choosen pixel format Wgl.PIXELFORMATDESCRIPTOR pDescriptor = new Wgl.PIXELFORMATDESCRIPTOR(); if (Wgl.SetPixelFormat(_DeviceContext, pixelFormatIndex, ref pDescriptor) == false) throw new InvalidOperationException("unable to set pixel format", GetPlatformException()); IsPixelFormatSet = true; }
void impl_ChoosePixelFormat(DevicePixelFormat pixelFormat) { // Create pixel format descriptor _pfd = new Win32.PIXELFORMATDESCRIPTOR() { nSize = (ushort)System.Runtime.InteropServices.Marshal.SizeOf(typeof(OpenGL.Win32.PIXELFORMATDESCRIPTOR)), nVersion = 1, dwFlags = OpenGL.Win32.PFD_DRAW_TO_WINDOW | OpenGL.Win32.PFD_SUPPORT_OPENGL | OpenGL.Win32.PFD_DOUBLEBUFFER, iPixelType = OpenGL.Win32.PFD_TYPE_RGBA, cColorBits = (byte)pixelFormat.ColorBits, cDepthBits = (byte)pixelFormat.DepthBits, iLayerType = OpenGL.Win32.PFD_PLANE_MAIN, }; // Choose pixel format _pixelFormat = Win32.ChoosePixelFormat(_hdc, ref _pfd); }
/// <summary> /// Create an off-screen buffer. /// </summary> /// <returns> /// It returns a <see cref="INativePBuffer"/> that implements a native P-Buffer on the underlying platform. /// </returns> /// <exception cref='NotSupportedException'> /// Exception thrown if the current platform is not supported. /// </exception> public static INativePBuffer CreatePBuffer(DevicePixelFormat pixelFormat, uint width, uint height) { #if !MONODROID if (Egl.IsRequired == false) { switch (Platform.CurrentPlatformId) { case Platform.Id.WindowsNT: return(new DeviceContextWGL.NativePBuffer(pixelFormat, width, height)); default: throw new NotSupportedException(String.Format("platform {0} not supported", Platform.CurrentPlatformId)); } } else #endif return(new DeviceContextEGL.NativePBuffer(pixelFormat, width, height)); }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException(nameof(pixelFormat)); } if (_NativeSurface == null) { return; // Support EGL_KHR_surfaceless_context } if (_NativeSurface.Handle != IntPtr.Zero) { throw new InvalidOperationException("pixel format already set"); } List <int> configAttribs = new List <int>(); if (Version >= Egl.Version_120) { configAttribs.AddRange(new[] { Egl.RENDERABLE_TYPE, Egl.OPENGL_ES2_BIT }); } configAttribs.AddRange(new[] { Egl.CONFIG_ID, pixelFormat.FormatIndex }); configAttribs.Add(Egl.NONE); int[] configCount = new int[1]; IntPtr[] configs = new IntPtr[1]; if (Egl.ChooseConfig(Display, configAttribs.ToArray(), configs, 1, configCount) == false) { throw new InvalidOperationException("unable to choose configuration"); } if (configCount[0] == 0) { throw new InvalidOperationException("no available configuration"); } _Config = configs[0]; IsPixelFormatSet = true; }
private DevicePixelFormatCollection GetPixelFormats_Win32() { DevicePixelFormatCollection pixelFormats = new DevicePixelFormatCollection(); Wgl.PIXELFORMATDESCRIPTOR pixelDescr = new Wgl.PIXELFORMATDESCRIPTOR(); int pixelFormatsCount = Wgl.DescribePixelFormat(_DeviceContext, 0, 0, ref pixelDescr); for (int i = 1; i <= pixelFormatsCount; i++) { Wgl.DescribePixelFormat(_DeviceContext, i, (uint)Marshal.SizeOf(typeof(Wgl.PIXELFORMATDESCRIPTOR)), ref pixelDescr); if ((pixelDescr.dwFlags & Wgl.PixelFormatDescriptorFlags.SupportOpenGL) == 0) continue; DevicePixelFormat pixelFormat = new DevicePixelFormat(); pixelFormat.FormatIndex = i; pixelFormat.RgbaUnsigned = true; pixelFormat.RgbaFloat = false; pixelFormat.RenderWindow = true; pixelFormat.RenderBuffer = false; pixelFormat.DoubleBuffer = (pixelDescr.dwFlags & Wgl.PixelFormatDescriptorFlags.Doublebuffer) != 0; pixelFormat.SwapMethod = 0; pixelFormat.StereoBuffer = (pixelDescr.dwFlags & Wgl.PixelFormatDescriptorFlags.Stereo) != 0; pixelFormat.ColorBits = pixelDescr.cColorBits; pixelFormat.DepthBits = pixelDescr.cDepthBits; pixelFormat.StencilBits = pixelDescr.cStencilBits; pixelFormat.MultisampleBits = 0; pixelFormat.RenderPBuffer = false; pixelFormat.SRGBCapable = false; pixelFormats.Add(pixelFormat); } return (pixelFormats); }
private int GetPixelFormatPriority(DevicePixelFormat pixelFormat) { int priority = 0; if (!IsRequiredBuffer(BufferType.Depth) && pixelFormat.DepthBits > 0) { priority -= 1; } if (!IsRequiredBuffer(BufferType.Stencil) && pixelFormat.StencilBits > 0) { priority -= 1; } if (!IsRequiredBuffer(BufferType.Multisample) && pixelFormat.MultisampleBits > 0) { priority -= 1; } if (pixelFormat.DoubleBuffer) { priority += 3; } return(priority); }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> public override void ChoosePixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) { throw new ArgumentNullException("pixelFormat"); } int screen = Glx.XDefaultScreen(_Display); // Get basic visual Glx.XVisualInfo visual; IntPtr config; List <int> attributes = new List <int>(); if (pixelFormat.RenderWindow) { attributes.AddRange(new int[] { Glx.DRAWABLE_TYPE, (int)Glx.WINDOW_BIT }); } if (pixelFormat.RgbaUnsigned) { attributes.AddRange(new int[] { Glx.RENDER_TYPE, (int)Glx.RGBA_BIT }); } if (pixelFormat.RgbaFloat) { attributes.AddRange(new int[] { Glx.RENDER_TYPE, (int)Glx.RGBA_FLOAT_BIT_ARB }); } if (pixelFormat.DoubleBuffer) { attributes.AddRange(new int[] { Glx.DOUBLEBUFFER, Gl.TRUE }); } if (pixelFormat.ColorBits > 0) { switch (pixelFormat.ColorBits) { case 16: attributes.AddRange(new int[] { Glx.RED_SIZE, 5, Glx.GREEN_SIZE, 6, Glx.BLUE_SIZE, 8, Glx.ALPHA_SIZE, 5 }); break; case 24: attributes.AddRange(new int[] { Glx.RED_SIZE, 8, Glx.GREEN_SIZE, 8, Glx.BLUE_SIZE, 8 }); break; case 32: attributes.AddRange(new int[] { Glx.RED_SIZE, 8, Glx.GREEN_SIZE, 8, Glx.BLUE_SIZE, 8, Glx.ALPHA_SIZE, 8 }); break; default: if (pixelFormat.ColorBits < 16) { attributes.AddRange(new int[] { Glx.RED_SIZE, 1, Glx.GREEN_SIZE, 1, Glx.BLUE_SIZE, 1 }); } else { int bits = pixelFormat.ColorBits / 4; attributes.AddRange(new int[] { Glx.RED_SIZE, bits, Glx.GREEN_SIZE, bits, Glx.BLUE_SIZE, bits }); } break; } } if (pixelFormat.DepthBits > 0) { attributes.AddRange(new int[] { Glx.DEPTH_SIZE, pixelFormat.DepthBits }); } if (pixelFormat.StencilBits > 0) { attributes.AddRange(new int[] { Glx.STENCIL_SIZE, pixelFormat.StencilBits }); } attributes.Add(0); unsafe { int[] choosenConfigCount = new int[1]; IntPtr *choosenConfigs = Glx.ChooseFBConfig(_Display, screen, attributes.ToArray(), choosenConfigCount); if (choosenConfigCount[0] == 0) { throw new InvalidOperationException("unable to choose visual"); } config = *choosenConfigs; KhronosApi.LogComment("Choosen config is 0x{0}", config.ToString("X8")); visual = Glx.GetVisualFromFBConfig(_Display, config); KhronosApi.LogComment("Choosen visual is {0}", visual); Glx.XFree((IntPtr)choosenConfigs); } _FBConfig = config; _XVisualInfo = visual; IsPixelFormatSet = true; }
/// <summary> /// Copy this DevicePixelFormat /// </summary> /// <returns> /// It returns a <see cref="DevicePixelFormat"/> equals to this DevicePixelFormat. /// </returns> public DevicePixelFormat Copy() { DevicePixelFormat copy = (DevicePixelFormat)MemberwiseClone(); return(copy); }
/// <summary> /// Callback method for filtering valid pixel formats for this GraphicsSurface. /// </summary> /// <param name="pFormat"> /// A <see cref="DevicePixelFormat"/> to be validated by derived implementation. /// </param> /// <returns> /// It returns true in the case the pixel format is valid for usage in the derived implementation, /// otherwise it returns false. /// </returns> private static bool ValidPixelFormat(DevicePixelFormat pFormat) { // The pixel format must be able to render on a window return (pFormat.RenderWindow); }
/// <summary> /// Construct a NativePBuffer with a specific pixel format and size. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format and the ancillary buffers required. /// </param> /// <param name="width"> /// A <see cref="UInt32"/> that specifies the width of the P-Buffer, in pixels. /// </param> /// <param name="height"> /// A <see cref="UInt32"/> that specifies the height of the P-Buffer, in pixels. /// </param> public NativePBuffer(DevicePixelFormat pixelFormat, uint width, uint height) : this(DefaultDisplay, pixelFormat, width, height) { }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> private static IntPtr ChoosePixelFormat(IntPtr display, KhronosVersion version, DevicePixelFormat pixelFormat) { if (version == null) { throw new ArgumentNullException(nameof(version)); } if (pixelFormat == null) { throw new ArgumentNullException(nameof(pixelFormat)); } List <int> configAttribs = new List <int>(); int[] configCount = new int[1]; IntPtr[] configs = new IntPtr[8]; int surfaceType = 0; if (version >= Egl.Version_120) { configAttribs.AddRange(new[] { Egl.RENDERABLE_TYPE, Egl.OPENGL_ES2_BIT }); } if (pixelFormat.RenderWindow) { surfaceType |= Egl.WINDOW_BIT; } if (pixelFormat.RenderPBuffer) { surfaceType |= Egl.PBUFFER_BIT; } if (surfaceType != 0) { configAttribs.AddRange(new[] { Egl.SURFACE_TYPE, surfaceType }); } switch (pixelFormat.ColorBits) { case 24: configAttribs.AddRange(new[] { Egl.RED_SIZE, 8, Egl.GREEN_SIZE, 8, Egl.BLUE_SIZE, 8 }); break; case 32: configAttribs.AddRange(new[] { Egl.RED_SIZE, 8, Egl.GREEN_SIZE, 8, Egl.BLUE_SIZE, 8, Egl.ALPHA_SIZE, 8 }); break; default: configAttribs.AddRange(new[] { Egl.BUFFER_SIZE, pixelFormat.ColorBits }); break; } if (pixelFormat.DepthBits > 0) { configAttribs.AddRange(new[] { Egl.DEPTH_SIZE, pixelFormat.DepthBits }); } if (pixelFormat.StencilBits > 0) { configAttribs.AddRange(new[] { Egl.STENCIL_SIZE, pixelFormat.StencilBits }); } configAttribs.Add(Egl.NONE); if (Egl.ChooseConfig(display, configAttribs.ToArray(), configs, configs.Length, configCount) == false) { throw new InvalidOperationException("unable to choose configuration"); } if (configCount[0] == 0) { throw new InvalidOperationException("no available configuration"); } return(configs[0]); }
private int GetPixelFormatPriority(DevicePixelFormat pixelFormat) { int priority = 0; if (!IsRequiredBuffer(BufferType.Depth) && pixelFormat.DepthBits > 0) priority -= 1; if (!IsRequiredBuffer(BufferType.Stencil) && pixelFormat.StencilBits > 0) priority -= 1; if (!IsRequiredBuffer(BufferType.Multisample) && pixelFormat.MultisampleBits > 0) priority -= 1; if (pixelFormat.DoubleBuffer) priority += 3; return (priority); }
/// <summary> /// Create the device context and set the pixel format. /// </summary> private void CreateDeviceContext(DevicePixelFormat controlReqFormat) { #region Support ES/SC API switch (_ProfileType) { case ProfileType.Embedded: DeviceContext.DefaultAPI = KhronosVersion.ApiGles2; break; case ProfileType.SecurityCritical2: DeviceContext.DefaultAPI = KhronosVersion.ApiGlsc2; break; } #endregion #region Create device context _DeviceContext = DeviceContext.Create(GetDisplay(), this.Handle); _DeviceContext.IncRef(); #endregion #region Set pixel format DevicePixelFormatCollection pixelFormats = _DeviceContext.PixelsFormats; List <DevicePixelFormat> matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if ((matchingPixelFormats.Count == 0) && controlReqFormat.MultisampleBits > 0) { // Try to select the maximum multisample configuration int multisampleBits = 0; pixelFormats.ForEach(delegate(DevicePixelFormat item) { multisampleBits = Math.Max(multisampleBits, item.MultisampleBits); }); controlReqFormat.MultisampleBits = multisampleBits; matchingPixelFormats = pixelFormats.Choose(controlReqFormat); } if ((matchingPixelFormats.Count == 0) && controlReqFormat.DoubleBuffer) { // Try single buffered pixel formats controlReqFormat.DoubleBuffer = false; matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException(String.Format("unable to find a suitable pixel format: {0}", pixelFormats.GuessChooseError(controlReqFormat))); } } else if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException(String.Format("unable to find a suitable pixel format: {0}", pixelFormats.GuessChooseError(controlReqFormat))); } _DeviceContext.SetPixelFormat(matchingPixelFormats[0]); #endregion #region Set V-Sync if (Gl.PlatformExtensions.SwapControl) { int swapInterval = SwapInterval; // Mask value in case it is not supported if (!Gl.PlatformExtensions.SwapControlTear && swapInterval == -1) { swapInterval = 1; } _DeviceContext.SwapInterval(swapInterval); } #endregion }
/// <summary> /// Confirm pixel format assigned to this surface. XXX /// </summary> /// <param name="pFormat"> /// A <see cref="DevicePixelFormat"/> defining the available surface buffers /// and their definitions. /// </param> /// <remarks> /// This routine shall be called after a successfull call to SetPixelFormat. /// </remarks> public void SetBufferConfiguration(DevicePixelFormat pFormat) { // Determine available buffers mSurfaceBuffers = 0; if (pFormat.ColorBits > 0) { if (pFormat.SRGBCapable == false) mSurfaceBuffers |= BufferType.Color; else mSurfaceBuffers |= BufferType.ColorSRGB; } if (pFormat.DepthBits > 0) mSurfaceBuffers |= BufferType.Depth; if (pFormat.StencilBits > 0) mSurfaceBuffers |= BufferType.Stencil; if (pFormat.MultisampleBits > 0) mSurfaceBuffers |= BufferType.Multisample; if (pFormat.DoubleBuffer == true) mSurfaceBuffers |= BufferType.Double; if (pFormat.StereoBuffer == true) mSurfaceBuffers |= BufferType.Stereo; // Store buffer definitions switch (pFormat.ColorBits) { case 8: mColorType = PixelLayout.RGB8; break; case 16: mColorType = PixelLayout.RGB16; break; case 24: mColorType = PixelLayout.RGB24; break; case 32: mColorType = PixelLayout.RGBA32; break; default: throw new InvalidOperationException("invalid pixel format composed by " + pFormat.ColorBits + " bits"); } mDepthBits = (uint)pFormat.DepthBits; mStencilBits = (uint)pFormat.StencilBits; mMultisampleBits = (uint)pFormat.MultisampleBits; mDoubleBuffers = pFormat.DoubleBuffer; mStereoBuffers = pFormat.StereoBuffer; }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> public abstract void SetPixelFormat(DevicePixelFormat pixelFormat);
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> public abstract void ChoosePixelFormat(DevicePixelFormat pixelFormat);
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) throw new ArgumentNullException("pixelFormat"); }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) throw new ArgumentNullException("pixelFormat"); // Note: GLX does not really need a SetPixelFormat operation // Framebuffer configuration FBConfig = pixelFormat.XFbConfig; // X Visual Information XVisualInfo = pixelFormat.XVisualInfo; }
/// <summary> /// Set the device pixel format. /// </summary> /// <param name="pixelFormat"> /// A <see cref="DevicePixelFormat"/> that specifies the pixel format to set. /// </param> /// <exception cref="ArgumentNullException"> /// Exception thrown if <paramref name="pixelFormat"/> is null. /// </exception> public override void SetPixelFormat(DevicePixelFormat pixelFormat) { if (pixelFormat == null) throw new ArgumentNullException("pixelFormat"); if (_PixelFormatSet == true) throw new InvalidOperationException("pixel format already set"); Wgl.PIXELFORMATDESCRIPTOR pDescriptor = new Wgl.PIXELFORMATDESCRIPTOR(); bool res; // Note (from MSDN): Setting the pixel format of a window more than once can lead to significant complications for the Window Manager // and for multithread applications, so it is not allowed. An application can only set the pixel format of a window one time. Once a // window's pixel format is set, it cannot be changed. res = Wgl.DescribePixelFormat(DeviceContext, pixelFormat.FormatIndex, (uint)pDescriptor.nSize, ref pDescriptor); Debug.Assert(res); // Set choosen pixel format res = Wgl.SetPixelFormat(DeviceContext, pixelFormat.FormatIndex, ref pDescriptor); Debug.Assert(res); // Unable to set pixel format again _PixelFormatSet = true; }