mirror of https://github.com/dahall/Vanara.git
673 lines
32 KiB
C#
673 lines
32 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Vanara.PInvoke
|
|
{
|
|
public static partial class Gdi32
|
|
{
|
|
/// <summary>A set of bit flags that specify properties of the pixel buffer.</summary>
|
|
[PInvokeData("wingdi.h", MSDNShortId = "1480dea3-ae74-4e8b-b4de-fca8de5d8395")]
|
|
[Flags]
|
|
public enum PFD_FLAGS : uint
|
|
{
|
|
/// <summary>The buffer is double-buffered. This flag and PFD_SUPPORT_GDI are mutually exclusive in the current generic implementation.</summary>
|
|
PFD_DOUBLEBUFFER = 0x00000001,
|
|
|
|
/// <summary>The buffer is stereoscopic. This flag is not supported in the current generic implementation.</summary>
|
|
PFD_STEREO = 0x00000002,
|
|
|
|
/// <summary>The buffer can draw to a window or device surface.</summary>
|
|
PFD_DRAW_TO_WINDOW = 0x00000004,
|
|
|
|
/// <summary>The buffer can draw to a memory bitmap.</summary>
|
|
PFD_DRAW_TO_BITMAP = 0x00000008,
|
|
|
|
/// <summary>
|
|
/// The buffer supports GDI drawing. This flag and PFD_DOUBLEBUFFER are mutually exclusive in the current generic implementation.
|
|
/// </summary>
|
|
PFD_SUPPORT_GDI = 0x00000010,
|
|
|
|
/// <summary>The buffer supports OpenGL drawing.</summary>
|
|
PFD_SUPPORT_OPENGL = 0x00000020,
|
|
|
|
/// <summary>
|
|
/// The pixel format is supported by the GDI software implementation, which is also known as the generic implementation. If this
|
|
/// bit is clear, the pixel format is supported by a device driver or hardware.
|
|
/// </summary>
|
|
PFD_GENERIC_FORMAT = 0x00000040,
|
|
|
|
/// <summary>
|
|
/// The buffer uses RGBA pixels on a palette-managed device. A logical palette is required to achieve the best results for this
|
|
/// pixel type. Colors in the palette should be specified according to the values of the cRedBits, cRedShift, cGreenBits,
|
|
/// cGreenShift, cBluebits, and cBlueShift members. The palette should be created and realized in the device context before
|
|
/// calling wglMakeCurrent.
|
|
/// </summary>
|
|
PFD_NEED_PALETTE = 0x00000080,
|
|
|
|
/// <summary>
|
|
/// Defined in the pixel format descriptors of hardware that supports one hardware palette in 256-color mode only. For such
|
|
/// systems to use hardware acceleration, the hardware palette must be in a fixed order (for example, 3-3-2) when in RGBA mode or
|
|
/// must match the logical palette when in color-index mode.When this flag is set, you must call SetSystemPaletteUse in your
|
|
/// program to force a one-to-one mapping of the logical palette and the system palette. If your OpenGL hardware supports
|
|
/// multiple hardware palettes and the device driver can allocate spare hardware palettes for OpenGL, this flag is typically clear.
|
|
/// <para>This flag is not set in the generic pixel formats.</para>
|
|
/// </summary>
|
|
PFD_NEED_SYSTEM_PALETTE = 0x00000100,
|
|
|
|
/// <summary>
|
|
/// Specifies the content of the back buffer in the double-buffered main color plane following a buffer swap. Swapping the color
|
|
/// buffers causes the exchange of the back buffer's content with the front buffer's content. Following the swap, the back
|
|
/// buffer's content contains the front buffer's content before the swap. PFD_SWAP_EXCHANGE is a hint only and might not be
|
|
/// provided by a driver.
|
|
/// </summary>
|
|
PFD_SWAP_EXCHANGE = 0x00000200,
|
|
|
|
/// <summary>
|
|
/// Specifies the content of the back buffer in the double-buffered main color plane following a buffer swap. Swapping the color
|
|
/// buffers causes the content of the back buffer to be copied to the front buffer. The content of the back buffer is not
|
|
/// affected by the swap. PFD_SWAP_COPY is a hint only and might not be provided by a driver.
|
|
/// </summary>
|
|
PFD_SWAP_COPY = 0x00000400,
|
|
|
|
/// <summary>
|
|
/// Indicates whether a device can swap individual layer planes with pixel formats that include double-buffered overlay or
|
|
/// underlay planes. Otherwise all layer planes are swapped together as a group. When this flag is set, wglSwapLayerBuffers is supported.
|
|
/// </summary>
|
|
PFD_SWAP_LAYER_BUFFERS = 0x00000800,
|
|
|
|
/// <summary>
|
|
/// The pixel format is supported by a device driver that accelerates the generic implementation. If this flag is clear and the
|
|
/// PFD_GENERIC_FORMAT flag is set, the pixel format is supported by the generic implementation only.
|
|
/// </summary>
|
|
PFD_GENERIC_ACCELERATED = 0x00001000,
|
|
|
|
/// <summary>The PFD support directdraw</summary>
|
|
PFD_SUPPORT_DIRECTDRAW = 0x00002000,
|
|
|
|
/// <summary>The PFD direc t3 d accelerated</summary>
|
|
PFD_DIRECT3D_ACCELERATED = 0x00004000,
|
|
|
|
/// <summary>The PFD support composition</summary>
|
|
PFD_SUPPORT_COMPOSITION = 0x00008000,
|
|
|
|
/// <summary>
|
|
/// The requested pixel format can either have or not have a depth buffer. To select a pixel format without a depth buffer, you
|
|
/// must specify this flag. The requested pixel format can be with or without a depth buffer. Otherwise, only pixel formats with
|
|
/// a depth buffer are considered.
|
|
/// </summary>
|
|
PFD_DEPTH_DONTCARE = 0x20000000,
|
|
|
|
/// <summary>The requested pixel format can be either single- or double-buffered.</summary>
|
|
PFD_DOUBLEBUFFER_DONTCARE = 0x40000000,
|
|
|
|
/// <summary>The requested pixel format can be either monoscopic or stereoscopic.</summary>
|
|
PFD_STEREO_DONTCARE = 0x80000000,
|
|
}
|
|
|
|
/// <summary>The plane layer.</summary>
|
|
[PInvokeData("wingdi.h", MSDNShortId = "1480dea3-ae74-4e8b-b4de-fca8de5d8395")]
|
|
public enum PFD_LAYER : sbyte
|
|
{
|
|
/// <summary>The layer is the main plane.</summary>
|
|
PFD_MAIN_PLANE = 0,
|
|
|
|
/// <summary>The layer is the overlay plane.</summary>
|
|
PFD_OVERLAY_PLANE = 1,
|
|
|
|
/// <summary>The layer is the underlay plane.</summary>
|
|
PFD_UNDERLAY_PLANE = -1
|
|
}
|
|
|
|
/// <summary>Specifies the type of pixel data.</summary>
|
|
[PInvokeData("wingdi.h", MSDNShortId = "1480dea3-ae74-4e8b-b4de-fca8de5d8395")]
|
|
public enum PFD_TYPE : byte
|
|
{
|
|
/// <summary>RGBA pixels. Each pixel has four components in this order: red, green, blue, and alpha.</summary>
|
|
PFD_TYPE_RGBA = 0,
|
|
|
|
/// <summary>Color-index pixels. Each pixel uses a color-index value.</summary>
|
|
PFD_TYPE_COLORINDEX = 1,
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ChoosePixelFormat</c> function attempts to match an appropriate pixel format supported by a device context to a given
|
|
/// pixel format specification.
|
|
/// </summary>
|
|
/// <param name="hdc">
|
|
/// Specifies the device context that the function examines to determine the best match for the pixel format descriptor pointed to by ppfd.
|
|
/// </param>
|
|
/// <param name="ppfd">
|
|
/// <para>
|
|
/// Pointer to a PIXELFORMATDESCRIPTOR structure that specifies the requested pixel format. In this context, the members of the
|
|
/// <c>PIXELFORMATDESCRIPTOR</c> structure that ppfd points to are used as follows:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>nSize</term>
|
|
/// <term>Specifies the size of the PIXELFORMATDESCRIPTOR data structure. Set this member to .</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>nVersion</term>
|
|
/// <term>Specifies the version number of the PIXELFORMATDESCRIPTOR data structure. Set this member to 1.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>dwFlags</term>
|
|
/// <term>
|
|
/// A set of bit flags that specify properties of the pixel buffer. You can combine the following bit flag constants by using
|
|
/// bitwise-OR. If any of the following flags are set, the ChoosePixelFormat function attempts to match pixel formats that also have
|
|
/// that flag or flags set. Otherwise, ChoosePixelFormat ignores that flag in the pixel formats: PFD_DRAW_TO_WINDOW,
|
|
/// PFD_DRAW_TO_BITMAP, PFD_SUPPORT_GDI, PFD_SUPPORT_OPENGL If any of the following flags are set, ChoosePixelFormat attempts to
|
|
/// match pixel formats that also have that flag or flags set. Otherwise, it attempts to match pixel formats without that flag set:
|
|
/// PFD_DOUBLEBUFFER PFD_STEREO If the following flag is set, the function ignores the PFD_DOUBLEBUFFER flag in the pixel formats:
|
|
/// PFD_DOUBLEBUFFER_DONTCARE If the following flag is set, the function ignores the PFD_STEREO flag in the pixel formats: PFD_STEREO_DONTCARE
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>iPixelType</term>
|
|
/// <term>Specifies the type of pixel format for the function to consider: PFD_TYPE_RGBA, PFD_TYPE_COLORINDEX</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cColorBits</term>
|
|
/// <term>Zero or greater.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cRedBits</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cRedShift</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cGreenBits</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cGreenShift</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cBlueBits</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cBlueShift</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cAlphaBits</term>
|
|
/// <term>Zero or greater.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cAlphaShift</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cAccumBits</term>
|
|
/// <term>Zero or greater.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cAccumRedBits</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cAccumGreenBits</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cAccumBlueBits</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cAccumAlphaBits</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cDepthBits</term>
|
|
/// <term>Zero or greater.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cStencilBits</term>
|
|
/// <term>Zero or greater.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>cAuxBuffers</term>
|
|
/// <term>Zero or greater.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>iLayerType</term>
|
|
/// <term>Specifies one of the following layer type values: PFD_MAIN_PLANE, PFD_OVERLAY_PLANE, PFD_UNDERLAY_PLANE</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>bReserved</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>dwLayerMask</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>dwVisibleMask</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>dwDamageMask</term>
|
|
/// <term>Not used.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is a pixel format index (one-based) that is the closest match to the given pixel
|
|
/// format descriptor.
|
|
/// </para>
|
|
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// You must ensure that the pixel format matched by the <c>ChoosePixelFormat</c> function satisfies your requirements. For example,
|
|
/// if you request a pixel format with a 24-bit RGB color buffer but the device context offers only 8-bit RGB color buffers, the
|
|
/// function returns a pixel format with an 8-bit RGB color buffer.
|
|
/// </para>
|
|
/// <para>Examples</para>
|
|
/// <para>The following code sample shows how to use <c>ChoosePixelFormat</c> to match a specified pixel format.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-choosepixelformat int ChoosePixelFormat( HDC hdc, const
|
|
// PIXELFORMATDESCRIPTOR *ppfd );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "17bd0a2c-5257-4ae3-80f4-a5ad536169fb")]
|
|
public static extern int ChoosePixelFormat(HDC hdc, in PIXELFORMATDESCRIPTOR ppfd);
|
|
|
|
/// <summary>
|
|
/// The <c>DescribePixelFormat</c> function obtains information about the pixel format identified by iPixelFormat of the device
|
|
/// associated with hdc. The function sets the members of the PIXELFORMATDESCRIPTOR structure pointed to by ppfd with that pixel
|
|
/// format data.
|
|
/// </summary>
|
|
/// <param name="hdc">Specifies the device context.</param>
|
|
/// <param name="iPixelFormat">
|
|
/// Index that specifies the pixel format. The pixel formats that a device context supports are identified by positive one-based
|
|
/// integer indexes.
|
|
/// </param>
|
|
/// <param name="nBytes">
|
|
/// The size, in bytes, of the structure pointed to by ppfd. The <c>DescribePixelFormat</c> function stores no more than nBytes bytes
|
|
/// of data to that structure. Set this value to <c>sizeof</c>( <c>PIXELFORMATDESCRIPTOR</c>).
|
|
/// </param>
|
|
/// <param name="ppfd">
|
|
/// Pointer to a <c>PIXELFORMATDESCRIPTOR</c> structure whose members the function sets with pixel format data. The function stores
|
|
/// the number of bytes copied to the structure in the structure's <c>nSize</c> member. If, upon entry, ppfd is <c>NULL</c>, the
|
|
/// function writes no data to the structure. This is useful when you only want to obtain the maximum pixel format index of a device context.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is the maximum pixel format index of the device context. In addition, the function
|
|
/// sets the members of the <c>PIXELFORMATDESCRIPTOR</c> structure pointed to by ppfd according to the specified pixel format.
|
|
/// </para>
|
|
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-describepixelformat int DescribePixelFormat( HDC hdc, int
|
|
// iPixelFormat, UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "9692a30d-c7d4-40c7-a265-72c4ebabd5f2")]
|
|
public static extern int DescribePixelFormat(HDC hdc, int iPixelFormat, uint nBytes, ref PIXELFORMATDESCRIPTOR ppfd);
|
|
|
|
/// <summary>The <c>GetEnhMetaFilePixelFormat</c> function retrieves pixel format information for an enhanced metafile.</summary>
|
|
/// <param name="hemf">Identifies the enhanced metafile.</param>
|
|
/// <param name="cbBuffer">Specifies the size, in bytes, of the buffer into which the pixel format information is copied.</param>
|
|
/// <param name="ppfd">
|
|
/// Pointer to a PIXELFORMATDESCRIPTOR structure that contains the logical pixel format specification. The metafile uses this
|
|
/// structure to record the logical pixel format specification.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds and finds a pixel format, the return value is the size of the metafile's pixel format.</para>
|
|
/// <para>If no pixel format is present, the return value is zero.</para>
|
|
/// <para>If an error occurs and the function fails, the return value is GDI_ERROR. To get extended error information, call GetLastError.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// When an enhanced metafile specifies a pixel format in its <c>ENHMETAHEADER</c> structure and the pixel format fits in the buffer,
|
|
/// the pixel format information is copied into ppfd. When cbBuffer is too small to contain the pixel format of the metafile, the
|
|
/// pixel format is not copied to the buffer. In either case, the function returns the size of the metafile's pixel format.
|
|
/// </para>
|
|
/// <para>For information on metafile recording and other operations, see Enhanced Metafile Operations.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-getenhmetafilepixelformat UINT GetEnhMetaFilePixelFormat(
|
|
// HENHMETAFILE hemf, UINT cbBuffer, PIXELFORMATDESCRIPTOR *ppfd );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "80209210-5caa-44a9-a791-991b257d8d28")]
|
|
public static extern uint GetEnhMetaFilePixelFormat(HENHMETAFILE hemf, uint cbBuffer, ref PIXELFORMATDESCRIPTOR ppfd);
|
|
|
|
/// <summary>
|
|
/// The <c>GetPixelFormat</c> function obtains the index of the currently selected pixel format of the specified device context.
|
|
/// </summary>
|
|
/// <param name="hdc">Specifies the device context of the currently selected pixel format index returned by the function.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is the currently selected pixel format index of the specified device context. This is
|
|
/// a positive, one-based index value.
|
|
/// </para>
|
|
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getpixelformat
|
|
// int GetPixelFormat( HDC hdc );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "e9a65f3a-6932-462f-b342-a993d222fae8")]
|
|
public static extern int GetPixelFormat(HDC hdc);
|
|
|
|
/// <summary>
|
|
/// The <c>SetPixelFormat</c> function sets the pixel format of the specified device context to the format specified by the
|
|
/// iPixelFormat index.
|
|
/// </summary>
|
|
/// <param name="hdc">Specifies the device context whose pixel format the function attempts to set.</param>
|
|
/// <param name="format">
|
|
/// Index that identifies the pixel format to set. The various pixel formats supported by a device context are identified by
|
|
/// one-based indexes.
|
|
/// </param>
|
|
/// <param name="ppfd">
|
|
/// Pointer to a PIXELFORMATDESCRIPTOR structure that contains the logical pixel format specification. The system's metafile
|
|
/// component uses this structure to record the logical pixel format specification. The structure has no other effect upon the
|
|
/// behavior of the <c>SetPixelFormat</c> function.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is <c>TRUE</c>.</para>
|
|
/// <para>If the function fails, the return value is <c>FALSE</c>. To get extended error information, call GetLastError.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// If hdc references a window, calling the <c>SetPixelFormat</c> function also changes the pixel format of the window. 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// You should select a pixel format in the device context before calling the wglCreateContext function. The <c>wglCreateContext</c>
|
|
/// function creates a rendering context for drawing on the device in the selected pixel format of the device context.
|
|
/// </para>
|
|
/// <para>
|
|
/// An OpenGL window has its own pixel format. Because of this, only device contexts retrieved for the client area of an OpenGL
|
|
/// window are allowed to draw into the window. As a result, an OpenGL window should be created with the WS_CLIPCHILDREN and
|
|
/// WS_CLIPSIBLINGS styles. Additionally, the window class attribute should not include the CS_PARENTDC style.
|
|
/// </para>
|
|
/// <para>Examples</para>
|
|
/// <para>The following code example shows <c>SetPixelFormat</c> usage.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-setpixelformat BOOL SetPixelFormat( HDC hdc, int format,
|
|
// const PIXELFORMATDESCRIPTOR *ppfd );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "f8d74078-a7e7-4d95-857a-f51d5d70598e")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool SetPixelFormat(HDC hdc, int format, ref PIXELFORMATDESCRIPTOR ppfd);
|
|
|
|
/// <summary>
|
|
/// The <c>SwapBuffers</c> function exchanges the front and back buffers if the current pixel format for the window referenced by the
|
|
/// specified device context includes a back buffer.
|
|
/// </summary>
|
|
/// <param name="Arg1">
|
|
/// Specifies a device context. If the current pixel format for the window referenced by this device context includes a back buffer,
|
|
/// the function exchanges the front and back buffers.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is <c>TRUE</c>.</para>
|
|
/// <para>If the function fails, the return value is <c>FALSE</c>. To get extended error information, call GetLastError.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// If the current pixel format for the window referenced by the device context does not include a back buffer, this call has no
|
|
/// effect and the content of the back buffer is undefined when the function returns.
|
|
/// </para>
|
|
/// <para>
|
|
/// With multithread applications, flush the drawing commands in any other threads drawing to the same window before calling <c>SwapBuffers</c>.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-swapbuffers BOOL SwapBuffers( HDC Arg1 );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "2c9728e4-c5be-4b14-a6f7-2899c792ec3d")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool SwapBuffers(HDC Arg1);
|
|
|
|
/// <summary>The <c>PIXELFORMATDESCRIPTOR</c> structure describes the pixel format of a drawing surface.</summary>
|
|
/// <remarks>
|
|
/// Please notice carefully, as documented above, that certain pixel format properties are not supported in the current generic
|
|
/// implementation. The generic implementation is the Microsoft GDI software implementation of OpenGL. Hardware manufacturers may
|
|
/// enhance parts of OpenGL, and may support some pixel format properties not supported by the generic implementation.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/ns-wingdi-tagpixelformatdescriptor typedef struct
|
|
// tagPIXELFORMATDESCRIPTOR { WORD nSize; WORD nVersion; DWORD dwFlags; BYTE iPixelType; BYTE cColorBits; BYTE cRedBits; BYTE
|
|
// cRedShift; BYTE cGreenBits; BYTE cGreenShift; BYTE cBlueBits; BYTE cBlueShift; BYTE cAlphaBits; BYTE cAlphaShift; BYTE cAccumBits;
|
|
// BYTE cAccumRedBits; BYTE cAccumGreenBits; BYTE cAccumBlueBits; BYTE cAccumAlphaBits; BYTE cDepthBits; BYTE cStencilBits; BYTE
|
|
// cAuxBuffers; BYTE iLayerType; BYTE bReserved; DWORD dwLayerMask; DWORD dwVisibleMask; DWORD dwDamageMask; } PIXELFORMATDESCRIPTOR,
|
|
// *PPIXELFORMATDESCRIPTOR, *LPPIXELFORMATDESCRIPTOR;
|
|
[PInvokeData("wingdi.h", MSDNShortId = "1480dea3-ae74-4e8b-b4de-fca8de5d8395")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct PIXELFORMATDESCRIPTOR
|
|
{
|
|
/// <summary>Specifies the size of this data structure. This value should be set to <c>sizeof</c>( <c>PIXELFORMATDESCRIPTOR</c>).</summary>
|
|
public ushort nSize;
|
|
|
|
/// <summary>Specifies the version of this data structure. This value should be set to 1.</summary>
|
|
public ushort nVersion;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// A set of bit flags that specify properties of the pixel buffer. The properties are generally not mutually exclusive; you can
|
|
/// set any combination of bit flags, with the exceptions noted. The following bit flag constants are defined.
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>PFD_DRAW_TO_WINDOW</term>
|
|
/// <term>The buffer can draw to a window or device surface.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_DRAW_TO_BITMAP</term>
|
|
/// <term>The buffer can draw to a memory bitmap.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_SUPPORT_GDI</term>
|
|
/// <term>The buffer supports GDI drawing. This flag and PFD_DOUBLEBUFFER are mutually exclusive in the current generic implementation.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_SUPPORT_OPENGL</term>
|
|
/// <term>The buffer supports OpenGL drawing.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_GENERIC_ACCELERATED</term>
|
|
/// <term>
|
|
/// The pixel format is supported by a device driver that accelerates the generic implementation. If this flag is clear and the
|
|
/// PFD_GENERIC_FORMAT flag is set, the pixel format is supported by the generic implementation only.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_GENERIC_FORMAT</term>
|
|
/// <term>
|
|
/// The pixel format is supported by the GDI software implementation, which is also known as the generic implementation. If this
|
|
/// bit is clear, the pixel format is supported by a device driver or hardware.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_NEED_PALETTE</term>
|
|
/// <term>
|
|
/// The buffer uses RGBA pixels on a palette-managed device. A logical palette is required to achieve the best results for this
|
|
/// pixel type. Colors in the palette should be specified according to the values of the cRedBits, cRedShift, cGreenBits,
|
|
/// cGreenShift, cBluebits, and cBlueShift members. The palette should be created and realized in the device context before
|
|
/// calling wglMakeCurrent.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_NEED_SYSTEM_PALETTE</term>
|
|
/// <term>
|
|
/// Defined in the pixel format descriptors of hardware that supports one hardware palette in 256-color mode only. For such
|
|
/// systems to use hardware acceleration, the hardware palette must be in a fixed order (for example, 3-3-2) when in RGBA mode or
|
|
/// must match the logical palette when in color-index mode.When this flag is set, you must call SetSystemPaletteUse in your
|
|
/// program to force a one-to-one mapping of the logical palette and the system palette. If your OpenGL hardware supports
|
|
/// multiple hardware palettes and the device driver can allocate spare hardware palettes for OpenGL, this flag is typically
|
|
/// clear. This flag is not set in the generic pixel formats.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_DOUBLEBUFFER</term>
|
|
/// <term>The buffer is double-buffered. This flag and PFD_SUPPORT_GDI are mutually exclusive in the current generic implementation.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_STEREO</term>
|
|
/// <term>The buffer is stereoscopic. This flag is not supported in the current generic implementation.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_SWAP_LAYER_BUFFERS</term>
|
|
/// <term>
|
|
/// Indicates whether a device can swap individual layer planes with pixel formats that include double-buffered overlay or
|
|
/// underlay planes. Otherwise all layer planes are swapped together as a group. When this flag is set, wglSwapLayerBuffers is supported.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>You can specify the following bit flags when calling ChoosePixelFormat.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>PFD_DEPTH_DONTCARE</term>
|
|
/// <term>
|
|
/// The requested pixel format can either have or not have a depth buffer. To select a pixel format without a depth buffer, you
|
|
/// must specify this flag. The requested pixel format can be with or without a depth buffer. Otherwise, only pixel formats with
|
|
/// a depth buffer are considered.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_DOUBLEBUFFER_DONTCARE</term>
|
|
/// <term>The requested pixel format can be either single- or double-buffered.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_STEREO_DONTCARE</term>
|
|
/// <term>The requested pixel format can be either monoscopic or stereoscopic.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>
|
|
/// With the <c>glAddSwapHintRectWIN</c> extension function, two new flags are included for the <c>PIXELFORMATDESCRIPTOR</c>
|
|
/// pixel format structure.
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>PFD_SWAP_COPY</term>
|
|
/// <term>
|
|
/// Specifies the content of the back buffer in the double-buffered main color plane following a buffer swap. Swapping the color
|
|
/// buffers causes the content of the back buffer to be copied to the front buffer. The content of the back buffer is not
|
|
/// affected by the swap. PFD_SWAP_COPY is a hint only and might not be provided by a driver.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_SWAP_EXCHANGE</term>
|
|
/// <term>
|
|
/// Specifies the content of the back buffer in the double-buffered main color plane following a buffer swap. Swapping the color
|
|
/// buffers causes the exchange of the back buffer's content with the front buffer's content. Following the swap, the back
|
|
/// buffer's content contains the front buffer's content before the swap. PFD_SWAP_EXCHANGE is a hint only and might not be
|
|
/// provided by a driver.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public PFD_FLAGS dwFlags;
|
|
|
|
/// <summary>
|
|
/// <para>Specifies the type of pixel data. The following types are defined.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>PFD_TYPE_RGBA</term>
|
|
/// <term>RGBA pixels. Each pixel has four components in this order: red, green, blue, and alpha.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PFD_TYPE_COLORINDEX</term>
|
|
/// <term>Color-index pixels. Each pixel uses a color-index value.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public PFD_TYPE iPixelType;
|
|
|
|
/// <summary>
|
|
/// Specifies the number of color bitplanes in each color buffer. For RGBA pixel types, it is the size of the color buffer,
|
|
/// excluding the alpha bitplanes. For color-index pixels, it is the size of the color-index buffer.
|
|
/// </summary>
|
|
public byte cColorBits;
|
|
|
|
/// <summary>Specifies the number of red bitplanes in each RGBA color buffer.</summary>
|
|
public byte cRedBits;
|
|
|
|
/// <summary>Specifies the shift count for red bitplanes in each RGBA color buffer.</summary>
|
|
public byte cRedShift;
|
|
|
|
/// <summary>Specifies the number of green bitplanes in each RGBA color buffer.</summary>
|
|
public byte cGreenBits;
|
|
|
|
/// <summary>Specifies the shift count for green bitplanes in each RGBA color buffer.</summary>
|
|
public byte cGreenShift;
|
|
|
|
/// <summary>Specifies the number of blue bitplanes in each RGBA color buffer.</summary>
|
|
public byte cBlueBits;
|
|
|
|
/// <summary>Specifies the shift count for blue bitplanes in each RGBA color buffer.</summary>
|
|
public byte cBlueShift;
|
|
|
|
/// <summary>Specifies the number of alpha bitplanes in each RGBA color buffer. Alpha bitplanes are not supported.</summary>
|
|
public byte cAlphaBits;
|
|
|
|
/// <summary>Specifies the shift count for alpha bitplanes in each RGBA color buffer. Alpha bitplanes are not supported.</summary>
|
|
public byte cAlphaShift;
|
|
|
|
/// <summary>Specifies the total number of bitplanes in the accumulation buffer.</summary>
|
|
public byte cAccumBits;
|
|
|
|
/// <summary>Specifies the number of red bitplanes in the accumulation buffer.</summary>
|
|
public byte cAccumRedBits;
|
|
|
|
/// <summary>Specifies the number of green bitplanes in the accumulation buffer.</summary>
|
|
public byte cAccumGreenBits;
|
|
|
|
/// <summary>Specifies the number of blue bitplanes in the accumulation buffer.</summary>
|
|
public byte cAccumBlueBits;
|
|
|
|
/// <summary>Specifies the number of alpha bitplanes in the accumulation buffer.</summary>
|
|
public byte cAccumAlphaBits;
|
|
|
|
/// <summary>Specifies the depth of the depth (z-axis) buffer.</summary>
|
|
public byte cDepthBits;
|
|
|
|
/// <summary>Specifies the depth of the stencil buffer.</summary>
|
|
public byte cStencilBits;
|
|
|
|
/// <summary>Specifies the number of auxiliary buffers. Auxiliary buffers are not supported.</summary>
|
|
public byte cAuxBuffers;
|
|
|
|
/// <summary>Ignored. Earlier implementations of OpenGL used this member, but it is no longer used.</summary>
|
|
public byte iLayerType;
|
|
|
|
/// <summary>
|
|
/// Specifies the number of overlay and underlay planes. Bits 0 through 3 specify up to 15 overlay planes and bits 4 through 7
|
|
/// specify up to 15 underlay planes.
|
|
/// </summary>
|
|
public byte bReserved;
|
|
|
|
/// <summary>Ignored. Earlier implementations of OpenGL used this member, but it is no longer used.</summary>
|
|
public PFD_LAYER dwLayerMask;
|
|
|
|
/// <summary>
|
|
/// Specifies the transparent color or index of an underlay plane. When the pixel type is RGBA, <c>dwVisibleMask</c> is a
|
|
/// transparent RGB color value. When the pixel type is color index, it is a transparent index value.
|
|
/// </summary>
|
|
public uint dwVisibleMask;
|
|
|
|
/// <summary>Ignored. Earlier implementations of OpenGL used this member, but it is no longer used.</summary>
|
|
public uint dwDamageMask;
|
|
}
|
|
}
|
|
} |