diff --git a/src/Generator/CodeWriter.cs b/src/Generator/CodeWriter.cs index 1b335f6..6a13a9c 100644 --- a/src/Generator/CodeWriter.cs +++ b/src/Generator/CodeWriter.cs @@ -12,10 +12,12 @@ public sealed class CodeWriter : IDisposable public int IndentLevel { get; private set; } public string Api { get; } + public string DocFileName { get; } - public CodeWriter(string fileName, string api, string ns, params string[] usingNamespaces) + public CodeWriter(string fileName, string api, string docFileName, string ns, params string[] usingNamespaces) { Api = api; + DocFileName = docFileName; _indentStrings = new string[10]; for (int i = 0; i < _indentStrings.Length; i++) diff --git a/src/Generator/Generator.csproj b/src/Generator/Generator.csproj index 597c081..9fab0c8 100644 --- a/src/Generator/Generator.csproj +++ b/src/Generator/Generator.csproj @@ -8,7 +8,9 @@ + + diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs index 889fd73..ce030d8 100644 --- a/src/Generator/Program.cs +++ b/src/Generator/Program.cs @@ -2,7 +2,12 @@ // Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. using System.Text; +using System.Text.RegularExpressions; +using System.Xml; +using MessagePack; +using Microsoft.Windows.SDK.Win32Docs; using Newtonsoft.Json; +using Newtonsoft.Json.Linq; namespace Generator; @@ -138,9 +143,211 @@ public static class Program Generate(api!, outputPath, jsonFile); } + // Generate docs + using FileStream docsStream = File.OpenRead(@"C:\Users\amerk\.nuget\packages\microsoft.windows.sdk.win32docs\0.1.8-alpha\apidocs.msgpack"); + var data = MessagePackSerializer.Deserialize>(docsStream); + var documentationData = new Dictionary(); + + string[] prefixes = new[] { "DXGI" }; + foreach (string key in data.Keys) + { + //Debug.WriteLine(key); + + foreach (string prefix in prefixes) + { + if (key.StartsWith(prefix) || key.StartsWith("I" + prefix)) + { + documentationData.Add(key, data[key]); + } + } + } + + XmlWriterSettings settings = new() + { + Indent = true, + }; + //settings.ConformanceLevel = ConformanceLevel.Fragment; + + using (var writer = XmlWriter.Create(Path.Combine(outputPath, "DXGI.xml"), settings)) + { + writer.WriteStartDocument(); + writer.WriteStartElement(null, "doc", null); + + foreach (var item in documentationData.Keys) + { + var doc = documentationData[item]; + + if (!string.IsNullOrEmpty(doc.Description) || doc.Parameters.Count > 0) + { + writer.WriteStartElement(null, "member", null); + writer.WriteAttributeString("name", item.Replace(".", "::")); + { + writer.WriteStartElement(null, "summary", null); + { + if (!string.IsNullOrEmpty(doc.Description)) + { + writer.WriteStartElement(null, "para", null); + writer.WriteRaw(FormatMd(doc.Description)); + writer.WriteEndElement(); // para + } + + if (doc.HelpLink != null) + { + writer.WriteStartElement(null, "para", null); + writer.WriteString("Microsoft Docs: "); + writer.WriteStartElement(null, "see", null); + writer.WriteAttributeString("href", doc.HelpLink.ToString()); + writer.WriteEndElement(); // see + writer.WriteEndElement(); // para + } + + // Write params + foreach (var param in doc.Parameters) + { + if (!string.IsNullOrEmpty(param.Value)) + { + writer.WriteStartElement(null, "param", null); + string paramName = param.Key; + if (paramName.StartsWith("pp") && char.IsUpper(paramName[2])) + { + paramName = paramName.Substring(2); + paramName = paramName[0].ToString().ToLower() + paramName.Substring(1); + } + else if (paramName.StartsWith("p") && char.IsUpper(paramName[1])) + { + paramName = paramName.Substring(1); + paramName = paramName[0].ToString().ToLower() + paramName.Substring(1); + } + else if (paramName.StartsWith("u") && char.IsUpper(paramName[1])) + { + paramName = paramName.Substring(1); + paramName = paramName[0].ToString().ToLower() + paramName.Substring(1); + } + else if (paramName.StartsWith("b") && char.IsUpper(paramName[1])) // bEnable + { + paramName = paramName.Substring(1); + paramName = paramName[0].ToString().ToLower() + paramName.Substring(1); + } + else if (char.IsUpper(paramName[0]) && paramName.Length > 1 && char.IsLower(paramName[1])) + { + paramName = paramName[0].ToString().ToLower() + paramName.Substring(1); + } + else if (paramName == "ID") + { + paramName = "id"; + } + else if (paramName == "dwCookie") + { + paramName = "cookie"; + } + + writer.WriteAttributeString("name", paramName); + + if (!param.Value.StartsWith("Type:")) + { + writer.WriteRaw(FormatMd(param.Value)); + } + else + { + var lines = param.Value.Split('\n'); + writer.WriteRaw(FormatMd(string.Join("\r\n", lines.Skip(2)))); + } + + writer.WriteEndElement(); // param + } + + } + } + writer.WriteEndElement(); // summary + } + writer.WriteEndElement(); // comment + } + + // Write fields + foreach (var fieldName in doc.Fields.Keys) + { + var field = doc.Fields[fieldName]; + + if (string.IsNullOrEmpty(field)) + { + continue; + } + + if (!field.StartsWith("Type:")) + { + // Enum value + writer.WriteStartElement(null, "member", null); + writer.WriteAttributeString("name", $"{item.Replace(".", "::")}::{fieldName}"); + { + writer.WriteStartElement(null, "summary", null); + { + var a = FormatMd(field); + writer.WriteRaw(FormatMd(field)); + } + writer.WriteEndElement(); // summary + } + writer.WriteEndElement(); // comment + } + else + { + // Struct field + writer.WriteStartElement(null, "member", null); + writer.WriteAttributeString("name", $"{item.Replace(".", "::")}::{fieldName}"); + { + writer.WriteStartElement(null, "summary", null); + { + var lines = field.Split('\n'); + writer.WriteRaw(FormatMd(string.Join("\r\n", lines.Skip(2)))); + } + writer.WriteEndElement(); // summary + } + writer.WriteEndElement(); // comment + } + } + } + + writer.WriteEndElement(); // comments + writer.WriteEndDocument(); + } + return 0; } + public static Regex MDLink = new(@"\[([A-z0-9<>\\]+)\]\(([^\)]+)\)"); + public static Regex ImgLink = new(@"!\[([A-z0-9<>\\]+)\]\(([^\)]+)\)"); + public static Regex Bold = new(@"\*\*([^ ^\*][^\*^\n]*)\*\*"); + public static Regex Italics = new(@"\*([^ ^\*][^\*^\n]*)\*"); + public static Regex MultilineCode = new(@"```[A-z]*([^`]+)```"); + public static Regex InlineCode = new(@"`([^`]+)`"); + + public static Regex Struct = new Regex(@"struct DML_[A-z0-9_]+_OPERATOR_DESC\r\n{[^}]+};", RegexOptions.Multiline); + + public static string FormatMd(string value) + { + value = ImgLink.Replace(value, ""); + value = MDLink.Replace(value, "$1"); + value = Bold.Replace(value, "$1"); + value = Italics.Replace(value, "$1"); + value = MultilineCode.Replace(value, "$1"); + value = InlineCode.Replace(value, "$1"); + + value = value.Replace("s", "s"); + value = value.Replace("ns-d3d12video-d3d12_video_process_luma_key\"\"", "\"ns-d3d12video-d3d12_video_process_luma_key\""); + value = value.Replace("&L", "&l"); + + value = value.Replace("& ", "& "); + value = value.Replace(" > ", " > "); + value = value.Replace(" < ", " < "); + value = value.Replace(" >= ", " >= "); + value = value.Replace(" <= ", " <= "); + value = value.Replace("<-", "<-"); + value = value.Replace("->", "->"); + value = value.Replace("\n>", "\n>"); + value = value.Replace("—", "—"); + + return value; + } + private static void Generate(ApiData api, string outputPath, string jsonFile) { string[] splits = jsonFile.Split(".", StringSplitOptions.RemoveEmptyEntries); @@ -168,6 +375,7 @@ public static class Program using var writer = new CodeWriter( Path.Combine(outputFolder, fileName), $"{folderRoot}.{ns}", + $"DXGI", $"Win32.{folderRoot}.{ns}"); GenerateConstants(writer, api); @@ -219,7 +427,7 @@ public static class Program writer.WriteLine($"#region Enums"); foreach (ApiType enumType in api.Types.Where(item => item.Kind.ToLowerInvariant() == "enum")) { - GenerateEnum(writer, enumType); + GenerateEnum(writer, enumType, false); } writer.WriteLine($"#endregion Enums"); writer.WriteLine(); @@ -271,7 +479,7 @@ public static class Program foreach (ApiType enumType in createdEnums.Values) { - GenerateEnum(writer, enumType); + GenerateEnum(writer, enumType, true); } writer.WriteLine($"#endregion Generated Enums"); @@ -286,12 +494,17 @@ public static class Program writer.WriteLine(); } - private static void GenerateEnum(CodeWriter writer, ApiType enumType) + private static void GenerateEnum(CodeWriter writer, ApiType enumType, bool autoGenerated) { string csTypeName = GetDataTypeName(enumType.Name, out string enumPrefix); string baseTypeName = GetTypeName(enumType.IntegerBase); AddCsMapping(writer.Api, enumType.Name, csTypeName); + if (!autoGenerated) + { + writer.WriteLine($"/// "); + } + if (s_generateUnmanagedDocs) writer.WriteLine($"/// {enumType.Name}"); @@ -317,6 +530,12 @@ public static class Program continue; string enumValueName = GetPrettyFieldName(value.Name, enumPrefix); + + if (!autoGenerated) + { + writer.WriteLine($"/// "); + } + if (s_generateUnmanagedDocs) { writer.WriteLine($"/// {value.Name}"); @@ -339,6 +558,8 @@ public static class Program string csTypeName = GetDataTypeName(structType.Name, out string structPrefix); AddCsMapping(writer.Api, structType.Name, csTypeName); + writer.WriteLine($"/// "); + if (s_generateUnmanagedDocs) { writer.WriteLine($"/// {structType.Name}"); @@ -353,6 +574,9 @@ public static class Program string fieldValueName = GetPrettyFieldName(field.Name, structPrefix); string fieldTypeName = GetTypeName(field.Type); + + writer.WriteLine($"/// "); + if (s_generateUnmanagedDocs) { //writer.WriteLine($"/// {field.Name}"); diff --git a/src/Vortice.Win32/Generated/DXGI.xml b/src/Vortice.Win32/Generated/DXGI.xml new file mode 100644 index 0000000..f825eed --- /dev/null +++ b/src/Vortice.Win32/Generated/DXGI.xml @@ -0,0 +1,4764 @@ + + + + + Identifies resize behavior when the back-buffer size does not match the size of the target output. + Microsoft Docs: + + + + Directs DXGI to make the back-buffer contents scale to fit the presentation target size. This is the implicit behavior of DXGI when you call the IDXGIFactory::CreateSwapChain method. + + + Directs DXGI to make the back-buffer contents appear without any scaling when the presentation target size is not equal to the back-buffer size. The top edges of the back buffer and presentation target are aligned together. If the WS_EX_LAYOUTRTL style is associated with the HWND handle to the target output window, the right edges of the back buffer and presentation target are aligned together; otherwise, the left edges are aligned together. All target area outside the back buffer is filled with window background color. + +This value specifies that all target areas outside the back buffer of a swap chain are filled with the background color that you specify in a call to IDXGISwapChain1::SetBackgroundColor. + + + Directs DXGI to make the back-buffer contents scale to fit the presentation target size, while preserving the aspect ratio of the back-buffer. If the scaled back-buffer does not fill the presentation area, it will be centered with black borders. + +This constant is supported on Windows Phone 8 and Windows 10. + +Note that with legacy Win32 window swapchains, this works the same as DXGI_SCALING_STRETCH. + + + + Represents a 3x2 matrix. Used with GetMatrixTransform and SetMatrixTransform to indicate the scaling and translation transform for SwapChainPanel swap chains. + Microsoft Docs: + + + + The value in the first row and first column of the matrix. + + + The value in the first row and second column of the matrix. + + + The value in the second row and first column of the matrix. + + + The value in the second row and second column of the matrix. + + + The value in the third row and first column of the matrix. + + + The value in the third row and second column of the matrix. + + + + Identifies the adapter on which a shared resource object was created. + Microsoft Docs: + A handle to a shared resource object. The IDXGIResource1::CreateSharedHandle method returns this handle. + A pointer to a variable that receives a locally unique identifier (LUID) value that identifies the adapter. LUID is defined in Dxgi.h. An LUID is a 64-bit value that is guaranteed to be unique only on the operating system on which it was generated. The uniqueness of an LUID is guaranteed only until the operating system is restarted. + + + + + An IDXGIResource interface allows resource sharing and identifies the memory that a resource resides in. + Microsoft Docs: + + + + + Indicates options for presenting frames to the swap chain. + Microsoft Docs: + + + + Specifies that the presentation mode is a composition surface, meaning that the conversion from YUV to RGB is happening once per output refresh (for example, 60 Hz). + When this value is returned, the media app should discontinue use of the decode swap chain and perform YUV to RGB conversion itself, reducing the frequency of YUV to RGB conversion to once per video frame. + + + Specifies that the presentation mode is an overlay surface, meaning that the YUV to RGB conversion is happening efficiently in hardware (once per video frame). + When this value is returned, the media app can continue to use the decode swap chain. + See IDXGIDecodeSwapChain. + + + No presentation is specified. + + + An issue occurred that caused content protection to be invalidated in a swap-chain with hardware content protection, and is usually because the system ran out of hardware protected memory. The app will need to do one of the following: + +
    +
  • Drastically reduce the amount of hardware protected memory used. For example, media applications might be able to reduce their buffering. +
    • +
  • Stop using hardware protection if possible.
    • +
+Note that simply re-creating the swap chain or the device will usually have no impact as the DWM will continue to run out of memory and will return the same failure. + + + + The eviction priority of the resource is high. The resource is placed in its preferred location instead of a low-priority or normal-priority resource. + Microsoft Docs: + + + + + Retrieves a debugging interface. + Microsoft Docs: + The globally unique identifier (GUID) of the requested interface type. + A pointer to a buffer that receives a pointer to the debugging interface. + + + + + Values that specify categories of debug messages. + Microsoft Docs: + + + + Unknown category. + + + Miscellaneous category. + + + Initialization category. + + + Cleanup category. + + + Compilation category. + + + State creation category. + + + State setting category. + + + State getting category. + + + Resource manipulation category. + + + Execution category. + + + Shader category. + + + + Outputs the IDXGIAdapter for the specified LUID. + Microsoft Docs: + A unique value that identifies the adapter. + See LUID for a definition of the structure. + LUID is defined in dxgi.h. + The globally unique identifier (GUID) of the IDXGIAdapter object referenced by the ppvAdapter parameter. + The address of an IDXGIAdapter interface pointer to the adapter. + This parameter must not be NULL. + + + + + The DXGI_OUTDUPL_MOVE_RECT structure describes the movement of a rectangle. + Microsoft Docs: + + + + The starting position of a rectangle. + + + The target region to which to move a rectangle. + + + + Gets the output (the display monitor) to which you can restrict the contents of a present operation. + Microsoft Docs: + A pointer to a buffer that receives a pointer to the IDXGIOutput interface for the restrict-to output. An application passes this pointer to IDXGIOutput in a call to the IDXGIFactory2::CreateSwapChainForHwnd, IDXGIFactory2::CreateSwapChainForCoreWindow, or IDXGIFactory2::CreateSwapChainForComposition method to create the swap chain. + + + + + Extends IDXGISwapChain1 with methods to support swap back buffer scaling and lower-latency swap chains. + Microsoft Docs: + + + + + Pushes a deny-all storage filter onto the storage-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pushes the filter. + + + + + Gets the source region that is used for the swap chain. + Microsoft Docs: + A pointer to a RECT structure + that receives the source region for the swap chain. + + + + + Set an interface in the object's private data. + Microsoft Docs: + A GUID identifying the interface. + The interface to set. + + + + + Provides an adapter which can be provided to D3D12CreateDevice to use the WARP renderer. + Microsoft Docs: + The globally unique identifier (GUID) of the IDXGIAdapter object referenced by the ppvAdapter parameter. + The address of an IDXGIAdapter interface pointer to the adapter. + This parameter must not be NULL. + + + + + Describes a debug message filter, which contains lists of message types to allow and deny. + Microsoft Docs: + + + + A DXGI_INFO_QUEUE_FILTER_DESC structure that describes the types of messages to allow. + + + A DXGI_INFO_QUEUE_FILTER_DESC structure that describes the types of messages to deny. + + + + Sets the rotation of the back buffers for the swap chain. + Microsoft Docs: + A DXGI_MODE_ROTATION-typed value that specifies how to set the rotation of the back buffers for the swap chain. + + + + + Describes which levels of hardware composition are supported. + Microsoft Docs: + + + + This flag specifies that swapchain composition can be facilitated in a performant manner using hardware for fullscreen applications. + + + This flag specifies that swapchain composition can be facilitated in a performant manner using hardware for windowed applications. + + + This flag specifies that swapchain composition facilitated using hardware can cause the cursor to appear stretched. + + + + Adds a debug message to the message queue and sends that message to the debug output. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that produced the message. + A DXGI_INFO_QUEUE_MESSAGE_CATEGORY-typed value that specifies the category of the message. + A DXGI_INFO_QUEUE_MESSAGE_SEVERITY-typed value that specifies the severity of the message. + An integer that uniquely identifies the message. + The message string. + + + + + This interface represents a display subsystem, and extends this family of interfaces to expose a method to check for an adapter's compatibility with Arbitrary Code Guard (ACG). + Microsoft Docs: + + + + + Pops a storage filter from the top of the storage-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pops the filter. + + + + + Gets a message from the message queue. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the message. + An index into the message queue after an optional retrieval filter has been applied. This can be between 0 and the number of messages in the message queue that pass through the retrieval filter. Call IDXGIInfoQueue::GetNumStoredMessagesAllowedByRetrievalFilters to obtain this number. 0 is the message at the beginning of the message queue. + A pointer to a DXGI_INFO_QUEUE_MESSAGE structure that describes the message. + A pointer to a variable that receives the size, in bytes, of the message description that pMessage points to. This size includes the size of the DXGI_INFO_QUEUE_MESSAGE structure in bytes. + + + + + Gets the display modes that match the requested format and other input options. + Microsoft Docs: + A DXGI_FORMAT-typed value for the color format. + A combination of DXGI_ENUM_MODES-typed values that are combined by using a bitwise OR operation. The resulting value specifies options for display modes to include. You must specify DXGI_ENUM_MODES_SCALING to expose the display modes that require scaling. Centered modes that require no + scaling and correspond directly to the display output are enumerated by default. + A pointer to a variable that receives the number of display modes that GetDisplayModeList1 returns in the memory block to which pDesc points. Set pDesc to NULL so that pNumModes returns the number of display modes that match the format and the options. + Otherwise, pNumModes returns the number of display modes returned in pDesc. + A pointer to a list of display modes; set to NULL to get the number of display modes. + + + + + Sets the number of frames that the system is allowed to queue for rendering. + Microsoft Docs: + The maximum number of back buffer frames that a driver can queue. The value defaults to 3, but + can range from 1 to 16. A value of 0 will reset latency to the default. For multi-head devices, this value is specified per-head. + + + + + The color channels contain values that are premultiplied with the alpha channel. + Microsoft Docs: + + + + + Sets the size of the destination surface to use for the video processing blit operation. + Microsoft Docs: + The width of the destination size, in pixels. + The height of the destination size, in pixels. + + + + + Gets the number of messages that were denied passage through a storage filter. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the number. + + + + + Pushes a deny-all retrieval filter onto the retrieval-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pushes the deny-all retrieval filter. + + + + + An IDXGIObject interface is a base interface for all DXGI objects; IDXGIObject supports associating caller-defined (private data) with an object and retrieval of an interface to the parent object. + Microsoft Docs: + + + + + This interface enables a single method that enumerates graphics adapters based on a given GPU preference. + Microsoft Docs: + + + + + Finds the display mode that most closely matches the requested display mode. + Microsoft Docs: + A pointer to the DXGI_MODE_DESC1 structure that describes the display mode to match. Members of DXGI_MODE_DESC1 can be unspecified, which indicates no preference for + that member. A value of 0 for Width or Height indicates that the value is unspecified. If either Width or + Height is 0, both must be 0. A numerator and denominator of 0 in RefreshRate indicate it is unspecified. Other members + of DXGI_MODE_DESC1 have enumeration values that indicate that the member is unspecified. If pConcernedDevice is NULL, the Formatmember of DXGI_MODE_DESC1 cannot be DXGI_FORMAT_UNKNOWN. + A pointer to the DXGI_MODE_DESC1 structure that receives a description of the display mode that most closely matches the display mode described at pModeToMatch. + A pointer to the Direct3D device interface. If this parameter is NULL, FindClosestMatchingMode1 returns only modes whose format matches that of pModeToMatch; otherwise, FindClosestMatchingMode1 returns only those formats that are supported for scan-out by the device. For info about the formats that are supported for scan-out by the device at each feature level: + + + + + + + Unregisters a window or an event to stop it from receiving notification when occlusion status changes. + Microsoft Docs: + A key value for the window or event to unregister. The IDXGIFactory2::RegisterOcclusionStatusWindow or IDXGIFactory2::RegisterOcclusionStatusEvent method returns this value. + + + + + The resource is evicted from memory only if there is no other way of resolving the memory requirement. + Microsoft Docs: + + + + + The IDXGIDevice2 interface implements a derived class for DXGI objects that produce image data. The interface exposes methods to block CPU processing until the GPU completes processing, and to offer resources to the operating system. + Microsoft Docs: + + + + + Pushes a copy of the retrieval filter that is currently on the top of the retrieval-filter stack onto the retrieval-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pushes the copy of the retrieval filter. + + + + + Unregisters a window or an event to stop it from receiving notification when stereo status changes. + Microsoft Docs: + A key value for the window or event to unregister. The IDXGIFactory2::RegisterStereoStatusWindow or IDXGIFactory2::RegisterStereoStatusEvent method returns this value. + + + + + Notifies applications that hardware stretching is supported. + Microsoft Docs: + A bitfield of DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAGS enumeration values describing which types of hardware composition are supported. The values are bitwise OR'd together. + + + + + Create an adapter interface that represents a software adapter. + Microsoft Docs: + Handle to the software adapter's dll. HMODULE can be obtained with GetModuleHandle or LoadLibrary. + Address of a pointer to an adapter (see IDXGIAdapter). + + + + + Unregisters an event to stop it from receiving notification of hardware content protection teardown events. + Microsoft Docs: + A key value for the window or event to unregister. The IDXGIAdapter3::RegisterHardwareContentProtectionTeardownStatusEvent method returns this value. + + + + + Get the state associated with full-screen mode. + Microsoft Docs: + A pointer to a boolean whose value is either: + + +
    +
  • TRUE if the swap chain is in full-screen mode
    • +
  • FALSE if the swap chain is in windowed mode
    • +
+ A pointer to the output target (see IDXGIOutput) when the mode is full screen; otherwise NULL. + + + + + Informs an application of the possible need to re-enumerate adapters. + Microsoft Docs: + + + + + Describes multi-sampling parameters for a resource. + Microsoft Docs: + + + + The number of multisamples per pixel. + + + The image quality level. The higher the quality, the lower the performance. The valid range is between zero and one less than the level returned + by ID3D10Device::CheckMultisampleQualityLevels for Direct3D 10 or ID3D11Device::CheckMultisampleQualityLevels for Direct3D 11. + +For Direct3D 10.1 and Direct3D 11, you can use two special quality level values. For more information about these quality level values, see Remarks. + + + + Don't use this structure; it is not supported and it will be removed from the header in a future release. + Microsoft Docs: + + + + The primary coordinates, as an 8 by 2 array of FLOAT values. + + + The white points, as a 16 by 2 array of FLOAT values. + + + + Allows the operating system to free the video memory of resources by discarding their content. + Microsoft Docs: + The number of resources in the ppResources argument array. + An array of pointers to IDXGIResource interfaces for the resources to offer. + A DXGI_OFFER_RESOURCE_PRIORITY-typed value that indicates how valuable data is. + + + + + Extends IDXGISwapChain2 with methods to support getting the index of the swap chain's current back buffer and support for color space. + Microsoft Docs: + + + + + Sets the gamma controls. + Microsoft Docs: + A pointer to a DXGI_GAMMA_CONTROL structure that describes the gamma curve to set. + + + + + This method sets High Dynamic Range (HDR) and Wide Color Gamut (WCG) header metadata. + Microsoft Docs: + Specifies one member of the DXGI_HDR_METADATA_TYPE enum. + Specifies the size of pMetaData, in bytes. + Specifies a void pointer that references the metadata, if it exists. Refer to the DXGI_HDR_METADATA_HDR10 structure. + + + + + Describes a mapped rectangle that is used to access a surface. + Microsoft Docs: + + + + A value that describes the width, in bytes, of the surface. + + + A pointer to the image buffer of the surface. + + + + Gets the storage filter at the top of the storage-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the filter. + A pointer to a DXGI_INFO_QUEUE_FILTER structure that describes the filter. + A pointer to a variable that receives the size, in bytes, of the filter description to which pFilter points. If pFilter is NULL, GetStorageFilter outputs the size of the storage filter. + + + + + The IDXGIDevice3 interface implements a derived class for DXGI objects that produce image data. The interface exposes a method to trim graphics memory usage by the DXGI device. + Microsoft Docs: + + + + + An IDXGIDevice interface implements a derived class for DXGI objects that produce image data. + Microsoft Docs: + + + + + Gets a DXGI 1.0 description of an adapter (or video card). + Microsoft Docs: + A pointer to a DXGI_ADAPTER_DESC structure that describes the adapter. This parameter must not be NULL. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID in the VendorId, DeviceId, SubSysId, and Revision members of DXGI_ADAPTER_DESC and “Software Adapter” for the description string in the Description member. + + + + + Gets the retrieval filter at the top of the retrieval-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the filter. + A pointer to a DXGI_INFO_QUEUE_FILTER structure that describes the filter. + A pointer to a variable that receives the size, in bytes, of the filter description to which pFilter points. If pFilter is NULL, GetRetrievalFilter outputs the size of the retrieval filter. + + + + + Sets the display state to windowed or full screen. + Microsoft Docs: + A Boolean value that specifies whether to set the display state to windowed or full screen. TRUE for full screen, and FALSE for windowed. + If you pass TRUE to the Fullscreen parameter to set the display state to full screen, you can optionally set this parameter to a pointer to an IDXGIOutput interface for the output target that contains the swap chain. If you set this parameter to NULL, DXGI will choose the output based on the swap-chain's device and the output window's placement. If you pass FALSE to Fullscreen, then you must set this parameter to NULL. + + + + + Pushes a retrieval filter onto the retrieval-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pushes the filter. + A pointer to a DXGI_INFO_QUEUE_FILTER structure that describes the filter. + + + + + Adds retrieval filters to the top of the retrieval-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that produced the filters. + An array of DXGI_INFO_QUEUE_FILTER structures that describe the filters. + + + + + Retrieves the underlying CoreWindow object for this swap-chain object. + Microsoft Docs: + A pointer to the globally unique identifier (GUID) of the CoreWindow object that is referenced by + the ppUnk parameter. + A pointer to a variable that receives a pointer to the CoreWindow object. + + + + + Allows the operating system to free the video memory of resources, including both discarding the content and de-committing the memory. + Microsoft Docs: + The number of resources in the ppResources argument array. + An array of pointers to IDXGIResource interfaces for the resources to offer. + A DXGI_OFFER_RESOURCE_PRIORITY-typed value that indicates how valuable data is. + Specifies the DXGI_OFFER_RESOURCE_FLAGS. + + + + + This interface provides updated methods to offer and reclaim resources. + Microsoft Docs: + + + + + Creates a swap chain that is associated with an HWND handle to the output window for the swap chain. + Microsoft Docs: + For Direct3D 11, and earlier versions of Direct3D, this is a pointer to the Direct3D device for the swap chain. For Direct3D 12 this is a pointer to a direct command queue (refer to ID3D12CommandQueue). This parameter cannot be NULL. + The HWND handle that is associated with the swap chain that CreateSwapChainForHwnd creates. This parameter cannot be NULL. + A pointer to a DXGI_SWAP_CHAIN_DESC1 structure for the swap-chain description. This parameter cannot be NULL. + A pointer to a DXGI_SWAP_CHAIN_FULLSCREEN_DESC structure for the description of a full-screen swap chain. You can optionally set this parameter to create a full-screen swap chain. Set it to NULL to create a windowed swap chain. + A pointer to the IDXGIOutput interface for the output to restrict content to. You must also pass the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag in a IDXGISwapChain1::Present1 call to force the content to appear blacked out on any other output. If you want to restrict the content to a different output, you must create a new swap chain. However, you can conditionally restrict content based on the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag. + + +Set this parameter to NULL if you don't want to restrict content to an output target. + A pointer to a variable that receives a pointer to the IDXGISwapChain1 interface for the swap chain that CreateSwapChainForHwnd creates. + + + + + Inherited from objects that are tied to the device so that they can retrieve a pointer to it. + Microsoft Docs: + + + + + Sets the color space used by the swap chain. + Microsoft Docs: + A pointer to a combination of DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAGS-typed values that are combined by using a bitwise OR operation. The resulting value specifies the color space to set for the swap chain. + + + + + Sets the rectangle that defines the source region for the video processing blit operation. + Microsoft Docs: + A pointer to a RECT structure + that contains the source region to set for the swap chain. + + + + + Finds the display mode that most closely matches the requested display mode. + Microsoft Docs: + The desired display mode (see DXGI_MODE_DESC). Members of DXGI_MODE_DESC can be unspecified indicating no preference for + that member. A value of 0 for Width or Height indicates the value is unspecified. If either Width or + Height are 0, both must be 0. A numerator and denominator of 0 in RefreshRate indicate it is unspecified. Other members + of DXGI_MODE_DESC have enumeration values indicating the member is unspecified. If pConcernedDevice is NULL, Formatcannot be DXGI_FORMAT_UNKNOWN. + The mode that most closely matches pModeToMatch. + A pointer to the Direct3D device interface. If this parameter is NULL, only modes whose format matches that of pModeToMatch will + be returned; otherwise, only those formats that are supported for scan-out by the device are returned. For info about the formats that are supported for scan-out by the device at each feature level: + + + + + + + Represents an adapter output (such as a monitor). The IDXGIOutput6 interface exposes methods to provide specific monitor capabilities. + Microsoft Docs: + + + + + Checks whether the system supports a device interface for a graphics component. + Microsoft Docs: + The GUID of the interface of the device version for which support is being checked. This should usually be __uuidof(IDXGIDevice), which returns the version number of the Direct3D 9 UMD (user mode driver) binary. Since WDDM 2.3, all driver components within a driver package (D3D9, D3D11, and D3D12) have been required to share a single version number, so this is a good way to query the driver version regardless of which API is being used. + The user mode driver version of InterfaceName. This is returned only if the interface is supported, otherwise this parameter will be NULL. + + + + + Retrieves the underlying HWND for this swap-chain object. + Microsoft Docs: + A pointer to a variable that receives the HWND for the swap-chain object. + + + + + Sets a message category to break on when a message with that category passes through the storage filter. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that sets the breaking condition. + A DXGI_INFO_QUEUE_MESSAGE_CATEGORY-typed value that specifies the category of the message. + A Boolean value that specifies whether SetBreakOnCategory turns on or off this breaking condition (TRUE for on, FALSE for off). + + + + + The IDXGISurface2 interface extends the IDXGISurface1 interface by adding support for subresource surfaces and getting a handle to a shared resource. + Microsoft Docs: + + + + + Identifies the type of DXGI adapter. + Microsoft Docs: + + + + Specifies no flags. + + + Value always set to 0. This flag is reserved. + + + Specifies a software adapter. For more info about this flag, see new info in Windows 8 about enumerating adapters. + +Direct3D 11:  This enumeration value is supported starting with Windows 8. + + + Forces this enumeration to compile to 32 bits in size. Without this value, some compilers would allow this enumeration to compile + to a size other than 32 bits. This value is not used. + + + + Get a pointer to the object's data. + Microsoft Docs: + A GUID identifying the data. + The size of the data. + Pointer to the data. + + + + + Enables creating Microsoft DirectX Graphics Infrastructure (DXGI) objects. + Microsoft Docs: + + + + + Checks the swap chain's support for color space. + Microsoft Docs: + A DXGI_COLOR_SPACE_TYPE-typed value that specifies color space type to check support for. + A pointer to a variable that receives a combination of DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG-typed values that are combined by using a bitwise OR operation. The resulting value specifies options for color space support. + + + + + Gets the number of messages currently stored in the message queue. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the number. + + + + + An IDXGIFactory interface implements methods for generating DXGI objects (which handle full screen transitions). + Microsoft Docs: + + + + + Describes the current video memory budgeting parameters. + Microsoft Docs: + + + + Specifies the OS-provided video memory budget, in bytes, that the application should target. If CurrentUsage is greater than Budget, the application may incur stuttering or performance penalties due to background activity by the OS to provide other applications with a fair usage of video memory. + + + Specifies the application’s current video memory usage, in bytes. + + + The amount of video memory, in bytes, that the application has available for reservation. To reserve this video memory, the application should call IDXGIAdapter3::SetVideoMemoryReservation. + + + The amount of video memory, in bytes, that is reserved by the application. The OS uses the reservation as a hint to determine the application’s minimum working set. Applications should attempt to ensure that their video memory usage can be trimmed to meet this requirement. + + + + Get an extended description of the output that includes color characteristics and connection type. + Microsoft Docs: + A pointer to the output description (see DXGI_OUTPUT_DESC1). + + + + + Registers to receive notification of changes in occlusion status by using event signaling. + Microsoft Docs: + A handle to the event object that the operating system sets when notification of occlusion status change occurs. The CreateEvent or OpenEvent function returns this handle. + A pointer to a key value that an application can pass to the IDXGIFactory2::UnregisterOcclusionStatus method to unregister the notification event that hEvent specifies. + + + + + Represents a swap chain that is used by desktop media apps to decode video data and show it on a DirectComposition surface. + Microsoft Docs: + + + + + Creates a swap chain that is associated with the CoreWindow object for the output window for the swap chain. + Microsoft Docs: + For Direct3D 11, and earlier versions of Direct3D, this is a pointer to the Direct3D device for the swap chain. For Direct3D 12 this is a pointer to a direct command queue (refer to ID3D12CommandQueue). This parameter cannot be NULL. + A pointer to the CoreWindow object that is associated with the swap chain that CreateSwapChainForCoreWindow creates. + A pointer to a DXGI_SWAP_CHAIN_DESC1 structure for the swap-chain description. This parameter cannot be NULL. + A pointer to the IDXGIOutput interface that the swap chain is restricted to. If the swap chain is moved to a different output, the content is black. You can optionally set this parameter to an output target that uses DXGI_PRESENT_RESTRICT_TO_OUTPUT to restrict the content on this output. If you do not set this parameter to restrict content on an output target, you can set it to NULL. + A pointer to a variable that receives a pointer to the IDXGISwapChain1 interface for the swap chain that CreateSwapChainForCoreWindow creates. + + + + + Gets the parent resource and subresource index that support a subresource surface. + Microsoft Docs: + The globally unique identifier (GUID) of the requested interface type. + A pointer to a buffer that receives a pointer to the parent resource object for the subresource surface. + A pointer to a variable that receives the index of the subresource surface. + + + + + This method establishes a correlation between a CPU synchronization object and the budget change event. + Microsoft Docs: + Specifies a HANDLE for the event. + A key value for the window or event to unregister. The IDXGIAdapter3::RegisterHardwareContentProtectionTeardownStatusEvent method returns this value. + + + + + Sets a message identifier to break on when a message with that identifier passes through the storage filter. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that sets the breaking condition. + An integer value that specifies the identifier of the message. + A Boolean value that specifies whether SetBreakOnID turns on or off this breaking condition (TRUE for on, FALSE for off). + + + + + Gets a value indicating whether leak tracking is turned on for the current thread. + Microsoft Docs: + + + + + Creates a swap chain that you can use to send Direct3D content into the DirectComposition API or the Windows.UI.Xaml framework to compose in a window. + Microsoft Docs: + For Direct3D 11, and earlier versions of Direct3D, this is a pointer to the Direct3D device for the swap chain. For Direct3D 12 this is a pointer to a direct command queue (refer to ID3D12CommandQueue). This parameter cannot be NULL. Software drivers, like D3D_DRIVER_TYPE_REFERENCE, are not supported for composition swap chains. + A pointer to a DXGI_SWAP_CHAIN_DESC1 structure for the swap-chain description. This parameter cannot be NULL. + +You must specify the DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL value in the SwapEffect member of DXGI_SWAP_CHAIN_DESC1 because CreateSwapChainForComposition supports only flip presentation model. + +You must also specify the DXGI_SCALING_STRETCH value in the Scaling member of DXGI_SWAP_CHAIN_DESC1. + A pointer to the IDXGIOutput interface for the output to restrict content to. You must also pass the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag in a IDXGISwapChain1::Present1 call to force the content to appear blacked out on any other output. If you want to restrict the content to a different output, you must create a new swap chain. However, you can conditionally restrict content based on the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag. + + +Set this parameter to NULL if you don't want to restrict content to an output target. + A pointer to a variable that receives a pointer to the IDXGISwapChain1 interface for the swap chain that CreateSwapChainForComposition creates. + + + + + Gets the number of messages that a storage filter allowed to pass through. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the number. + + + + + Indicates that the application finished processing the frame. + Microsoft Docs: + + + + + Retrieves the device. + Microsoft Docs: + The reference id for the device. + The address of a pointer to the device. + + + + + Set a Boolean value to either enable or disable the operating system's stereoscopic 3D display behavior. + Microsoft Docs: + A Boolean value that either enables or disables the operating system's stereoscopic 3D display behavior. TRUE enables the operating system's stereoscopic 3D display behavior and FALSE disables it. + + + + + Creates a YUV swap chain for an existing DirectComposition surface handle. + Microsoft Docs: + A pointer to the Direct3D device for the swap chain. This parameter cannot be NULL. Software drivers, like D3D_DRIVER_TYPE_REFERENCE, are not supported for composition swap chains. + A handle to an existing DirectComposition surface. This parameter cannot be NULL. + A pointer to a DXGI_SWAP_CHAIN_DESC1 structure for the swap-chain description. This parameter cannot be NULL. + A pointer to the IDXGIOutput interface for the swap chain to restrict content to. If the swap chain is moved to a different output, the content is black. You can optionally set this parameter to an output target that uses DXGI_PRESENT_RESTRICT_TO_OUTPUT to restrict the content on this output. If the swap chain is moved to a different output, the content is black. + +You must also pass the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag in a present call to force the content to appear blacked out on any other output. If you want to restrict the content to a different output, you must create a new swap chain. However, you can conditionally restrict content based on the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag. + +Set this parameter to NULL if you don't want to restrict content to an output target. + A pointer to a variable that receives a pointer to the IDXGISwapChain1 interface for the swap chain that this method creates. + + + + + Used to verify system approval for the app's custom present duration (custom refresh rate). + Microsoft Docs: + + + + A value that represents the running total count of times that an image was presented to the monitor since the computer booted. + +
Note  The number of times that an image was presented to the monitor is not necessarily the same as the number of times + that you called IDXGISwapChain::Present or IDXGISwapChain1::Present1.
+
 
 + + + A value that represents the running total count of v-blanks at which the last image was presented to the monitor and that have happened since the computer booted (for windowed mode, since the swap chain was created). + + + A value that represents the running total count of v-blanks when the scheduler last sampled the machine time by calling QueryPerformanceCounter and that have happened since the computer booted (for windowed mode, since the swap chain was created). + + + A value that represents the high-resolution performance counter timer. + This value is the same as the value returned by the QueryPerformanceCounter + function. + + + Reserved. Always returns 0. + + + A value indicating the composition presentation mode. This value is used to determine whether the app should continue to use the decode swap chain. See DXGI_FRAME_PRESENTATION_MODE. + + + If the system approves an app's custom present duration request, this field is set to the approved custom present duration. + +If the app's custom present duration request is not approved, this field is set to zero. + + + + Identifies the type of DXGI adapter. + Microsoft Docs: + + + + Specifies no flags. + + + Value always set to 0. This flag is reserved. + + + Specifies a software adapter. For more info about this flag, see new info in Windows 8 about enumerating adapters. + +Direct3D 11:  This enumeration value is supported starting with Windows 8. + + + Specifies that the adapter's driver has been confirmed to work in an OS process where Arbitrary Code Guard (ACG) is enabled (i.e. dynamic code generation is disallowed). + + + Specifies that the adapter supports monitored fences. These adapters support the ID3D12Device::CreateFence and ID3D11Device5::CreateFence functions. + + + Specifies that the adapter supports non-monitored fences. These adapters support the ID3D12Device::CreateFence function together with the D3D12_FENCE_FLAG_NON_MONITORED flag. + +
Note  For adapters that support both monitored and non-monitored fences, non-monitored fences are only supported when created with the D3D12_FENCE_FLAG_SHARED and D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER flags. Monitored fences should always be used by supporting adapters unless communicating with an adapter that only supports non-monitored fences.
+
 
 + + + Specifies that the adapter claims keyed mutex conformance. This signals a stronger guarantee that the IDXGIKeyedMutex interface behaves correctly. + + + Forces this enumeration to compile to 32 bits in size. Without this value, some compilers would allow this enumeration to compile to a size other than 32 bits. This value is not used. + + + + Takes ownership of an output. + Microsoft Docs: + A pointer to the IUnknown interface of a device (such as an ID3D10Device). + Set to TRUE to enable other threads or applications to take ownership of the device; otherwise, set to FALSE. + + + + + Accesses one of the swap-chain's back buffers. + Microsoft Docs: + A zero-based buffer index. + +If the swap chain's swap effect is DXGI_SWAP_EFFECT_DISCARD, this method can only access the first buffer; for this situation, set the index to zero. + +If the swap chain's swap effect is either DXGI_SWAP_EFFECT_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, only the swap chain's zero-index buffer can be read from and written to. The swap chain's buffers with indexes greater than zero can only be read from; so if you call the IDXGIResource::GetUsage method for such buffers, they have the DXGI_USAGE_READ_ONLY flag set. + The type of interface used to manipulate the buffer. + A pointer to a back-buffer interface. + + + + + Enumerate adapter (video card) outputs. + Microsoft Docs: + The index of the output. + The address of a pointer to an IDXGIOutput interface at the position specified by the Output parameter. + + + + + Requests a custom presentation duration (custom refresh rate). + Microsoft Docs: + The custom presentation duration, specified in hundreds of nanoseconds. + + + + + Reports info about the lifetime of an object or objects. + Microsoft Docs: + The globally unique identifier (GUID) of the object or objects to get info about. Use one of the DXGI_DEBUG_ID GUIDs. + A DXGI_DEBUG_RLO_FLAGS-typed value that specifies the amount of info to report. + + + + + Gets the transform matrix that will be applied to a composition swap chain upon the next present. + Microsoft Docs: + [out] + +The transform matrix currently used for swap chain scaling and translation. + + + + + Gets the number of times that IDXGISwapChain::Present or IDXGISwapChain1::Present1 has been called. + Microsoft Docs: + A pointer to a variable that receives the number of calls. + + + + + Returns a waitable handle that signals when the DXGI adapter has finished presenting a new frame. + Microsoft Docs: + + + + + Enumerates graphics adapters based on a given GPU preference. + Microsoft Docs: + The index of the adapter to enumerate. The indices are in order of the preference specified in GpuPreference—for example, if DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE is specified, then the highest-performing adapter is at index 0, the second-highest is at index 1, and so on. + The GPU preference for the app. + The globally unique identifier (GUID) of the IDXGIAdapter object referenced by the ppvAdapter parameter. + The address of an IDXGIAdapter interface pointer to the adapter. + +This parameter must not be NULL. + + + + + Determines whether to use stereo mode. + Microsoft Docs: + + + + + Queries the system for a DXGI_FRAME_STATISTICS_MEDIA structure that indicates whether a custom refresh rate is currently approved by the system. + Microsoft Docs: + A DXGI_FRAME_STATISTICS_MEDIA structure indicating whether the system currently approves the custom refresh rate request. + + + + + Get the output (the display monitor) that contains the majority of the client area of the target window. + Microsoft Docs: + A pointer to the output interface (see IDXGIOutput). + + + + + Flags indicating the memory location of a resource. + Microsoft Docs: + + + + The resource is located in video memory. + + + At least some of the resource is located in CPU memory. + + + At least some of the resource has been paged out to the hard drive. + + + + Gets information about the new pointer shape for the current desktop frame. + Microsoft Docs: + The size in bytes of the buffer that the caller passed to the pPointerShapeBuffer parameter. + A pointer to a buffer to which GetFramePointerShape copies and returns pixel data for the new pointer shape. + Pointer to a variable that receives the number of bytes that GetFramePointerShape needs to store the new pointer shape pixel data in the buffer at pPointerShapeBuffer. + +For more information about returning the required buffer size, see Remarks. + Pointer to a DXGI_OUTDUPL_POINTER_SHAPE_INFO structure that receives the pointer shape information. + + + + + An IDXGIOutput interface represents an adapter output (such as a monitor). + Microsoft Docs: + + + + + Creates a swap chain. + Microsoft Docs: + For Direct3D 11, and earlier versions of Direct3D, this is a pointer to the Direct3D device for the swap chain. For Direct3D 12 this is a pointer to a direct command queue (refer to ID3D12CommandQueue) . This parameter cannot be NULL. + A pointer to a DXGI_SWAP_CHAIN_DESC structure for the swap-chain description. This parameter cannot be NULL. + A pointer to a variable that receives a pointer to the IDXGISwapChain interface for the swap chain that CreateSwapChain creates. + + + + + Gets performance statistics about the last render frame. + Microsoft Docs: + A pointer to a DXGI_FRAME_STATISTICS structure for the frame statistics. + + + + + The IDXGIFactory2 interface includes methods to create a newer version swap chain with more features than IDXGISwapChain and to monitor stereoscopic 3D capabilities. + Microsoft Docs: + + + + + Identifies the alpha value, transparency behavior, of a surface. + Microsoft Docs: + + + + Indicates that the transparency behavior is not specified. + + + Indicates that the transparency behavior is premultiplied. Each color is first scaled by the alpha value. The alpha value itself is the same in both straight and premultiplied alpha. Typically, no color channel value is greater than the alpha channel value. If a color channel value in a premultiplied format is greater than the alpha channel, the standard source-over blending math results in an additive blend. + + + Indicates that the transparency behavior is not premultiplied. The alpha channel indicates the transparency of the color. + + + Indicates to ignore the transparency behavior. + + + Forces this enumeration to compile to 32 bits in size. Without this value, some compilers would allow this enumeration to compile + to a size other than 32 bits. This value is not used. + + + + Describes a surface. + Microsoft Docs: + + + + A value describing the surface width. + + + A value describing the surface height. + + + A member of the DXGI_FORMAT enumerated type that describes the surface format. + + + A member of the DXGI_SAMPLE_DESC structure that describes multi-sampling parameters for the surface. + + + + Changes the swap chain's back buffer size, format, and number of buffers. This should be called when the application window is resized. + Microsoft Docs: + The number of buffers in the swap chain (including all back and front buffers). + This number can be different from the number of buffers with which you created the swap chain. + This number can't be greater than DXGI_MAX_SWAP_CHAIN_BUFFERS. + Set this number to zero to preserve the existing number of buffers in the swap chain. + You can't specify less than two buffers for the flip presentation model. + The new width of the back buffer. + If you specify zero, DXGI will use the width of the client area of the target window. + You can't specify the width as zero if you called the IDXGIFactory2::CreateSwapChainForComposition method to create the swap chain for a composition surface. + The new height of the back buffer. + If you specify zero, DXGI will use the height of the client area of the target window. + You can't specify the height as zero if you called the IDXGIFactory2::CreateSwapChainForComposition method to create the swap chain for a composition surface. + A DXGI_FORMAT-typed value for the new format of the back buffer. + Set this value to DXGI_FORMAT_UNKNOWN to preserve the existing format of the back buffer. + The flip presentation model supports a more restricted set of formats than the bit-block transfer (bitblt) model. + A combination of DXGI_SWAP_CHAIN_FLAG-typed values that are combined by using a bitwise OR operation. + The resulting value specifies options for swap-chain behavior. + + + + + The IDXGIOutputDuplication interface accesses and manipulates the duplicated desktop image. + Microsoft Docs: + + + + + The DXGI_OUTDUPL_POINTER_SHAPE_INFO structure describes information about the cursor shape. + Microsoft Docs: + + + + A DXGI_OUTDUPL_POINTER_SHAPE_TYPE-typed value that specifies the type of cursor shape. + + + The width in pixels of the mouse cursor. + + + The height in scan lines of the mouse cursor. + + + The width in bytes of the mouse cursor. + + + The position of the cursor's hot spot relative to its upper-left pixel. An application does not use the hot spot when it determines where to draw the cursor shape. + + + + Gets a description of the swap chain. + Microsoft Docs: + A pointer to a DXGI_SWAP_CHAIN_DESC1 structure that describes the swap chain. + + + + + This interface controls the debug information queue, and can only be used if the debug layer is turned on. + Microsoft Docs: + + + + + Specifies the memory segment group to use. + Microsoft Docs: + + + + The grouping of segments which is considered local to the video adapter, and represents the fastest available memory to the GPU. Applications should target the local segment group as the target size for their working set. + + + The grouping of segments which is considered non-local to the video adapter, and may have slower performance than the local segment group. + + + + This interface exposes a single method for setting video metadata. + Microsoft Docs: + + + + + Registers an application window to receive notification messages of changes of occlusion status. + Microsoft Docs: + The handle of the window to send a notification message to when occlusion status change occurs. + Identifies the notification message to send. + A pointer to a key value that an application can pass to the IDXGIFactory2::UnregisterOcclusionStatus method to unregister the notification message that wMsg specifies. + + + + + Gets the handle to a shared resource. + Microsoft Docs: + A pointer to a handle. + + + + + Queries the graphics driver for a supported frame present duration corresponding to a custom refresh rate. + Microsoft Docs: + Indicates the frame duration to check. This value is the duration of one frame at the desired refresh rate, specified in hundreds of nanoseconds. For example, set this field to 167777 to check for 60 Hz refresh rate support. + A variable that will be set to the closest supported frame present duration that's smaller than the requested value, or zero if the device does not support any lower duration. + A variable that will be set to the closest supported frame present duration that's larger than the requested value, or zero if the device does not support any higher duration. + + + + + Gets the index of the swap chain's current back buffer. + Microsoft Docs: + + + + + Gets the maximum number of messages that can be added to the message queue. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the number. + + + + + Identifies the granularity at which the graphics processing unit (GPU) can be preempted from performing its current graphics rendering task. + Microsoft Docs: + + + + Indicates the preemption granularity as a DMA buffer. + + + Indicates the preemption granularity as a graphics primitive. A primitive is a section in a DMA buffer and can be a group of triangles. + + + Indicates the preemption granularity as a triangle. A triangle is a part of a primitive. + + + Indicates the preemption granularity as a pixel. A pixel is a part of a triangle. + + + Indicates the preemption granularity as a graphics instruction. A graphics instruction operates on a pixel. + + + + This method stops notifying a CPU synchronization object whenever a budget change occurs. An application may switch back to polling the information regularly. + Microsoft Docs: + A key value for the window or event to unregister. The IDXGIAdapter3::RegisterHardwareContentProtectionTeardownStatusEvent method returns this value. + + + + + Gets the rectangle that defines the target region for the video processing blit operation. + Microsoft Docs: + A pointer to a RECT structure + that receives the target region for the swap chain. + + + + + Provides the CPU with efficient access to a desktop image if that desktop image is already in system memory. + Microsoft Docs: + A pointer to a DXGI_MAPPED_RECT structure that receives the surface data that the CPU needs to directly access the surface data. + + + + + Describes a display mode and whether the display mode supports stereo. + Microsoft Docs: + + + + A value that describes the resolution width. + + + A value that describes the resolution height. + + + A DXGI_RATIONAL structure that describes the refresh rate in hertz. + + + A DXGI_FORMAT-typed value that describes the display format. + + + A DXGI_MODE_SCANLINE_ORDER-typed value that describes the scan-line drawing mode. + + + A DXGI_MODE_SCALING-typed value that describes the scaling mode. + + + Specifies whether the full-screen display mode is stereo. TRUE if stereo; otherwise, FALSE. + + + + Represents an adapter output (such as a monitor). The IDXGIOutput2 interface exposes a method to check for multiplane overlay support on the primary output adapter. + Microsoft Docs: + + + + + Halt a thread until the next vertical blank occurs. + Microsoft Docs: + + + + + Gets the residency status of an array of resources. + Microsoft Docs: + An array of IDXGIResource interfaces. + An array of DXGI_RESIDENCY flags. Each element describes the residency status for corresponding element in + the ppResources argument array. + The number of resources in the ppResources argument array and pResidencyStatus argument array. + + + + + This interface enables registration for notifications to detect adapter enumeration state changes. + Microsoft Docs: + + + + + Get the expected resource usage. + Microsoft Docs: + A pointer to a usage flag (see DXGI_USAGE). For Direct3D 10, a surface can be used as a shader input or a render-target output. + + + + + Unregisters an event to stop receiving notifications when the adapter enumeration state changes. + Microsoft Docs: + A key value for the event to unregister. + + + + + The DXGI_OUTDUPL_DESC structure describes the dimension of the output and the surface that contains the desktop image. The format of the desktop image is always DXGI_FORMAT_B8G8R8A8_UNORM. + Microsoft Docs: + + + + A DXGI_MODE_DESC structure that describes the display mode of the duplicated output. + + + A member of the DXGI_MODE_ROTATION enumerated type that describes how the duplicated output rotates an image. + + + Specifies whether the resource that contains the desktop image is already located in system memory. TRUE if the resource is in system memory; otherwise, FALSE. If this value is TRUE and the application requires CPU access, it can use the IDXGIOutputDuplication::MapDesktopSurface and IDXGIOutputDuplication::UnMapDesktopSurface methods to avoid copying the data into a staging buffer. + + + + This method sends the minimum required physical memory for an application, to the OS. + Microsoft Docs: + Specifies the device's physical adapter for which the video memory information is being set. + For single-GPU operation, set this to zero. + If there are multiple GPU nodes, set this to the index of the node (the device's physical adapter) for which the video memory information is being set. + See Multi-adapter systems. + Specifies a DXGI_MEMORY_SEGMENT_GROUP that identifies the group as local or non-local. + Specifies a UINT64 that sets the minimum required physical memory, in bytes. + + + + + Determines whether a swap chain supports “temporary mono.” + Microsoft Docs: + + + + + Allows DXGI to monitor an application's message queue for the alt-enter key sequence (which causes the application to switch from windowed to full screen or vice versa). + Microsoft Docs: + The handle of the window that is to be monitored. This parameter can be NULL; but only if Flags is also 0. + + + + + + Controls debug settings for Microsoft DirectX Graphics Infrastructure (DXGI). You can use the IDXGIDebug1 interface in Windows Store apps. + Microsoft Docs: + + + + + Changes the swap chain's back buffer size, format, and number of buffers, where the swap chain was created using a D3D12 command queue as an input device. This should be called when the application window is resized. + Microsoft Docs: + The number of buffers in the swap chain (including all back and front buffers). + This number can be different from the number of buffers with which you created the swap chain. + This number can't be greater than DXGI_MAX_SWAP_CHAIN_BUFFERS. + Set this number to zero to preserve the existing number of buffers in the swap chain. + You can't specify less than two buffers for the flip presentation model. + The new width of the back buffer. + If you specify zero, DXGI will use the width of the client area of the target window. + You can't specify the width as zero if you called the IDXGIFactory2::CreateSwapChainForComposition method to create the swap chain for a composition surface. + The new height of the back buffer. + If you specify zero, DXGI will use the height of the client area of the target window. + You can't specify the height as zero if you called the IDXGIFactory2::CreateSwapChainForComposition method to create the swap chain for a composition surface. + A DXGI_FORMAT-typed value for the new format of the back buffer. + Set this value to DXGI_FORMAT_UNKNOWN to preserve the existing format of the back buffer. + The flip presentation model supports a more restricted set of formats than the bit-block transfer (bitblt) model. + A combination of DXGI_SWAP_CHAIN_FLAG-typed values that are combined by using a bitwise OR operation. + The resulting value specifies options for swap-chain behavior. + An array of UINTs, of total size BufferCount, where the value indicates which node the back buffer should be created on. + Buffers created using ResizeBuffers1 with a non-null pCreationNodeMask array are visible to all nodes. + An array of command queues (ID3D12CommandQueue instances), of total size BufferCount. + Each queue provided must match the corresponding creation node mask specified in the pCreationNodeMask array. + When Present() is called, in addition to rotating to the next buffer for the next frame, the swapchain will also rotate through these command queues. + This allows the app to control which queue requires synchronization for a given present operation. + + + + + Removes a storage filter from the top of the storage-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that removes the filter. + + + + + Restores access to resources that were previously offered by calling IDXGIDevice2::OfferResources. + Microsoft Docs: + The number of resources in the ppResources argument and pDiscarded argument arrays. + An array of pointers to IDXGIResource interfaces for the resources to reclaim. + A pointer to an array that receives Boolean values. Each value in the array corresponds to a resource at the same index that the ppResources parameter specifies. The runtime sets each Boolean value to TRUE if the corresponding resource’s content was discarded and is now undefined, or to FALSE if the corresponding resource’s old content is still intact. The caller can pass in NULL, if the caller intends to fill the resources with new content regardless of whether the old content was discarded. + + + + + Turns the debug output on or off. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the mute status. + A Boolean value that specifies whether to turn the debug output on or off (TRUE for on, FALSE for off). + + + + + Sets the source region to be used for the swap chain. + Microsoft Docs: + Source width to use for the swap chain. This value must be greater than zero, and must be less than or equal to the overall width of the swap chain. + Source height to use for the swap chain. This value must be greater than zero, and must be less than or equal to the overall height of the swap chain. + + + + + Allows a process to indicate that it's resilient to any of its graphics devices being removed. + Microsoft Docs: + + + + + Used with IDXGIFactoryMedia::CreateDecodeSwapChainForCompositionSurfaceHandle to describe a decode swap chain. + Microsoft Docs: + + + + Can be 0, or a combination of DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO and/or DXGI_SWAP_CHAIN_FLAG_YUV_VIDEO. Those named values are members of the DXGI_SWAP_CHAIN_FLAG enumerated type, and you can combine them by using a bitwise OR operation. The resulting value specifies options for decode swap-chain behavior. + + + + The DXGI_OUTDUPL_FRAME_INFO structure describes the current desktop image. + Microsoft Docs: + + + + The time stamp of the last update of the desktop image. The operating system calls the QueryPerformanceCounter + function to obtain the value. A zero value indicates that the desktop image was not updated since an application last called the IDXGIOutputDuplication::AcquireNextFrame method to acquire the next frame of the desktop image. + + + The time stamp of the last update to the mouse. The operating system calls the QueryPerformanceCounter + function to obtain the value. A zero value indicates that the position or shape of the mouse was not updated since an application last called the IDXGIOutputDuplication::AcquireNextFrame method to acquire the next frame of the desktop image. The mouse position is always supplied for a mouse update. A new pointer shape is indicated by a non-zero value in the PointerShapeBufferSize member. + + + The number of frames that the operating system accumulated in the desktop image surface since the calling application processed the last desktop image. For more information about this number, see Remarks. + + + Specifies whether the operating system accumulated updates by coalescing dirty regions. Therefore, the dirty regions might contain unmodified pixels. TRUE if dirty regions were accumulated; otherwise, FALSE. + + + Specifies whether the desktop image might contain protected content that was already blacked out in the desktop image. TRUE if protected content was already blacked; otherwise, FALSE. The application can use this information to notify the remote user that some of the desktop content might be protected and therefore not visible. + + + A DXGI_OUTDUPL_POINTER_POSITION structure that describes the most recent mouse position if the LastMouseUpdateTime member is a non-zero value; otherwise, this value is ignored. This value provides the coordinates of the location where the top-left-hand corner of the pointer shape is drawn; this value is not the desktop position of the hot spot. + + + Size in bytes of the buffers to store all the desktop update metadata for this frame. For more information about this size, see Remarks. + + + Size in bytes of the buffer to hold the new pixel data for the mouse shape. For more information about this size, see Remarks. + + + + Flushes any outstanding rendering commands and sets the specified event object to the signaled state after all previously submitted rendering commands complete. + Microsoft Docs: + A handle to the event object. The CreateEvent or OpenEvent function returns this handle. All types of event objects (manual-reset, auto-reset, and so on) are supported. + +The handle must have the EVENT_MODIFY_STATE access right. For more information about access rights, see Synchronization Object Security and Access Rights. + + + + + Specifies result flags for the ReclaimResources1 method. + Microsoft Docs: + + + + The surface was successfully reclaimed and has valid content. This result is identical to the false value returned by the older ReclaimResources API. + + + The surface was reclaimed, but the old content was lost and must be regenerated. This result is identical to the true value returned by the older ReclaimResources API. + + + Both the surface and its contents are lost and invalid. The surface must be +recreated and the content regenerated in order to be used. All future use of that resource is invalid. Attempts to bind it to the pipeline or map a resource which returns this value will never succeed, and the resource cannot be reclaimed again. + + + + Gets the rotation of the back buffers for the swap chain. + Microsoft Docs: + A pointer to a variable that receives a DXGI_MODE_ROTATION-typed value that specifies the rotation of the back buffers for the swap chain. + + + + + Gets a copy of the current display surface. + Microsoft Docs: + A pointer to a destination surface (see IDXGISurface). + + + + + Represents an adapter output (such as a monitor). The IDXGIOutput5 interface exposes a single method to specify a list of supported formats for fullscreen surfaces. + Microsoft Docs: + + + + + Sets the color space used by the swap chain. + Microsoft Docs: + A DXGI_COLOR_SPACE_TYPE-typed value that specifies the color space to set. + + + + + Sets the maximum number of messages that can be added to the message queue. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that sets the limit on the number of messages. + The maximum number of messages that can be added to the queue. –1 means no limit. + + + + + Resizes the output target. + Microsoft Docs: + A pointer to a DXGI_MODE_DESC structure that describes the mode, which specifies the new width, height, format, and refresh rate of the target. + If the format is DXGI_FORMAT_UNKNOWN, ResizeTarget uses the existing format. We only recommend that you use DXGI_FORMAT_UNKNOWN when the swap chain is in full-screen + mode as this method is not thread safe. + + + + + Pops a retrieval filter from the top of the retrieval-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pops the filter. + + + + + Gets the flags that were used when a Microsoft DirectX Graphics Infrastructure (DXGI) object was created. + Microsoft Docs: + + + + + The eviction priority of the resource is low. The placement of the resource is not critical, and minimal work is performed to find a location for the resource. For example, if a GPU can render with a vertex buffer from either local or non-local memory with little difference in performance, that vertex buffer is low priority. Other more critical resources (for example, a render target or texture) can then occupy the faster memory. + Microsoft Docs: + + + + + Returns a surface. This method is used internally and you should not call it directly in your application. + Microsoft Docs: + A pointer to a DXGI_SURFACE_DESC structure that describes the surface. + The number of surfaces to create. + A DXGI_USAGE flag that specifies how the surface is expected to be used. + An optional pointer to a DXGI_SHARED_RESOURCE structure that contains shared resource information for opening views of such resources. + The address of an IDXGISurface interface pointer to the first created surface. + + + + + The IDXGIFactory1 interface implements methods for generating DXGI objects. + Microsoft Docs: + + + + + Options for handling pixels in a display surface after calling IDXGISwapChain1::Present1. + Microsoft Docs: + + + + Use this flag to specify the bit-block transfer (bitblt) model and to specify that DXGI discard the contents of the back buffer after you call IDXGISwapChain1::Present1. + This flag is valid for a swap chain with more than one back buffer, although, applications only have read and write access to buffer 0. + Use this flag to enable the display driver to select the most efficient presentation technique for the swap chain. + +Direct3D 12: This enumeration value is never supported. D3D12 apps must using DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD. + +
Note  There are differences between full screen exclusive and full screen UWP. If you are porting a Direct3D 11 application to UWP on a Windows PC, be aware that the use of DXGI_SWAP_EFFECT_DISCARD when creating swap chains does +not behave the same way in UWP as it does in Win32, and its use may be detrimental to GPU performance. + +This is because UWP applications are forced into FLIP swap modes (even if other swap modes are set), because this reduces the computation +time used by the memory copies originally done by the older bitblt model. + +The recommended approach is to manually convert DX11 Discard swap chains to use flip models within UWP, using DXGI_SWAP_EFFECT_FLIP_DISCARD instead of DXGI_SWAP_EFFECT_DISCARD where possible. + Refer to the Example below, and see this article for more information.
+
 
 + + + Use this flag to specify the bitblt model and to specify that DXGI persist the contents of the back buffer after you call IDXGISwapChain1::Present1. + Use this option to present the contents of the swap chain in order, from the first buffer (buffer 0) to the last buffer. + This flag cannot be used with multisampling. + +Direct3D 12: This enumeration value is never supported. D3D12 apps must using DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD. + + +
Note  For best performance, use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL instead of DXGI_SWAP_EFFECT_SEQUENTIAL. See this article for more information.
+
 
 + + + Use this flag to specify the flip presentation model and to specify that DXGI persist the contents of the back buffer after you call IDXGISwapChain1::Present1. This flag cannot be used with multisampling. + + +Direct3D 11:  This enumeration value is supported starting with Windows 8. + + + Use this flag to specify the flip presentation model and to specify that DXGI discard the contents of the back buffer after you call IDXGISwapChain1::Present1. + This flag cannot be used with multisampling and partial presentation. + See DXGI 1.4 Improvements. + + +Direct3D 11:  This enumeration value is supported starting with Windows 10. + + +
Note  Windows Store apps must use DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL or DXGI_SWAP_EFFECT_FLIP_DISCARD. +
+
 
 + + + + Get a description of the output. + Microsoft Docs: + A pointer to the output description (see DXGI_OUTPUT_DESC). + + + + + Allows specifying a list of supported formats for fullscreen surfaces that can be returned by the IDXGIOutputDuplication object. + Microsoft Docs: + A pointer to the Direct3D device interface that you can use to process the desktop image. This device must be created from the adapter to which the output is connected. + Reserved for future use; must be zero. + Specifies the number of supported formats. + Specifies an array, of length SupportedFormatsCount of DXGI_FORMAT entries. + A pointer to a variable that receives the new IDXGIOutputDuplication interface. + + + + + Retrieves the background color of the swap chain. + Microsoft Docs: + A pointer to a DXGI_RGBA structure that receives the background color of the swap chain. + + + + + Retrieves a Boolean value that indicates whether the operating system's stereoscopic 3D display behavior is enabled. + Microsoft Docs: + + + + + Pushes an empty storage filter onto the storage-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pushes the empty storage filter. + + + + + Using a key, releases exclusive rendering access to a shared resource. + Microsoft Docs: + A value that indicates which device to give access to. This method succeeds when the device that currently owns the surface calls the ReleaseSync method using the same value. This value can be any UINT64 value. + + + + + Specifies color space support for the swap chain. + Microsoft Docs: + + + + Color space support is present. + + + Overlay color space support is present. + + + + Enumerates both adapters (video cards) with or without outputs. + Microsoft Docs: + The index of the adapter to enumerate. + The address of a pointer to an IDXGIAdapter1 interface at the position specified by the Adapter parameter. + This parameter must not be NULL. + + + + + An IDXGISwapChain interface implements one or more surfaces for storing rendered data before presenting it to an output. + Microsoft Docs: + + + + + Specifies overlay support to check for in a call to IDXGIOutput3::CheckOverlaySupport. + Microsoft Docs: + + + + Direct overlay support. + + + Scaling overlay support. + + + + Creates swap chains for desktop media apps that use DirectComposition surfaces to decode and display video. + Microsoft Docs: + + + + + Presents a frame on the display screen. + Microsoft Docs: + An integer that specifies how to synchronize presentation of a frame with the vertical blank. + + +For the bit-block transfer (bitblt) model (DXGI_SWAP_EFFECT_DISCARDor DXGI_SWAP_EFFECT_SEQUENTIAL), values are: + +
    +
  • 0 - The presentation occurs immediately, there is no synchronization.
    • +
  • 1 through 4 - Synchronize presentation after the nth vertical blank.
    • +
+For the flip model (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL), values are: + +
    +
  • 0 - Cancel the remaining time on the previously presented frame and discard this frame if a newer frame is queued. +
    • +
  • 1 through 4 - Synchronize presentation for at least n vertical blanks.
    • +
+For an example that shows how sync-interval values affect a flip presentation queue, see Remarks. + +If the update region straddles more than one output (each represented by IDXGIOutput1), Present1 performs the synchronization to the output that contains the largest sub-rectangle of the target window's client area. + An integer value that contains swap-chain presentation options. These options are defined by the DXGI_PRESENT constants. + A pointer to a DXGI_PRESENT_PARAMETERS structure that describes updated rectangles and scroll information of the frame to present. + + + + + Describes an adapter (or video card) that uses Microsoft DirectX Graphics Infrastructure (DXGI) 1.2. + Microsoft Docs: + + + + A string that contains the adapter description. + + + The PCI ID of the hardware vendor. + + + The PCI ID of the hardware device. + + + The PCI ID of the sub system. + + + The PCI ID of the revision number of the adapter. + + + The number of bytes of dedicated video memory that are not shared with the CPU. + + + The number of bytes of dedicated system memory that are not shared with the CPU. This memory is allocated from available system memory at boot time. + + + The number of bytes of shared system memory. This is the maximum value of system memory that may be consumed by the adapter during operation. Any incidental memory consumed by the driver as it manages and uses video memory is additional. + + + A unique value that identifies the adapter. See LUID for a definition of the structure. LUID is defined in dxgi.h. + + + A value of the DXGI_ADAPTER_FLAG enumerated type that describes the adapter type. The DXGI_ADAPTER_FLAG_REMOTE flag is reserved. + + + A value of the DXGI_GRAPHICS_PREEMPTION_GRANULARITY enumerated type that describes the granularity level at which the GPU can be preempted from performing its current graphics rendering task. + + + A value of the DXGI_COMPUTE_PREEMPTION_GRANULARITY enumerated type that describes the granularity level at which the GPU can be preempted from performing its current compute task. + + + + Identifies the importance of a resource’s content when you call the IDXGIDevice2::OfferResources method to offer the resource. + Microsoft Docs: + + + + The resource is low priority. The operating system discards a low priority resource before other offered resources with higher priority. It is a good programming practice to mark a resource as low priority if it has no useful content. + + + The resource is normal priority. You mark a resource as normal priority if it has content that is easy to regenerate. + + + The resource is high priority. The operating system discards other offered resources with lower priority before it discards a high priority resource. You mark a resource as high priority if it has useful content that is difficult to regenerate. + + + + Returns the adapter for the specified device. + Microsoft Docs: + The address of an IDXGIAdapter interface pointer to the adapter. This parameter must not be NULL. + + + + + Describes a swap chain. + Microsoft Docs: + + + + A value that describes the resolution width. If you specify the width as zero when you call the + IDXGIFactory2::CreateSwapChainForHwnd + method to create a swap chain, the runtime obtains the width from the output window and assigns this width value + to the swap-chain description. You can subsequently call the + IDXGISwapChain1::GetDesc1 method to + retrieve the assigned width value. You cannot specify the width as zero when you call the + IDXGIFactory2::CreateSwapChainForComposition + method. + + + A value that describes the resolution height. If you specify the height as zero when you call the + IDXGIFactory2::CreateSwapChainForHwnd + method to create a swap chain, the runtime obtains the height from the output window and assigns this height + value to the swap-chain description. You can subsequently call the + IDXGISwapChain1::GetDesc1 method to + retrieve the assigned height value. You cannot specify the height as zero when you call the + IDXGIFactory2::CreateSwapChainForComposition + method. + + + A DXGI_FORMAT structure that describes the + display format. + + + Specifies whether the full-screen display mode or the swap-chain back buffer is stereo. + TRUE if stereo; otherwise, FALSE. If you specify stereo, you + must also specify a flip-model swap chain (that is, a swap chain that has the + DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL + value set in the SwapEffect member). + + + A DXGI_SAMPLE_DESC structure that + describes multi-sampling parameters. This member is valid only with bit-block transfer (bitblt) model swap + chains. + + + A DXGI_USAGE-typed value that describes the + surface usage and CPU access options for the back buffer. The back buffer can be used for shader input or + render-target output. + + + A value that describes the number of buffers in the swap chain. When you create a full-screen swap chain, + you typically include the front buffer in this value. + + + A DXGI_SCALING-typed value that identifies + resize behavior if the size of the back buffer is not equal to the target output. + + + A DXGI_SWAP_EFFECT-typed value + that describes the presentation model that is used by the swap chain and options for handling the contents of + the presentation buffer after presenting a surface. You must specify the + DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL + value when you call the + IDXGIFactory2::CreateSwapChainForComposition + method because this method supports only flip + presentation model. + + + A DXGI_ALPHA_MODE-typed value that + identifies the transparency behavior of the swap-chain back buffer. + + + A combination of + DXGI_SWAP_CHAIN_FLAG-typed values that are + combined by using a bitwise OR operation. The resulting value specifies options for swap-chain behavior. + + + + This interface adds some memory residency methods, for budgeting and reserving physical memory. + Microsoft Docs: + + + + + The IDXGIDisplayControl interface exposes methods to indicate user preference for the operating system's stereoscopic 3D display behavior and to set stereoscopic 3D display status to enable or disable. + Microsoft Docs: + + + + + Set the priority for evicting the resource from memory. + Microsoft Docs: + + + + + + Identifies the type of pointer shape. + Microsoft Docs: + + + + The pointer type is a monochrome mouse pointer, which is a monochrome bitmap. The bitmap's size is specified by width and height in a 1 bits per pixel (bpp) device independent bitmap (DIB) format AND mask that is followed by another 1 bpp DIB format XOR mask of the same size. + + + The pointer type is a color mouse pointer, which is a color bitmap. The bitmap's size is specified by width and height in a 32 bpp ARGB DIB format. + + + The pointer type is a masked color mouse pointer. A masked color mouse pointer is a 32 bpp ARGB format bitmap with the mask value in the alpha bits. The only allowed mask values are 0 and 0xFF. When the mask value is 0, the RGB value should replace the screen pixel. When the mask value is 0xFF, an XOR operation is performed on the RGB value and the screen pixel; the result replaces the screen pixel. + + + + Changes the background color of the swap chain. + Microsoft Docs: + A pointer to a DXGI_RGBA structure that specifies the background color to set. + + + + + The preference of GPU for the app to run on. + Microsoft Docs: + + + + No preference of GPU. + + + Preference for the minimum-powered GPU (such as an integrated graphics processor, or iGPU). + + + Preference for the highest performing GPU, such as a discrete graphics processor (dGPU) or external graphics processor (xGPU). + + + + Registers to receive notification of hardware content protection teardown events. + Microsoft Docs: + A handle to the event object that the operating system sets when hardware content protection teardown occurs. The CreateEvent or OpenEvent function returns this handle. + A pointer to a key value that an application can pass to the IDXGIAdapter3::UnregisterHardwareContentProtectionTeardownStatus method to unregister the notification event that hEvent specifies. + + + + + Gets the gamma control settings. + Microsoft Docs: + An array of gamma control settings (see DXGI_GAMMA_CONTROL). + + + + + Represents a rational number. + Microsoft Docs: + + + + An unsigned integer value representing the top of the rational number. + + + An unsigned integer value representing the bottom of the rational number. + + + + This interface controls debug settings, and can only be used if the debug layer is turned on. + Microsoft Docs: + + + + + Gets the size of the retrieval-filter stack in bytes. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the size. + + + + + Removes a retrieval filter from the top of the retrieval-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that removes the filter. + + + + + The alpha channel is not specified. This value has the same effect as DXGI_ALPHA_MODE_IGNORE. + Microsoft Docs: + + + + + Pushes a storage filter onto the storage-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pushes the filter. + A pointer to a DXGI_INFO_QUEUE_FILTER structure that describes the filter. + + + + + Specifies flags for the OfferResources1 method. + Microsoft Docs: + + + + Indicates the ability to allow memory de-commit by the DirectX Graphics Kernel. + + + + Invalidate the pointer to the surface retrieved by IDXGISurface::Map and re-enable GPU access to the resource. + Microsoft Docs: + + + + + Gets a description of the gamma-control capabilities. + Microsoft Docs: + A pointer to a description of the gamma-control capabilities (see DXGI_GAMMA_CONTROL_CAPABILITIES). + + + + + Adds a user-defined message to the message queue and sends that message to the debug output. + Microsoft Docs: + A DXGI_INFO_QUEUE_MESSAGE_SEVERITY-typed value that specifies the severity of the message. + The message string. + + + + + Invalidates the pointer to the desktop image that was retrieved by using IDXGIOutputDuplication::MapDesktopSurface. + Microsoft Docs: + + + + + Used to check for hardware feature support. + Microsoft Docs: + Specifies one member of DXGI_FEATURE to query support for. + Specifies a pointer to a buffer that will be filled with data that describes the feature support. + The size, in bytes, of pFeatureSupportData. + + + + + The resource is unused and can be evicted as soon as another resource requires the memory that the resource occupies. + Microsoft Docs: + + + + + Specifies a range of hardware features, to be used when checking for feature support. + Microsoft Docs: + + + + The display supports tearing, a requirement of variable refresh rate displays. + + + + The eviction priority of the resource is normal. The placement of the resource is important, but not critical, for performance. The resource is placed in its preferred location instead of a low-priority resource. + Microsoft Docs: + + + + + The DXGI_OUTDUPL_POINTER_POSITION structure describes the position of the hardware cursor. + Microsoft Docs: + + + + The position of the hardware cursor relative to the top-left of the adapter output. + + + Specifies whether the hardware cursor is visible. TRUE if visible; otherwise, FALSE. If the hardware cursor is not visible, the calling application does not display the cursor in the client. + + + + The IDXGIAdapter1 interface represents a display sub-system (including one or more GPU's, DACs and video memory). + Microsoft Docs: + + + + + The IDXGISurface interface implements methods for image-data objects. + Microsoft Docs: + + + + + Specifies support for overlay color space. + Microsoft Docs: + + + + Overlay color space support is present. + + + + Determines whether the break on a message category is turned on or off. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the breaking status. + A DXGI_INFO_QUEUE_MESSAGE_CATEGORY-typed value that specifies the category of the message. + + + + + Queries an adapter output for multiplane overlay support. + Microsoft Docs: + + + + + Releases the GDI device context (DC) that is associated with the current surface and allows you to use Direct3D to render. + Microsoft Docs: + A pointer to a RECT structure that identifies the dirty region of the surface. + A dirty region is any part of the surface that you used for GDI rendering and that you want to preserve. + This area is used as a performance hint to graphics subsystem in certain scenarios. + Do not use this parameter to restrict rendering to the specified rectangular region. + If you pass in NULL, ReleaseDC considers the whole surface as dirty. + Otherwise, ReleaseDC uses the area specified by the RECT as a performance hint to indicate what areas have been manipulated by GDI rendering. + +You can pass a pointer to an empty RECT structure (a rectangle with no position or area) if you didn't change any content. + + + + + Provides presentation capabilities that are enhanced from IDXGISwapChain. These presentation capabilities consist of specifying dirty rectangles and scroll rectangle to optimize the presentation. + Microsoft Docs: + + + + + Describes the types of messages to allow or deny to pass through a filter. + Microsoft Docs: + + + + The number of message categories to allow or deny. + + + An array of DXGI_INFO_QUEUE_MESSAGE_CATEGORY enumeration values that describe the message categories to allow or deny. The array must have at least NumCategories number of elements. + + + The number of message severity levels to allow or deny. + + + An array of DXGI_INFO_QUEUE_MESSAGE_SEVERITY enumeration values that describe the message severity levels to allow or deny. The array must have at least NumSeverities number of elements. + + + The number of message IDs to allow or deny. + + + An array of integers that represent the message IDs to allow or deny. The array must have at least NumIDs number of elements. + + + + Represents a handle to a shared resource. + Microsoft Docs: + + + + A handle to a shared resource. + + + + An IDXGIResource1 interface extends the IDXGIResource interface by adding support for creating a subresource surface object and for creating a handle to a shared resource. + Microsoft Docs: + + + + + Get a pointer to the data contained in the surface, and deny GPU access to the surface. + Microsoft Docs: + A pointer to the surface data (see DXGI_MAPPED_RECT). + CPU read-write flags. These flags can be combined with a logical OR. + + + +
    +
  • DXGI_MAP_READ - Allow CPU read access.
    • +
  • DXGI_MAP_WRITE - Allow CPU write access.
    • +
  • DXGI_MAP_DISCARD - Discard the previous contents of a resource when it is mapped.
    • +
+ + + + + The IDXGIAdapter2 interface represents a display subsystem, which includes one or more GPUs, DACs, and video memory. + Microsoft Docs: + + + + + Starts tracking leaks for the current thread. + Microsoft Docs: + + + + + Get the eviction priority. + Microsoft Docs: + A pointer to the eviction priority, which determines when a resource can be evicted from memory. + +The following defined values are possible. + + + + + + + + + + + + + + + + + + + + + + + + + + +
ValueMeaning
+
DXGI_RESOURCE_PRIORITY_MINIMUM (0x28000000)
+
+		 +The resource is unused and can be evicted as soon as another resource requires the memory that the resource occupies. + +
+
DXGI_RESOURCE_PRIORITY_LOW (0x50000000)
+
+		 +The eviction priority of the resource is low. The placement of the resource is not critical, and minimal work is performed to find a location for the resource. For example, if a GPU can render with a vertex buffer from either local or non-local memory with little difference in performance, that vertex buffer is low priority. Other more critical resources (for example, a render target or texture) can then occupy the faster memory. + +
+
DXGI_RESOURCE_PRIORITY_NORMAL (0x78000000)
+
+		 +The eviction priority of the resource is normal. The placement of the resource is important, but not critical, for performance. The resource is placed in its preferred location instead of a low-priority resource. + +
+
DXGI_RESOURCE_PRIORITY_HIGH (0xa0000000)
+
+		 +The eviction priority of the resource is high. The resource is placed in its preferred location instead of a low-priority or normal-priority resource. + +
+
DXGI_RESOURCE_PRIORITY_MAXIMUM (0xc8000000)
+
+		 +The resource is evicted from memory only if there is no other way of resolving the memory requirement. + +
+ + + + + This method informs the process of the current budget and process usage. + Microsoft Docs: + Specifies the device's physical adapter for which the video memory information is queried. + For single-GPU operation, set this to zero. + If there are multiple GPU nodes, set this to the index of the node (the device's physical adapter) for which the video memory information is queried. + See Multi-adapter systems. + Specifies a DXGI_MEMORY_SEGMENT_GROUP that identifies the group as local or non-local. + Fills in a DXGI_QUERY_VIDEO_MEMORY_INFO structure with the current values. + + + + + Gets the number of frames that the swap chain is allowed to queue for rendering. + Microsoft Docs: + The maximum number of back buffer frames that will be queued for the swap chain. This value is 1 by default, but should be set to 2 if the scene takes longer than it takes for one vertical refresh (typically about 16ms) to draw. + + + + + Trims the graphics memory allocated by the IDXGIDevice3 DXGI device on the app's behalf. + Microsoft Docs: + + + + + Sets the number of frames that the swap chain is allowed to queue for rendering. + Microsoft Docs: + The maximum number of back buffer frames that will be queued for the swap chain. This value is 1 by default. + + + + + Values that specify debug message severity levels for an information queue. + Microsoft Docs: + + + + Defines some type of corruption that has occurred. + + + Defines an error message. + + + Defines a warning message. + + + Defines an information message. + + + Defines a message other than corruption, error, warning, or information. + + + + Gets a description of a full-screen swap chain. + Microsoft Docs: + A pointer to a DXGI_SWAP_CHAIN_FULLSCREEN_DESC structure that describes the full-screen swap chain. + + + + + Describes full-screen mode for a swap chain. + Microsoft Docs: + + + + A DXGI_RATIONAL structure that describes the refresh rate in hertz. + + + A member of the DXGI_MODE_SCANLINE_ORDER enumerated type that describes the scan-line drawing mode. + + + A member of the DXGI_MODE_SCALING enumerated type that describes the scaling mode. + + + A Boolean value that specifies whether the swap chain is in windowed mode. TRUE if the swap chain is in windowed mode; otherwise, FALSE. + + + + Describes timing and presentation statistics for a frame. + Microsoft Docs: + + + + A value that represents the running total count of times that an image was presented to the monitor since the computer booted. + +
Note  The number of times that an image was presented to the monitor is not necessarily the same as the number of times + that you called IDXGISwapChain::Present or IDXGISwapChain1::Present1.
+
 
 + + + A value that represents the running total count of v-blanks at which the last image was presented to the monitor and that have happened since the computer booted (for windowed mode, since the swap chain was created). + + + A value that represents the running total count of v-blanks when the scheduler last sampled the machine time by calling QueryPerformanceCounter and that have happened since the computer booted (for windowed mode, since the swap chain was created). + + + A value that represents the high-resolution performance counter timer. + This value is the same as the value returned by the QueryPerformanceCounter + function. + + + Reserved. Always returns 0. + + + + Gets information about the moved rectangles for the current desktop frame. + Microsoft Docs: + The size in bytes of the buffer that the caller passed to the pMoveRectBuffer parameter. + A pointer to an array of + DXGI_OUTDUPL_MOVE_RECT structures + that identifies the moved rectangle regions for the desktop frame. + Pointer to a variable that receives the number of bytes that + GetFrameMoveRects + needs to store information about moved regions in the buffer at pMoveRectBuffer. + +For more information about returning the required buffer size, see Remarks. + + + + + Gets statistics about recently rendered frames. + Microsoft Docs: + A pointer to frame statistics (see DXGI_FRAME_STATISTICS). + + + + + Creates a desktop duplication interface from the IDXGIOutput1 interface that represents an adapter output. + Microsoft Docs: + A pointer to the Direct3D device interface that you can use to process the desktop image. This device must be created from the adapter to which the output is connected. + A pointer to a variable that receives the new IDXGIOutputDuplication interface. + + + + + Describes an output or physical connection between the adapter (video card) and a device, including additional information about color capabilities and connection type. + Microsoft Docs: + + + + A string that contains the name of the output device. + + + A RECT structure containing the bounds of the output in desktop coordinates. Desktop coordinates depend on the dots per inch (DPI) of the desktop. + For info about writing DPI-aware Win32 apps, see High DPI. + + + True if the output is attached to the desktop; otherwise, false. + + + A member of the DXGI_MODE_ROTATION enumerated type describing on how an image is rotated by the output. + + + An HMONITOR handle that represents the display monitor. For more information, see HMONITOR and the Device Context. + + + The number of bits per color channel for the active wire format of the display attached to this output. + + + The current advanced color capabilities of the display attached to this output. Specifically, whether its capable of reproducing color and luminance values outside of the sRGB color space. + A value of DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 indicates that the display is limited to SDR/sRGB; A value of DXGI_COLOR_SPACE_RGB_FULL_G2048_NONE_P2020 indicates that the display supports + advanced color capabilities. + +For detailed luminance and color capabilities, see additional members of this struct. + + + The red color primary, in xy coordinates, of the display attached to this output. This value will usually come from the EDID of the corresponding display or sometimes from an override. + + + The green color primary, in xy coordinates, of the display attached to this output. This value will usually come from the EDID of the corresponding display or sometimes from an override. + + + The blue color primary, in xy coordinates, of the display attached to this output. This value will usually come from the EDID of the corresponding display or sometimes from an override. + + + The white point, in xy coordinates, of the display attached to this output. This value will usually come from the EDID of the corresponding display or sometimes from an override. + + + The minimum luminance, in nits, that the display attached to this output is capable of rendering. Content should not exceed this minimum value for optimal rendering. This value will + usually come from the EDID of the corresponding display or sometimes from an override. + + + The maximum luminance, in nits, that the display attached to this output is capable of rendering; this value is likely only valid for a small area of the panel. Content should not exceed + this minimum value for optimal rendering. This value will usually come from the EDID of the corresponding display or sometimes from an override. + + + The maximum luminance, in nits, that the display attached to this output is capable of rendering; unlike MaxLuminance, this value is valid for a color that fills the entire area of the + panel. Content should not exceed this value across the entire panel for optimal rendering. This value will usually come from the EDID of the corresponding display or sometimes from an + override. + + + + An IDXGIOutput1 interface represents an adapter output (such as a monitor). + Microsoft Docs: + + + + + Stops tracking leaks for the current thread. + Microsoft Docs: + + + + + Get the window through which the user controls the transition to and from full screen. + Microsoft Docs: + A pointer to a window handle. + + + + + Creates a handle to a shared resource. You can then use the returned handle with multiple Direct3D devices. + Microsoft Docs: + A pointer to a SECURITY_ATTRIBUTES + structure that contains two separate but related data members: an optional security descriptor, and a Boolean + value that determines whether child processes can inherit the returned handle. + +Set this parameter to NULL if you want child processes that the + application might create to not inherit the handle returned by + CreateSharedHandle, and if you want the resource that is associated with the returned handle to get a default security + descriptor. + +The lpSecurityDescriptor member of the structure specifies a + SECURITY_DESCRIPTOR for the resource. Set + this member to NULL if you want the runtime to assign a default security descriptor to the resource that is associated with the returned handle. The ACLs in the default security descriptor for the resource come from the primary or impersonation token of the creator. For more info, see Synchronization Object Security and Access Rights. + The requested access rights to the resource. In addition to the generic access rights, DXGI defines the following values: + +
    +
  • DXGI_SHARED_RESOURCE_READ ( 0x80000000L ) - specifies read access to the resource.
    • +
  • DXGI_SHARED_RESOURCE_WRITE ( 1 ) - specifies write access to the resource.
    • +
+You can combine these values by using a bitwise OR operation. + The name of the resource to share. The name is limited to MAX_PATH characters. Name comparison is case sensitive. + +You will need the resource name if you call the ID3D11Device1::OpenSharedResourceByName method to access the shared resource by name. If you instead call the ID3D11Device1::OpenSharedResource1 method to access the shared resource by handle, set this parameter to NULL. + +If lpName matches the name of an existing resource, CreateSharedHandle fails with DXGI_ERROR_NAME_ALREADY_EXISTS. This occurs because these objects share the same namespace. + +The name can have a "Global\" or "Local\" prefix to explicitly create the object in the global or session namespace. The remainder of the name can contain any character except the backslash character (\\). For more information, see +Kernel Object Namespaces. Fast user switching is implemented using Terminal Services sessions. Kernel object names must follow the guidelines outlined for Terminal Services so that applications can support multiple users. + +The object can be created in a private namespace. For more information, see Object Namespaces. + A pointer to a variable that receives the NT HANDLE value to the resource to share. You can use this handle in calls to access the resource. + + + + + Enumerates the adapters (video cards). + Microsoft Docs: + The index of the adapter to enumerate. + The address of a pointer to an IDXGIAdapter interface at the position specified by the Adapter parameter. This parameter must not be NULL. + + + + + Pushes a copy of the storage filter that is currently on the top of the storage-filter stack onto the storage-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pushes the copy of the storage filter. + + + + + Releases ownership of the output. + Microsoft Docs: + + + + + Returns a device context (DC) that allows you to render to a Microsoft DirectX Graphics Infrastructure (DXGI) surface using Windows Graphics Device Interface (GDI). + Microsoft Docs: + A Boolean value that specifies whether to preserve Direct3D contents in the GDI DC. TRUE directs the runtime not to preserve Direct3D contents in the GDI DC; that is, the runtime discards the Direct3D contents. FALSE guarantees that Direct3D contents are available in the GDI DC. + A pointer to an HDC handle that represents the current device context for GDI rendering. + + + + + Adds storage filters to the top of the storage-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that produced the filters. + An array of DXGI_INFO_QUEUE_FILTER structures that describe the filters. + + + + + Determines whether the break on a message severity level is turned on or off. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the breaking status. + A DXGI_INFO_QUEUE_MESSAGE_SEVERITY-typed value that specifies the severity of the message. + + + + + Describes an output or physical connection between the adapter (video card) and a device. + Microsoft Docs: + + + + A string that contains the name of the output device. + + + A RECT structure containing the bounds of the output in desktop coordinates. Desktop coordinates depend on the dots per inch (DPI) of the desktop. +For info about writing DPI-aware Win32 apps, see High DPI. + + + True if the output is attached to the desktop; otherwise, false. + + + A member of the DXGI_MODE_ROTATION enumerated type describing on how an image is rotated by the output. + + + An HMONITOR handle that represents the display monitor. For more information, see HMONITOR and the Device Context. + + + + Options for swap-chain behavior. + Microsoft Docs: + + + + Set this flag to turn off automatic image rotation; that is, do not perform a rotation when transferring the contents of the front buffer to the monitor. + Use this flag to avoid a bandwidth penalty when an application expects to handle rotation. This option is valid only during full-screen mode. + + + Set this flag to enable an application to switch modes by calling IDXGISwapChain::ResizeTarget. + When switching from windowed to full-screen mode, the display mode (or monitor resolution) will be changed to match the dimensions of the application window. + + + Set this flag to enable an application to render using GDI on a swap chain or a surface. + This will allow the application to call IDXGISurface1::GetDC on the 0th back buffer or a surface. + +This flag is not applicable for Direct3D 12. + + + Set this flag to indicate that the swap chain might contain protected content; therefore, the operating system supports the creation of the swap chain only when driver and hardware protection is used. If the driver and hardware do not support content protection, the call to create a resource for the swap chain fails. + +Direct3D 11:  This enumeration value is supported starting with Windows 8. + + + Set this flag to indicate that shared resources that are created within the swap chain must be protected by using the driver’s mechanism for restricting access to shared surfaces. + +Direct3D 11:  This enumeration value is supported starting with Windows 8. + + + Set this flag to restrict presented content to the local displays. Therefore, the presented content is not accessible via remote accessing or through the desktop duplication APIs. + +This flag supports the window content protection features of Windows. Applications can use this flag to protect their own onscreen window content from being captured or copied through a specific set of public operating system features and APIs. + +If you use this flag with windowed (HWND or IWindow) swap chains where another process created the HWND, the owner of the HWND must use the SetWindowDisplayAffinity function appropriately in order to allow calls to IDXGISwapChain::Present or IDXGISwapChain1::Present1 to succeed. + + +Direct3D 11:  This enumeration value is supported starting with Windows 8. + + + Set this flag to create a waitable object you can use to ensure rendering does not begin while a frame is still being presented. When this flag is used, the swapchain's latency must be set with the IDXGISwapChain2::SetMaximumFrameLatency API instead of IDXGIDevice1::SetMaximumFrameLatency. + +This flag isn't supported in full-screen mode, unless the render API is Direct3D 12. + +Note  This enumeration value is supported starting with Windows 8.1. + + + Set this flag to create a swap chain in the foreground layer for multi-plane rendering. This flag can only be used with CoreWindow swap chains, which are created with CreateSwapChainForCoreWindow. Apps should not create foreground swap chains if IDXGIOutput2::SupportsOverlays indicates that hardware support for overlays is not available. + +Note that IDXGISwapChain::ResizeBuffers cannot be used to add or remove this flag. + +Note  This enumeration value is supported starting with Windows 8.1. + + + Set this flag to create a swap chain for full-screen video. + +Note  This enumeration value is supported starting with Windows 8.1. + + + Set this flag to create a swap chain for YUV video. + +Note  This enumeration value is supported starting with Windows 8.1. + + + Indicates that the swap chain should be created such that all underlying resources can be protected by the hardware. Resource creation will fail if hardware content protection is not supported. + +This flag has the following restrictions: + +
    +
  • This flag can only be used with swap effect DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL.
    • +
+
Note  Creating a swap chain using this flag does not automatically guarantee that hardware protection will be enabled for the underlying allocation. Some implementations require that the DRM components are first initialized prior to any guarantees of protection.
+
 
+Note  This enumeration value is supported starting with Windows 10. + + + Tearing support is a requirement to enable displays that support variable refresh rates to function properly when the application presents a swap chain tied to a full screen borderless window. Win32 apps can already achieve tearing in fullscreen exclusive mode by calling SetFullscreenState(TRUE), but the recommended approach for Win32 developers is to use this tearing flag instead. This flag requires the use of a DXGI_SWAP_EFFECT_FLIP_* swap effect. + +To check for hardware support of this feature, refer to IDXGIFactory5::CheckFeatureSupport. For usage information refer to IDXGISwapChain::Present and the DXGI_PRESENT flags. + + + + Options for swap-chain color space. + Microsoft Docs: + + + + Specifies nominal range YCbCr, which isn't an absolute color space, but a way of encoding RGB info. + + + Specifies BT.709, which standardizes the format of high-definition television and has 16:9 (widescreen) aspect ratio. + + + Specifies xvYCC or extended-gamut YCC (also x.v.Color) color space that can be used in the video electronics of television sets to support a gamut 1.8 times as large as that of the sRGB color space. + + + + Describes an adapter (or video card) using DXGI 1.1. + Microsoft Docs: + + + + A string that contains the adapter description. On feature level 9 graphics hardware, GetDesc1 returns “Software Adapter” for the description string. + + + The PCI ID of the hardware vendor. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID of the hardware vendor. + + + The PCI ID of the hardware device. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID of the hardware device. + + + The PCI ID of the sub system. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID of the sub system. + + + The PCI ID of the revision number of the adapter. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID of the revision number of the adapter. + + + The number of bytes of dedicated video memory that are not shared with the CPU. + + + The number of bytes of dedicated system memory that are not shared with the CPU. This memory is allocated from available system memory at boot time. + + + The number of bytes of shared system memory. This is the maximum value of system memory that may be consumed by the adapter during operation. Any incidental memory consumed by the driver as it manages and uses video memory is additional. + + + A unique value that identifies the adapter. See LUID for a definition of the structure. LUID is defined in dxgi.h. + + + A value of the DXGI_ADAPTER_FLAG enumerated type that describes the adapter type. The DXGI_ADAPTER_FLAG_REMOTE flag is reserved. + + + + Gets the number of messages that were discarded due to the message count limit. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the number. + + + + + Gets the number of messages that can pass through a retrieval filter. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the number. + + + + + Clears all messages from the message queue. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that clears the messages. + + + + + Creates a YUV swap chain for an existing DirectComposition surface handle. + Microsoft Docs: + A pointer to the Direct3D device for the swap chain. This parameter cannot be NULL. + Software drivers, like D3D_DRIVER_TYPE_REFERENCE, are not supported for composition swap chains. + A handle to an existing DirectComposition surface. This parameter cannot be NULL. + A pointer to a DXGI_DECODE_SWAP_CHAIN_DESC structure for the swap-chain description. + This parameter cannot be NULL. + A pointer to a IDXGIResource interface that represents the resource that contains the info + that CreateDecodeSwapChainForCompositionSurfaceHandle decodes. + A pointer to the IDXGIOutput interface for the swap chain to restrict content to. If the swap chain + is moved to a different output, the content is black. You can optionally set this parameter to an output target that + uses DXGI_PRESENT_RESTRICT_TO_OUTPUT to restrict + the content on this output. If the swap chain is moved to a different output, the content is black. + + +You must also pass the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag in a + present call to force the content to appear blacked out on any other output. If you want to restrict the content to a different output, you must create a new swap chain. + However, you can conditionally restrict content + based on the DXGI_PRESENT_RESTRICT_TO_OUTPUT flag. + + +Set this parameter to NULL if you don't want to restrict content to an output target. + A pointer to a variable that receives a pointer to the IDXGIDecodeSwapChain interface for the + swap chain that this method creates. + + + + + This swap chain interface allows desktop media applications to request a seamless change to a specific refresh rate. + Microsoft Docs: + + + + + Get a description of the swap chain. + Microsoft Docs: + A pointer to the swap-chain description (see DXGI_SWAP_CHAIN_DESC). + + + + + Specifies color space types. + Microsoft Docs: + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range0-255
Gamma2.2
SitingImage
PrimariesBT.709
+  + +This is the standard definition for sRGB. + + Note that this is often implemented with a linear segment, but in that case the exponent is corrected to stay aligned with a gamma 2.2 curve. + + This is usually used with 8 or 10 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range0-255
Gamma1.0
SitingImage
PrimariesBT.709
+  + +This is the standard definition for scRGB, and is usually used with 16 bit integer, 16 bit floating point, or 32 bit floating point color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range16-235
Gamma2.2
SitingImage
PrimariesBT.709
+  + +This is the standard definition for ITU-R Recommendation BT.709. Note that due to the inclusion of a linear segment, the transfer curve looks similar to a pure exponential gamma of 1.9. + + This is usually used with 8 or 10 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range16-235
Gamma2.2
SitingImage
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + Reserved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range0-255
Gamma2.2
SitingImage
PrimariesBT.709
Transfer MatrixBT.601
+  + +This definition is commonly used for JPG, and is usually used with 8, 10, or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range16-235
Gamma2.2
SitingVideo
PrimariesBT.601
+  + +This definition is commonly used for MPEG2, and is usually used with 8, 10, or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range0-255
Gamma2.2
SitingVideo
PrimariesBT.601
+  + +This is sometimes used for H.264 camera capture, and is usually used with 8, 10, or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range16-235
Gamma2.2
SitingVideo
PrimariesBT.709
+  + +This definition is commonly used for H.264 and HEVC, and is usually used with 8, 10, or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range0-255
Gamma2.2
SitingVideo
PrimariesBT.709
+  + +This is sometimes used for H.264 camera capture, and is usually used with 8, 10, or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range16-235
Gamma2.2
SitingVideo
PrimariesBT.2020
+  + +This definition may be used by HEVC, and is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range0-255
Gamma2.2
SitingVideo
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range0-255
Gamma2084
SitingImage
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range16-235
Gamma2084
SitingVideo
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range16-235
Gamma2084
SitingImage
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range16-235
Gamma2.2
SitingVideo
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCbCr
Range16-235
Gamma2084
SitingVideo
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range0-255
Gamma2.2
SitingImage
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCBCR
Range16-235
GammaHLG
SitingVideo
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCBCR
Range0-255
GammaHLG
SitingVideo
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range16-235
Gamma2.4
SitingImage
PrimariesBT.709
+  + +This is usually used with 8, 10, or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceRGB
Range16-235
Gamma2.4
SitingImage
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCBCR
Range16-235
Gamma2.4
SitingVideo
PrimariesBT.709
+  + +This is usually used with 8, 10, or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCBCR
Range16-235
Gamma2.4
SitingVideo
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyValue
ColorspaceYCBCR
Range16-235
Gamma2.4
SitingVideo
PrimariesBT.2020
+  + +This is usually used with 10 or 12 bit color channels. + + + A custom color definition is used. + + + + Sets application-defined data to the object and associates that data with a GUID. + Microsoft Docs: + A GUID that identifies the data. Use this GUID in a call to GetPrivateData to get the data. + The size of the object's data. + A pointer to the object's data. + + + + + Presents a frame on the output adapter. + Microsoft Docs: + An index indicating which member of the subresource array to present. + An integer that specifies how to synchronize presentation of a frame with the vertical blank. + + +For the bit-block transfer (bitblt) model (DXGI_SWAP_EFFECT_DISCARDor DXGI_SWAP_EFFECT_SEQUENTIAL), values are: + +
    +
  • 0 - The presentation occurs immediately, there is no synchronization.
    • +
  • 1,2,3,4 - Synchronize presentation after the nth vertical blank.
    • +
+For the flip model (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL), values are: + +
    +
  • 0 - Cancel the remaining time on the previously presented frame and discard this frame if a newer frame is queued. +
    • +
  • n > 0 - Synchronize presentation for at least n vertical blanks.
    • +
+ An integer value that contains swap-chain presentation options. These options are defined by the DXGI_PRESENT constants. + +The DXGI_PRESENT_USE_DURATION flag must be set if a custom present duration (custom refresh rate) is being used. + + + + + Retrieves a description of a duplicated output. This description specifies the dimensions of the surface that contains the desktop image. + Microsoft Docs: + A pointer to a DXGI_OUTDUPL_DESC structure that describes the duplicated output. This parameter must not be NULL. + + + + + Determines whether the break on a message identifier is turned on or off. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the breaking status. + An integer value that specifies the identifier of the message. + + + + + Describes a swap chain. + Microsoft Docs: + + + + A DXGI_MODE_DESC structure that describes the backbuffer display mode. + + + A DXGI_SAMPLE_DESC structure that describes multi-sampling parameters. + + + A member of the DXGI_USAGE enumerated type that describes the surface usage and CPU access options for the back buffer. The back buffer can + be used for shader input or render-target output. + + + A value that describes the number of buffers in the swap chain. When you call IDXGIFactory::CreateSwapChain to create a full-screen swap chain, you typically include the front buffer in this value. For more information about swap-chain buffers, see Remarks. + + + An HWND handle to the output window. This member must not be NULL. + + + A Boolean value that specifies whether the output is in windowed mode. TRUE if the output is in windowed mode; otherwise, FALSE. + +We recommend that you create a windowed swap chain and allow the end user to change the swap chain to full screen through IDXGISwapChain::SetFullscreenState; that is, do not set this member to FALSE to force the swap chain to be full screen. However, if you create the swap chain as full screen, also provide the end user with a list of supported display modes through the BufferDesc member because a swap chain that is created with an unsupported display mode might cause the display to go black and prevent the end user from seeing anything. + +For more information about choosing windowed verses full screen, see IDXGIFactory::CreateSwapChain. + + + A member of the DXGI_SWAP_EFFECT enumerated type that describes options for handling the contents of the presentation buffer after + presenting a surface. + + + A member of the DXGI_SWAP_CHAIN_FLAG enumerated type that describes options for swap-chain behavior. + + + + Checks for overlay color space support. + Microsoft Docs: + A DXGI_FORMAT-typed value for the color format. + A DXGI_COLOR_SPACE_TYPE-typed value that specifies color space type to check overlay support for. + A pointer to the Direct3D device interface. CheckOverlayColorSpaceSupport returns only support info about this scan-out device. + A pointer to a variable that receives a combination of DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG-typed values that are combined by using a bitwise OR operation. The resulting value specifies options for overlay color space support. + + + + + Copies the display surface (front buffer) to a user-provided resource. + Microsoft Docs: + A pointer to a resource interface that represents the resource to which GetDisplaySurfaceData1 copies the display surface. + + + + + Gets a Microsoft DirectX Graphics Infrastructure (DXGI) 1.6 description of an adapter or video card. This description includes information about ACG compatibility. + Microsoft Docs: + A pointer to a DXGI_ADAPTER_DESC3 structure that describes the adapter. + This parameter must not be NULL. On feature level 9 graphics hardware, early versions of GetDesc3 (GetDesc1, and GetDesc) return zeros for the PCI ID in the VendorId, DeviceId, SubSysId, and Revision members of the adapter description structure and “Software Adapter” for the description string in the Description member. GetDesc3 and GetDesc2 return the actual feature level 9 hardware values in these members. + + + + + Gets the source region used for the swap chain. + Microsoft Docs: + The current width of the source region of the swap chain. This value can range from 1 to the overall width of the swap chain. + The current height of the source region of the swap chain. This value can range from 1 to the overall height of the swap chain. + + + + + Sets the GPU thread priority. + Microsoft Docs: + A value that specifies the required GPU thread priority. This value must be between -7 and 7, inclusive, where 0 represents normal priority. + + + + + The IDXGIAdapter interface represents a display subsystem (including one or more GPUs, DACs and video memory). + Microsoft Docs: + + + + + Gets the color space used by the swap chain. + Microsoft Docs: + + + + + Determines whether the debug output is turned on or off. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the mute status. + + + + + Retrieves an interface that Windows Store apps use for debugging the Microsoft DirectX Graphics Infrastructure (DXGI). + Microsoft Docs: + Not used. + The globally unique identifier (GUID) of the requested interface type, which can be the identifier for the IDXGIDebug, IDXGIDebug1, or IDXGIInfoQueue interfaces. + A pointer to a buffer that receives a pointer to the debugging interface. + + + + + Identifies the granularity at which the graphics processing unit (GPU) can be preempted from performing its current compute task. + Microsoft Docs: + + + + Indicates the preemption granularity as a compute packet. + + + Indicates the preemption granularity as a dispatch (for example, a call to the ID3D11DeviceContext::Dispatch method). A dispatch is a part of a compute packet. + + + Indicates the preemption granularity as a thread group. A thread group is a part of a dispatch. + + + Indicates the preemption granularity as a thread in a thread group. A thread is a part of a thread group. + + + Indicates the preemption granularity as a compute instruction in a thread. + + + + Presents a rendered image to the user. + Microsoft Docs: + An integer that specifies how to synchronize presentation of a frame with the vertical blank. + + +For the bit-block transfer (bitblt) model (DXGI_SWAP_EFFECT_DISCARDor DXGI_SWAP_EFFECT_SEQUENTIAL), values are: + +
    +
  • 0 - The presentation occurs immediately, there is no synchronization.
    • +
  • 1 through 4 - Synchronize presentation after the nth vertical blank.
    • +
+For the flip model (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL), values are: + +
    +
  • 0 - Cancel the remaining time on the previously presented frame and discard this frame if a newer frame is queued. +
    • +
  • 1 through 4 - Synchronize presentation for at least n vertical blanks.
    • +
+For an example that shows how sync-interval values affect a flip presentation queue, see Remarks. + +If the update region straddles more than one output (each represented by IDXGIOutput), Present performs the synchronization to the output that contains the largest sub-rectangle of the target window's client area. + An integer value that contains swap-chain presentation options. These options are defined by the DXGI_PRESENT constants. + + + + + Gets information about dirty rectangles for the current desktop frame. + Microsoft Docs: + The size in bytes of the buffer that the caller passed to the pDirtyRectsBuffer + parameter. + A pointer to an array of RECT structures + that identifies the dirty rectangle regions for the desktop frame. + Pointer to a variable that receives the number of bytes that + GetFrameDirtyRects + needs to store information about dirty regions in the buffer at + pDirtyRectsBuffer. + +For more information about returning the required buffer size, see Remarks. + + + + + Represents an adapter output (such as a monitor). The IDXGIOutput3 interface exposes a method to check for overlay support. + Microsoft Docs: + + + + + Gets the display modes that match the requested format and other input options. + Microsoft Docs: + The color format (see DXGI_FORMAT). + Options for modes to include (see DXGI_ENUM_MODES). + DXGI_ENUM_MODES_SCALING needs to be specified to expose the display modes that require scaling. Centered modes, requiring no + scaling and corresponding directly to the display output, are enumerated by default. + Set pDesc to NULL so that pNumModes returns the number of display modes that match the format and the options. + Otherwise, pNumModes returns the number of display modes returned in pDesc. + A pointer to a list of display modes (see DXGI_MODE_DESC); set to NULL to get the number of display modes. + + + + + Gets the GPU thread priority. + Microsoft Docs: + A pointer to a variable that receives a value that indicates the current GPU thread priority. The value will be between -7 and 7, inclusive, where 0 represents normal priority. + + + + + Describes the metadata for HDR10, used when video is compressed using High Efficiency Video Coding (HEVC). + Microsoft Docs: + + + + The chromaticity coordinates of the red value in the CIE1931 color space. Index 0 contains the X coordinate and index 1 contains the Y coordinate. The values are normalized to 50,000. + + + The chromaticity coordinates of the green value in the CIE1931 color space. Index 0 contains the X coordinate and index 1 contains the Y coordinate. The values are normalized to 50,000. + + + The chromaticity coordinates of the blue value in the CIE1931 color space. Index 0 contains the X coordinate and index 1 contains the Y coordinate. The values are normalized to 50,000. + + + The chromaticity coordinates of the white point in the CIE1931 color space. Index 0 contains the X coordinate and index 1 contains the Y coordinate. The values are normalized to 50,000. + + + The maximum number of nits of the display used to master the content. Values are in whole nits. + + + The minimum number of nits of the display used to master the content. Values are 1/10000th of a nit (0.0001 nit). + + + The maximum content light level (MaxCLL). This is the nit value corresponding to the brightest pixel used anywhere in the content. + + + The maximum frame average light level (MaxFALL). This is the nit value corresponding to the average luminance of the frame which has the brightest average luminance anywhere in the content. + + + + Enables creating Microsoft DirectX Graphics Infrastructure (DXGI) objects. + Microsoft Docs: + + + + + Creates a subresource surface object. + Microsoft Docs: + The index of the subresource surface object to enumerate. + The address of a pointer to a IDXGISurface2 interface that represents the created subresource surface object at the position specified by the index parameter. + + + + + The IDXGISurface1 interface extends the IDXGISurface by adding support for using Windows Graphics Device Interface (GDI) to render to a Microsoft DirectX Graphics Infrastructure (DXGI) surface. + Microsoft Docs: + + + + + Describes a debug message in the information queue. + Microsoft Docs: + + + + A DXGI_DEBUG_ID value that identifies the entity that produced the message. + + + A DXGI_INFO_QUEUE_MESSAGE_CATEGORY-typed value that specifies the category of the message. + + + A DXGI_INFO_QUEUE_MESSAGE_SEVERITY-typed value that specifies the severity of the message. + + + An integer that uniquely identifies the message. + + + The message string. + + + The length of the message string at pDescription, in bytes. + + + + Describes an adapter (or video card) by using DXGI 1.0. + Microsoft Docs: + + + + A string that contains the adapter description. On feature level 9 graphics hardware, GetDesc returns “Software Adapter” for the description string. + + + The PCI ID of the hardware vendor. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID of the hardware vendor. + + + The PCI ID of the hardware device. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID of the hardware device. + + + The PCI ID of the sub system. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID of the sub system. + + + The PCI ID of the revision number of the adapter. On feature level 9 graphics hardware, GetDesc returns zeros for the PCI ID of the revision number of the adapter. + + + The number of bytes of dedicated video memory that are not shared with the CPU. + + + The number of bytes of dedicated system memory that are not shared with the CPU. This memory is allocated from available system memory at boot time. + + + The number of bytes of shared system memory. This is the maximum value of system memory that may be consumed by the adapter during operation. Any incidental memory consumed by the driver as it manages and uses video memory is additional. + + + A unique value that identifies the adapter. See LUID for a definition of the structure. LUID is defined in dxgi.h. + + + + Represents an adapter output (such as a monitor). The IDXGIOutput4 interface exposes a method to check for overlay color space support. + Microsoft Docs: + + + + + Checks for overlay support. + Microsoft Docs: + A DXGI_FORMAT-typed value for the color format. + A pointer to the Direct3D device interface. CheckOverlaySupport returns only support info about this scan-out device. + A pointer to a variable that receives a combination of DXGI_OVERLAY_SUPPORT_FLAG-typed values that are combined by using a bitwise OR operation. The resulting value specifies options for overlay support. + + + + + Gets the size of the storage-filter stack in bytes. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that gets the size. + + + + + Restores access to resources that were previously offered by calling IDXGIDevice4::OfferResources1. + Microsoft Docs: + The number of resources in the ppResources argument and pResults argument arrays. + An array of pointers to IDXGIResource interfaces for the resources to reclaim. + A pointer to an array that receives DXGI_RECLAIM_RESOURCE_RESULTS values. Each value in the array corresponds to a resource at the same index that the ppResources parameter specifies. The caller can pass in NULL, if the caller intends to fill the resources with new content regardless of whether the old content was discarded. + + + + + Sets the rectangle that defines the target region for the video processing blit operation. + Microsoft Docs: + A pointer to a RECT structure + that contains the target region to set for the swap chain. + + + + + Resource data formats, including fully-typed and typeless formats. A list of modifiers at the bottom of the page more fully describes each format type. + Microsoft Docs: + + + + The format is not known. + + + A four-component, 128-bit typeless format that supports 32 bits per channel including alpha. ¹ + + + A four-component, 128-bit floating-point format that supports 32 bits per channel including alpha. 1,5,8 + + + A four-component, 128-bit unsigned-integer format that supports 32 bits per channel including alpha. ¹ + + + A four-component, 128-bit signed-integer format that supports 32 bits per channel including alpha. ¹ + + + A three-component, 96-bit typeless format that supports 32 bits per color channel. + + + A three-component, 96-bit floating-point format that supports 32 bits per color channel.5,8 + + + A three-component, 96-bit unsigned-integer format that supports 32 bits per color channel. + + + A three-component, 96-bit signed-integer format that supports 32 bits per color channel. + + + A four-component, 64-bit typeless format that supports 16 bits per channel including alpha. + + + A four-component, 64-bit floating-point format that supports 16 bits per channel including alpha.5,7 + + + A four-component, 64-bit unsigned-normalized-integer format that supports 16 bits per channel including alpha. + + + A four-component, 64-bit unsigned-integer format that supports 16 bits per channel including alpha. + + + A four-component, 64-bit signed-normalized-integer format that supports 16 bits per channel including alpha. + + + A four-component, 64-bit signed-integer format that supports 16 bits per channel including alpha. + + + A two-component, 64-bit typeless format that supports 32 bits for the red channel and 32 bits for the green channel. + + + A two-component, 64-bit floating-point format that supports 32 bits for the red channel and 32 bits for the green channel.5,8 + + + A two-component, 64-bit unsigned-integer format that supports 32 bits for the red channel and 32 bits for the green channel. + + + A two-component, 64-bit signed-integer format that supports 32 bits for the red channel and 32 bits for the green channel. + + + A two-component, 64-bit typeless format that supports 32 bits for the red channel, 8 bits for the green channel, and 24 bits are unused. + + + A 32-bit floating-point component, and two unsigned-integer components (with an additional 32 bits). This format supports 32-bit depth, 8-bit stencil, and 24 bits are unused.⁵ + + + A 32-bit floating-point component, and two typeless components (with an additional 32 bits). This format supports 32-bit red channel, 8 bits are unused, and 24 bits are unused.⁵ + + + A 32-bit typeless component, and two unsigned-integer components (with an additional 32 bits). This format has 32 bits unused, 8 bits for green channel, and 24 bits are unused. + + + A four-component, 32-bit typeless format that supports 10 bits for each color and 2 bits for alpha. + + + A four-component, 32-bit unsigned-normalized-integer format that supports 10 bits for each color and 2 bits for alpha. + + + A four-component, 32-bit unsigned-integer format that supports 10 bits for each color and 2 bits for alpha. + + + Three partial-precision floating-point numbers encoded into a single 32-bit value (a variant of s10e5, which is sign bit, 10-bit mantissa, and 5-bit biased (15) exponent). + There are no sign bits, and there is a 5-bit biased (15) exponent for each channel, 6-bit mantissa for R and G, and a 5-bit mantissa for B, as shown in the following illustration.5,7 + +Illustration of the bits in the three partial-precision floating-point numbers + + + A four-component, 32-bit typeless format that supports 8 bits per channel including alpha. + + + A four-component, 32-bit unsigned-normalized-integer format that supports 8 bits per channel including alpha. + + + A four-component, 32-bit unsigned-normalized integer sRGB format that supports 8 bits per channel including alpha. + + + A four-component, 32-bit unsigned-integer format that supports 8 bits per channel including alpha. + + + A four-component, 32-bit signed-normalized-integer format that supports 8 bits per channel including alpha. + + + A four-component, 32-bit signed-integer format that supports 8 bits per channel including alpha. + + + A two-component, 32-bit typeless format that supports 16 bits for the red channel and 16 bits for the green channel. + + + A two-component, 32-bit floating-point format that supports 16 bits for the red channel and 16 bits for the green channel.5,7 + + + A two-component, 32-bit unsigned-normalized-integer format that supports 16 bits each for the green and red channels. + + + A two-component, 32-bit unsigned-integer format that supports 16 bits for the red channel and 16 bits for the green channel. + + + A two-component, 32-bit signed-normalized-integer format that supports 16 bits for the red channel and 16 bits for the green channel. + + + A two-component, 32-bit signed-integer format that supports 16 bits for the red channel and 16 bits for the green channel. + + + A single-component, 32-bit typeless format that supports 32 bits for the red channel. + + + A single-component, 32-bit floating-point format that supports 32 bits for depth.5,8 + + + A single-component, 32-bit floating-point format that supports 32 bits for the red channel.5,8 + + + A single-component, 32-bit unsigned-integer format that supports 32 bits for the red channel. + + + A single-component, 32-bit signed-integer format that supports 32 bits for the red channel. + + + A two-component, 32-bit typeless format that supports 24 bits for the red channel and 8 bits for the green channel. + + + A 32-bit z-buffer format that supports 24 bits for depth and 8 bits for stencil. + + + A 32-bit format, that contains a 24 bit, single-component, unsigned-normalized integer, with an additional typeless 8 bits. This format has 24 bits red channel and 8 bits unused. + + + A 32-bit format, that contains a 24 bit, single-component, typeless format, with an additional 8 bit unsigned integer component. This format has 24 bits unused and 8 bits green channel. + + + A two-component, 16-bit typeless format that supports 8 bits for the red channel and 8 bits for the green channel. + + + A two-component, 16-bit unsigned-normalized-integer format that supports 8 bits for the red channel and 8 bits for the green channel. + + + A two-component, 16-bit unsigned-integer format that supports 8 bits for the red channel and 8 bits for the green channel. + + + A two-component, 16-bit signed-normalized-integer format that supports 8 bits for the red channel and 8 bits for the green channel. + + + A two-component, 16-bit signed-integer format that supports 8 bits for the red channel and 8 bits for the green channel. + + + A single-component, 16-bit typeless format that supports 16 bits for the red channel. + + + A single-component, 16-bit floating-point format that supports 16 bits for the red channel.5,7 + + + A single-component, 16-bit unsigned-normalized-integer format that supports 16 bits for depth. + + + A single-component, 16-bit unsigned-normalized-integer format that supports 16 bits for the red channel. + + + A single-component, 16-bit unsigned-integer format that supports 16 bits for the red channel. + + + A single-component, 16-bit signed-normalized-integer format that supports 16 bits for the red channel. + + + A single-component, 16-bit signed-integer format that supports 16 bits for the red channel. + + + A single-component, 8-bit typeless format that supports 8 bits for the red channel. + + + A single-component, 8-bit unsigned-normalized-integer format that supports 8 bits for the red channel. + + + A single-component, 8-bit unsigned-integer format that supports 8 bits for the red channel. + + + A single-component, 8-bit signed-normalized-integer format that supports 8 bits for the red channel. + + + A single-component, 8-bit signed-integer format that supports 8 bits for the red channel. + + + A single-component, 8-bit unsigned-normalized-integer format for alpha only. + + + A single-component, 1-bit unsigned-normalized integer format that supports 1 bit for the red channel. ². + + + Three partial-precision floating-point numbers encoded into a single 32-bit value all sharing the same 5-bit exponent (variant of s10e5, which is sign bit, 10-bit mantissa, and 5-bit biased (15) exponent). + There is no sign bit, and there is a shared 5-bit biased (15) exponent and a 9-bit mantissa for each channel, as shown in the following illustration. 6,7. + +Illustration of the bits in the three partial-precision floating-point numbers + + + A four-component, 32-bit unsigned-normalized-integer format. This packed RGB format is analogous to the UYVY format. Each 32-bit block describes a pair of pixels: (R8, G8, B8) and (R8, G8, B8) where the R8/B8 values are repeated, and the G8 values are unique to each pixel. ³ + +Width must be even. + + + A four-component, 32-bit unsigned-normalized-integer format. This packed RGB format is analogous to the YUY2 format. Each 32-bit block describes a pair of pixels: (R8, G8, B8) and (R8, G8, B8) where the R8/B8 values are repeated, and the G8 values are unique to each pixel. ³ + +Width must be even. + + + Four-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Four-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Four-component block-compression format for sRGB data. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Four-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Four-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Four-component block-compression format for sRGB data. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Four-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Four-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Four-component block-compression format for sRGB data. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + One-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + One-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + One-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Two-component typeless block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Two-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Two-component block-compression format. For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + A three-component, 16-bit unsigned-normalized-integer format that supports 5 bits for blue, 6 bits for green, and 5 bits for red. + +Direct3D 10 through Direct3D 11:  This value is defined for DXGI. However, Direct3D 10, 10.1, or 11 devices do not support this format. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + A four-component, 16-bit unsigned-normalized-integer format that supports 5 bits for each color channel and 1-bit alpha. + +Direct3D 10 through Direct3D 11:  This value is defined for DXGI. However, Direct3D 10, 10.1, or 11 devices do not support this format. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + A four-component, 32-bit unsigned-normalized-integer format that supports 8 bits for each color channel and 8-bit alpha. + + + A four-component, 32-bit unsigned-normalized-integer format that supports 8 bits for each color channel and 8 bits unused. + + + A four-component, 32-bit 2.8-biased fixed-point format that supports 10 bits for each color channel and 2-bit alpha. + + + A four-component, 32-bit typeless format that supports 8 bits for each channel including alpha. ⁴ + + + A four-component, 32-bit unsigned-normalized standard RGB format that supports 8 bits for each channel including alpha. ⁴ + + + A four-component, 32-bit typeless format that supports 8 bits for each color channel, and 8 bits are unused. ⁴ + + + A four-component, 32-bit unsigned-normalized standard RGB format that supports 8 bits for each color channel, and 8 bits are unused. ⁴ + + + A typeless block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + A block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11.⁵ + + + A block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11.⁵ + + + A typeless block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + A block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + A block-compression format. ⁴ For information about block-compression formats, see Texture Block Compression in Direct3D 11. + + + Most common YUV 4:4:4 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R8G8B8A8_UNORM and DXGI_FORMAT_R8G8B8A8_UINT. For UAVs, an additional valid view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R8G8B8A8_UNORM and DXGI_FORMAT_R8G8B8A8_UINT. Supported view types are SRV, RTV, and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is V->R8, +U->G8, +Y->B8, +and A->A8. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 10-bit per channel packed YUV 4:4:4 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R10G10B10A2_UNORM and DXGI_FORMAT_R10G10B10A2_UINT. For UAVs, an additional valid view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R10G10B10A2_UNORM and DXGI_FORMAT_R10G10B10A2_UINT. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is U->R10, +Y->G10, +V->B10, +and A->A2. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 16-bit per channel packed YUV 4:4:4 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R16G16B16A16_UNORM and DXGI_FORMAT_R16G16B16A16_UINT. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is U->R16, +Y->G16, +V->B16, +and A->A16. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + Most common YUV 4:2:0 video resource format. Valid luminance data view formats for this video resource format are DXGI_FORMAT_R8_UNORM and DXGI_FORMAT_R8_UINT. Valid chrominance data view formats (width and height are each 1/2 of luminance view) for this video resource format are DXGI_FORMAT_R8G8_UNORM and DXGI_FORMAT_R8G8_UINT. Supported view types are SRV, RTV, and UAV. For luminance data view, the mapping to the view channel is Y->R8. For chrominance data view, the mapping to the view channel is U->R8 and +V->G8. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Width and height must be even. Direct3D 11 staging resources and initData parameters for this format use (rowPitch * (height + (height / 2))) bytes. The first (SysMemPitch * height) bytes are the Y plane, the remaining (SysMemPitch * (height / 2)) bytes are the UV plane. + +An app using the YUY 4:2:0 formats must map the luma (Y) plane separately from the chroma (UV) planes. Developers do this by calling ID3D12Device::CreateShaderResourceView twice for the same texture and passing in 1-channel and 2-channel formats. Passing in a 1-channel format compatible with the Y plane maps only the Y plane. Passing in a 2-channel format compatible with the UV planes (together) maps only the U and V planes as a single resource view. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 10-bit per channel planar YUV 4:2:0 video resource format. Valid luminance data view formats for this video resource format are DXGI_FORMAT_R16_UNORM and DXGI_FORMAT_R16_UINT. The runtime does not enforce whether the lowest 6 bits are 0 (given that this video resource format is a 10-bit format that uses 16 bits). If required, application shader code would have to enforce this manually. From the runtime's point of view, DXGI_FORMAT_P010 is no different than DXGI_FORMAT_P016. Valid chrominance data view formats (width and height are each 1/2 of luminance view) for this video resource format are DXGI_FORMAT_R16G16_UNORM and DXGI_FORMAT_R16G16_UINT. For UAVs, an additional valid chrominance data view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R16G16_UNORM and DXGI_FORMAT_R16G16_UINT. Supported view types are SRV, RTV, and UAV. For luminance data view, the mapping to the view channel is Y->R16. For chrominance data view, the mapping to the view channel is U->R16 and +V->G16. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Width and height must be even. Direct3D 11 staging resources and initData parameters for this format use (rowPitch * (height + (height / 2))) bytes. The first (SysMemPitch * height) bytes are the Y plane, the remaining (SysMemPitch * (height / 2)) bytes are the UV plane. + +An app using the YUY 4:2:0 formats must map the luma (Y) plane separately from the chroma (UV) planes. Developers do this by calling ID3D12Device::CreateShaderResourceView twice for the same texture and passing in 1-channel and 2-channel formats. Passing in a 1-channel format compatible with the Y plane maps only the Y plane. Passing in a 2-channel format compatible with the UV planes (together) maps only the U and V planes as a single resource view. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 16-bit per channel planar YUV 4:2:0 video resource format. Valid luminance data view formats for this video resource format are DXGI_FORMAT_R16_UNORM and DXGI_FORMAT_R16_UINT. Valid chrominance data view formats (width and height are each 1/2 of luminance view) for this video resource format are DXGI_FORMAT_R16G16_UNORM and DXGI_FORMAT_R16G16_UINT. For UAVs, an additional valid chrominance data view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R16G16_UNORM and DXGI_FORMAT_R16G16_UINT. Supported view types are SRV, RTV, and UAV. For luminance data view, the mapping to the view channel is Y->R16. For chrominance data view, the mapping to the view channel is U->R16 and +V->G16. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Width and height must be even. Direct3D 11 staging resources and initData parameters for this format use (rowPitch * (height + (height / 2))) bytes. The first (SysMemPitch * height) bytes are the Y plane, the remaining (SysMemPitch * (height / 2)) bytes are the UV plane. + +An app using the YUY 4:2:0 formats must map the luma (Y) plane separately from the chroma (UV) planes. Developers do this by calling ID3D12Device::CreateShaderResourceView twice for the same texture and passing in 1-channel and 2-channel formats. Passing in a 1-channel format compatible with the Y plane maps only the Y plane. Passing in a 2-channel format compatible with the UV planes (together) maps only the U and V planes as a single resource view. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 8-bit per channel planar YUV 4:2:0 video resource format. This format is subsampled where each pixel has its own Y value, but each 2x2 pixel block shares a single U and V value. The runtime requires that the width and height of all resources that are created with this format are multiples of 2. The runtime also requires that the left, right, top, and bottom members of any RECT that are used for this format are multiples of 2. This format differs from DXGI_FORMAT_NV12 in that the layout of the data within the resource is completely opaque to applications. Applications cannot use the CPU to map the resource and then access the data within the resource. You cannot use shaders with this format. Because of this behavior, legacy hardware that supports a non-NV12 4:2:0 layout (for example, YV12, and so on) can be used. Also, new hardware that has a 4:2:0 implementation better than NV12 can be used when the application does not need the data to be in a standard layout. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Width and height must be even. Direct3D 11 staging resources and initData parameters for this format use (rowPitch * (height + (height / 2))) bytes. + +An app using the YUY 4:2:0 formats must map the luma (Y) plane separately from the chroma (UV) planes. Developers do this by calling ID3D12Device::CreateShaderResourceView twice for the same texture and passing in 1-channel and 2-channel formats. Passing in a 1-channel format compatible with the Y plane maps only the Y plane. Passing in a 2-channel format compatible with the UV planes (together) maps only the U and V planes as a single resource view. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + Most common YUV 4:2:2 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R8G8B8A8_UNORM and DXGI_FORMAT_R8G8B8A8_UINT. For UAVs, an additional valid view format is DXGI_FORMAT_R32_UINT. By using DXGI_FORMAT_R32_UINT for UAVs, you can both read and write as opposed to just write for DXGI_FORMAT_R8G8B8A8_UNORM and DXGI_FORMAT_R8G8B8A8_UINT. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is Y0->R8, +U0->G8, +Y1->B8, +and V0->A8. + +A unique valid view format for this video resource format is DXGI_FORMAT_R8G8_B8G8_UNORM. With this view format, the width of the view appears to be twice what the DXGI_FORMAT_R8G8B8A8_UNORM or DXGI_FORMAT_R8G8B8A8_UINT view would be when hardware reconstructs RGBA automatically on read and before filtering. This Direct3D hardware behavior is legacy and is likely not useful any more. With this view format, the mapping to the view channel is Y0->R8, +U0-> +G8[0], +Y1->B8, +and V0-> +G8[1]. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Width must be even. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 10-bit per channel packed YUV 4:2:2 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R16G16B16A16_UNORM and DXGI_FORMAT_R16G16B16A16_UINT. The runtime does not enforce whether the lowest 6 bits are 0 (given that this video resource format is a 10-bit format that uses 16 bits). If required, application shader code would have to enforce this manually. From the runtime's point of view, DXGI_FORMAT_Y210 is no different than DXGI_FORMAT_Y216. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is Y0->R16, +U->G16, +Y1->B16, +and V->A16. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Width must be even. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 16-bit per channel packed YUV 4:2:2 video resource format. Valid view formats for this video resource format are DXGI_FORMAT_R16G16B16A16_UNORM and DXGI_FORMAT_R16G16B16A16_UINT. Supported view types are SRV and UAV. One view provides a straightforward mapping of the entire surface. The mapping to the view channel is Y0->R16, +U->G16, +Y1->B16, +and V->A16. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Width must be even. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + Most common planar YUV 4:1:1 video resource format. Valid luminance data view formats for this video resource format are DXGI_FORMAT_R8_UNORM and DXGI_FORMAT_R8_UINT. Valid chrominance data view formats (width and height are each 1/4 of luminance view) for this video resource format are DXGI_FORMAT_R8G8_UNORM and DXGI_FORMAT_R8G8_UINT. Supported view types are SRV, RTV, and UAV. For luminance data view, the mapping to the view channel is Y->R8. For chrominance data view, the mapping to the view channel is U->R8 and +V->G8. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Width must be a multiple of 4. Direct3D11 staging resources and initData parameters for this format use (rowPitch * height * 2) bytes. The first (SysMemPitch * height) bytes are the Y plane, the next ((SysMemPitch / 2) * height) bytes are the UV plane, and the remainder is padding. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 4-bit palletized YUV format that is commonly used for DVD subpicture. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 4-bit palletized YUV format that is commonly used for DVD subpicture. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 8-bit palletized format that is used for palletized RGB data when the processor processes ISDB-T data and for palletized YUV data when the processor processes BluRay data. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + 8-bit palletized format with 8 bits of alpha that is used for palletized YUV data when the processor processes BluRay data. + +For more info about YUV formats for video rendering, see Recommended 8-Bit YUV Formats for Video Rendering. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + A four-component, 16-bit unsigned-normalized integer format that supports 4 bits for each channel including alpha. + +Direct3D 11.1:  This value is not supported until Windows 8. + + + A video format; an 8-bit version of a hybrid planar 4:2:2 format. + + + An 8 bit YCbCrA 4:4 rendering format. + + + An 8 bit YCbCrA 4:4:4:4 rendering format. + + + Forces this enumeration to compile to 32 bits in size. Without this value, some compilers would allow this enumeration to compile to a + size other than 32 bits. This value is not used. + + + + Sets the transform matrix that will be applied to a composition swap chain upon the next present. + Microsoft Docs: + The transform matrix to use for swap chain scaling and translation. This function can only be used with composition swap chains created by IDXGIFactory2::CreateSwapChainForComposition. Only scale and translation components are allowed in the matrix. + + + + + Gets the size of the destination surface to use for the video processing blit operation. + Microsoft Docs: + A pointer to a variable that receives the width in pixels. + A pointer to a variable that receives the height in pixels. + + + + + Specifies the header metadata type. + Microsoft Docs: + + + + Indicates there is no header metadata. + + + Indicates the header metadata is held by a DXGI_HDR_METADATA_HDR10 structure. + + + + Sets a message severity level to break on when a message with that severity level passes through the storage filter. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that sets the breaking condition. + A DXGI_INFO_QUEUE_MESSAGE_SEVERITY-typed value that specifies the severity of the message. + A Boolean value that specifies whether SetBreakOnSeverity turns on or off this breaking condition (TRUE for on, FALSE for off). + + + + + Indicates that the application is ready to process the next desktop image. + Microsoft Docs: + The time-out interval, in milliseconds. This interval specifies the amount of time that this method waits for a new frame before it returns to the caller. This method returns if the interval elapses, and a new desktop image is not available. + +For more information about the time-out interval, see Remarks. + A pointer to a memory location that receives the DXGI_OUTDUPL_FRAME_INFO structure that describes timing and presentation statistics for a frame. + A pointer to a variable that receives the IDXGIResource interface of the surface that contains the desktop bitmap. + + + + + Changes the display mode. + Microsoft Docs: + A pointer to a surface (see IDXGISurface) used for rendering an image to the screen. The surface must have been created as a back buffer (DXGI_USAGE_BACKBUFFER). + + + + + Represents a keyed mutex, which allows exclusive access to a shared resource that is used by multiple devices. + Microsoft Docs: + + + + + Describes information about present that helps the operating system optimize presentation. + Microsoft Docs: + + + + The number of updated rectangles that you update in the back buffer for the presented frame. The operating system uses this information to optimize presentation. You can set this member to 0 to indicate that you update the whole frame. + + + A list of updated rectangles that you update in the back buffer for the presented frame. An application must update every single pixel in each rectangle that it reports to the runtime; the application cannot assume that the pixels are saved from the previous frame. For more information about updating dirty rectangles, see Remarks. You can set this member to NULL if DirtyRectsCount is 0. An application must not update any pixel outside of the dirty rectangles. + + + A pointer to the scrolled rectangle. The scrolled rectangle is the rectangle of the previous frame from which the runtime bit-block transfers (bitblts) content. The runtime also uses the scrolled rectangle to optimize presentation in terminal server and indirect display scenarios. + +The scrolled rectangle also describes the destination rectangle, that is, the region on the current frame that is filled with scrolled content. You can set this member to NULL to indicate that no content is scrolled from the previous frame. + + + A pointer to the offset of the scrolled area that goes from the source rectangle (of previous frame) to the destination rectangle (of current frame). You can set this member to NULL to indicate no offset. + + + + Gets a Microsoft DirectX Graphics Infrastructure (DXGI) 1.2 description of an adapter or video card. + Microsoft Docs: + A pointer to a DXGI_ADAPTER_DESC2 structure that describes the adapter. + This parameter must not be NULL. On feature level 9 graphics hardware, earlier versions of GetDesc2 (GetDesc and GetDesc1) return zeros for the PCI ID in the VendorId, DeviceId, SubSysId, and Revision members of the adapter description structure and “Software Adapter” for the description string in the Description member. GetDesc2 returns the actual feature level 9 hardware values in these members. + + + + + Gets the parent of the object. + Microsoft Docs: + The ID of the requested interface. + The address of a pointer to the parent object. + + + + + An IDXGIDevice1 interface implements a derived class for DXGI objects that produce image data. + Microsoft Docs: + + + + + Get a description of the surface. + Microsoft Docs: + A pointer to the surface description (see DXGI_SURFACE_DESC). + + + + + Describes an adapter (or video card) that uses Microsoft DirectX Graphics Infrastructure (DXGI) 1.6. + Microsoft Docs: + + + + A string that contains the adapter description. + + + The PCI ID of the hardware vendor. + + + The PCI ID of the hardware device. + + + The PCI ID of the sub system. + + + The PCI ID of the revision number of the adapter. + + + The number of bytes of dedicated video memory that are not shared with the CPU. + + + The number of bytes of dedicated system memory that are not shared with the CPU. This memory is allocated from available system memory at boot time. + + + The number of bytes of shared system memory. This is the maximum value of system memory that may be consumed by the adapter during operation. Any incidental memory consumed by the driver as it manages and uses video memory is additional. + + + A unique value that identifies the adapter. See LUID for a definition of the structure. LUID is defined in dxgi.h. + + + A value of the DXGI_ADAPTER_FLAG3 enumeration that describes the adapter type. The DXGI_ADAPTER_FLAG_REMOTE flag is reserved. + + + A value of the DXGI_GRAPHICS_PREEMPTION_GRANULARITY enumerated type that describes the granularity level at which the GPU can be preempted from performing its current graphics rendering task. + + + A value of the DXGI_COMPUTE_PREEMPTION_GRANULARITY enumerated type that describes the granularity level at which the GPU can be preempted from performing its current compute task. + + + + Flags used with ReportLiveObjects to specify the amount of info to report about an object's lifetime. + Microsoft Docs: + + + + A flag that specifies to obtain a summary about an object's lifetime. + + + A flag that specifies to obtain detailed info about an object's lifetime. + + + This flag indicates to ignore objects which have no external refcounts keeping them alive. + D3D objects are printed using an external refcount and an internal refcount. + Typically, all objects are printed. + This flag means ignore the objects whose external refcount is 0, because the application is not responsible for keeping them alive. + + + A flag that specifies to obtain both a summary and detailed info about an object's lifetime. + + + + The alpha channel should be ignored and the bitmap should be rendered opaquely. + Microsoft Docs: + + + + + Registers an application window to receive notification messages of changes of stereo status. + Microsoft Docs: + The handle of the window to send a notification message to when stereo status change occurs. + Identifies the notification message to send. + A pointer to a key value that an application can pass to the IDXGIFactory2::UnregisterStereoStatus method to unregister the notification message that wMsg specifies. + + + + + Gets the number of frames that the system is allowed to queue for rendering. + Microsoft Docs: + This value is set to the number of frames that can be queued for render. + This value defaults to 3, but can range from 1 to 16. + + + + + Registers to receive notification of changes whenever the adapter enumeration state changes. + Microsoft Docs: + A handle to the event object. + A key value for the registered event. + + + + + Gets a DXGI 1.1 description of an adapter (or video card). + Microsoft Docs: + A pointer to a DXGI_ADAPTER_DESC1 structure that describes the adapter. + This parameter must not be NULL. On feature level 9 graphics hardware, GetDesc1 returns zeros for the PCI ID in the VendorId, DeviceId, SubSysId, and Revision members of DXGI_ADAPTER_DESC1 and “Software Adapter” for the description string in the Description member. + + + + + Pushes an empty retrieval filter onto the retrieval-filter stack. + Microsoft Docs: + A DXGI_DEBUG_ID value that identifies the entity that pushes the empty retrieval filter. + + + + + Registers to receive notification of changes in stereo status by using event signaling. + Microsoft Docs: + A handle to the event object that the operating system sets when notification of stereo status change occurs. The CreateEvent or OpenEvent function returns this handle. + A pointer to a key value that an application can pass to the IDXGIFactory2::UnregisterStereoStatus method to unregister the notification event that hEvent specifies. + + + + + Using a key, acquires exclusive rendering access to a shared resource. + Microsoft Docs: + A value that indicates which device to give access to. This method will succeed when the device that currently owns the surface calls + the IDXGIKeyedMutex::ReleaseSync method using the same value. This value can be any UINT64 value. + The time-out interval, in milliseconds. This method will return if the interval elapses, and the keyed mutex has not been released using the specified Key. + If this value is set to zero, the AcquireSync method will test to see if the keyed mutex has been released and returns immediately. + If this value is set to INFINITE, the time-out interval will never elapse. + + + + + This interface enables a single method to support variable refresh rate displays. + Microsoft Docs: + + + \ No newline at end of file diff --git a/src/Vortice.Win32/Generated/Graphics/Dxgi.Common.cs b/src/Vortice.Win32/Generated/Graphics/Dxgi.Common.cs index 69ad12d..2adc528 100644 --- a/src/Vortice.Win32/Generated/Graphics/Dxgi.Common.cs +++ b/src/Vortice.Win32/Generated/Graphics/Dxgi.Common.cs @@ -24,358 +24,527 @@ public static partial class Apis } #region Enums +/// /// DXGI_COLOR_SPACE_TYPE public enum ColorSpaceType : int { + /// /// DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 RgbFullG22NoneP709 = 0, + /// /// DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 RgbFullG10NoneP709 = 1, + /// /// DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709 RgbStudioG22NoneP709 = 2, + /// /// DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020 RgbStudioG22NoneP2020 = 3, + /// /// DXGI_COLOR_SPACE_RESERVED Reserved = 4, + /// /// DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601 YcbcrFullG22NoneP709X601 = 5, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 YcbcrStudioG22LeftP601 = 6, + /// /// DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601 YcbcrFullG22LeftP601 = 7, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 YcbcrStudioG22LeftP709 = 8, + /// /// DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709 YcbcrFullG22LeftP709 = 9, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020 YcbcrStudioG22LeftP2020 = 10, + /// /// DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020 YcbcrFullG22LeftP2020 = 11, + /// /// DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 RgbFullG2084NoneP2020 = 12, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020 YcbcrStudioG2084LeftP2020 = 13, + /// /// DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020 RgbStudioG2084NoneP2020 = 14, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020 YcbcrStudioG22TopleftP2020 = 15, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020 YcbcrStudioG2084TopleftP2020 = 16, + /// /// DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020 RgbFullG22NoneP2020 = 17, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020 YcbcrStudioGhlgTopleftP2020 = 18, + /// /// DXGI_COLOR_SPACE_YCBCR_FULL_GHLG_TOPLEFT_P2020 YcbcrFullGhlgTopleftP2020 = 19, + /// /// DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P709 RgbStudioG24NoneP709 = 20, + /// /// DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P2020 RgbStudioG24NoneP2020 = 21, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P709 YcbcrStudioG24LeftP709 = 22, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P2020 YcbcrStudioG24LeftP2020 = 23, + /// /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_TOPLEFT_P2020 YcbcrStudioG24TopleftP2020 = 24, + /// /// DXGI_COLOR_SPACE_CUSTOM Custom = -1, } +/// /// DXGI_FORMAT public enum Format : uint { + /// /// DXGI_FORMAT_UNKNOWN Unknown = 0, + /// /// DXGI_FORMAT_R32G32B32A32_TYPELESS R32G32B32A32Typeless = 1, + /// /// DXGI_FORMAT_R32G32B32A32_FLOAT R32G32B32A32Float = 2, + /// /// DXGI_FORMAT_R32G32B32A32_UINT R32G32B32A32Uint = 3, + /// /// DXGI_FORMAT_R32G32B32A32_SINT R32G32B32A32Sint = 4, + /// /// DXGI_FORMAT_R32G32B32_TYPELESS R32G32B32Typeless = 5, + /// /// DXGI_FORMAT_R32G32B32_FLOAT R32G32B32Float = 6, + /// /// DXGI_FORMAT_R32G32B32_UINT R32G32B32Uint = 7, + /// /// DXGI_FORMAT_R32G32B32_SINT R32G32B32Sint = 8, + /// /// DXGI_FORMAT_R16G16B16A16_TYPELESS R16G16B16A16Typeless = 9, + /// /// DXGI_FORMAT_R16G16B16A16_FLOAT R16G16B16A16Float = 10, + /// /// DXGI_FORMAT_R16G16B16A16_UNORM R16G16B16A16Unorm = 11, + /// /// DXGI_FORMAT_R16G16B16A16_UINT R16G16B16A16Uint = 12, + /// /// DXGI_FORMAT_R16G16B16A16_SNORM R16G16B16A16Snorm = 13, + /// /// DXGI_FORMAT_R16G16B16A16_SINT R16G16B16A16Sint = 14, + /// /// DXGI_FORMAT_R32G32_TYPELESS R32G32Typeless = 15, + /// /// DXGI_FORMAT_R32G32_FLOAT R32G32Float = 16, + /// /// DXGI_FORMAT_R32G32_UINT R32G32Uint = 17, + /// /// DXGI_FORMAT_R32G32_SINT R32G32Sint = 18, + /// /// DXGI_FORMAT_R32G8X24_TYPELESS R32G8X24Typeless = 19, + /// /// DXGI_FORMAT_D32_FLOAT_S8X24_UINT D32FloatS8X24Uint = 20, + /// /// DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS R32FloatX8X24Typeless = 21, + /// /// DXGI_FORMAT_X32_TYPELESS_G8X24_UINT X32TypelessG8X24Uint = 22, + /// /// DXGI_FORMAT_R10G10B10A2_TYPELESS R10G10B10A2Typeless = 23, + /// /// DXGI_FORMAT_R10G10B10A2_UNORM R10G10B10A2Unorm = 24, + /// /// DXGI_FORMAT_R10G10B10A2_UINT R10G10B10A2Uint = 25, + /// /// DXGI_FORMAT_R11G11B10_FLOAT R11G11B10Float = 26, + /// /// DXGI_FORMAT_R8G8B8A8_TYPELESS R8G8B8A8Typeless = 27, + /// /// DXGI_FORMAT_R8G8B8A8_UNORM R8G8B8A8Unorm = 28, + /// /// DXGI_FORMAT_R8G8B8A8_UNORM_SRGB R8G8B8A8UnormSrgb = 29, + /// /// DXGI_FORMAT_R8G8B8A8_UINT R8G8B8A8Uint = 30, + /// /// DXGI_FORMAT_R8G8B8A8_SNORM R8G8B8A8Snorm = 31, + /// /// DXGI_FORMAT_R8G8B8A8_SINT R8G8B8A8Sint = 32, + /// /// DXGI_FORMAT_R16G16_TYPELESS R16G16Typeless = 33, + /// /// DXGI_FORMAT_R16G16_FLOAT R16G16Float = 34, + /// /// DXGI_FORMAT_R16G16_UNORM R16G16Unorm = 35, + /// /// DXGI_FORMAT_R16G16_UINT R16G16Uint = 36, + /// /// DXGI_FORMAT_R16G16_SNORM R16G16Snorm = 37, + /// /// DXGI_FORMAT_R16G16_SINT R16G16Sint = 38, + /// /// DXGI_FORMAT_R32_TYPELESS R32Typeless = 39, + /// /// DXGI_FORMAT_D32_FLOAT D32Float = 40, + /// /// DXGI_FORMAT_R32_FLOAT R32Float = 41, + /// /// DXGI_FORMAT_R32_UINT R32Uint = 42, + /// /// DXGI_FORMAT_R32_SINT R32Sint = 43, + /// /// DXGI_FORMAT_R24G8_TYPELESS R24G8Typeless = 44, + /// /// DXGI_FORMAT_D24_UNORM_S8_UINT D24UnormS8Uint = 45, + /// /// DXGI_FORMAT_R24_UNORM_X8_TYPELESS R24UnormX8Typeless = 46, + /// /// DXGI_FORMAT_X24_TYPELESS_G8_UINT X24TypelessG8Uint = 47, + /// /// DXGI_FORMAT_R8G8_TYPELESS R8G8Typeless = 48, + /// /// DXGI_FORMAT_R8G8_UNORM R8G8Unorm = 49, + /// /// DXGI_FORMAT_R8G8_UINT R8G8Uint = 50, + /// /// DXGI_FORMAT_R8G8_SNORM R8G8Snorm = 51, + /// /// DXGI_FORMAT_R8G8_SINT R8G8Sint = 52, + /// /// DXGI_FORMAT_R16_TYPELESS R16Typeless = 53, + /// /// DXGI_FORMAT_R16_FLOAT R16Float = 54, + /// /// DXGI_FORMAT_D16_UNORM D16Unorm = 55, + /// /// DXGI_FORMAT_R16_UNORM R16Unorm = 56, + /// /// DXGI_FORMAT_R16_UINT R16Uint = 57, + /// /// DXGI_FORMAT_R16_SNORM R16Snorm = 58, + /// /// DXGI_FORMAT_R16_SINT R16Sint = 59, + /// /// DXGI_FORMAT_R8_TYPELESS R8Typeless = 60, + /// /// DXGI_FORMAT_R8_UNORM R8Unorm = 61, + /// /// DXGI_FORMAT_R8_UINT R8Uint = 62, + /// /// DXGI_FORMAT_R8_SNORM R8Snorm = 63, + /// /// DXGI_FORMAT_R8_SINT R8Sint = 64, + /// /// DXGI_FORMAT_A8_UNORM A8Unorm = 65, + /// /// DXGI_FORMAT_R1_UNORM R1Unorm = 66, + /// /// DXGI_FORMAT_R9G9B9E5_SHAREDEXP R9G9B9E5SharedExp = 67, + /// /// DXGI_FORMAT_R8G8_B8G8_UNORM R8G8B8G8Unorm = 68, + /// /// DXGI_FORMAT_G8R8_G8B8_UNORM G8R8G8B8Unorm = 69, + /// /// DXGI_FORMAT_BC1_TYPELESS BC1Typeless = 70, + /// /// DXGI_FORMAT_BC1_UNORM BC1Unorm = 71, + /// /// DXGI_FORMAT_BC1_UNORM_SRGB BC1UnormSrgb = 72, + /// /// DXGI_FORMAT_BC2_TYPELESS BC2Typeless = 73, + /// /// DXGI_FORMAT_BC2_UNORM BC2Unorm = 74, + /// /// DXGI_FORMAT_BC2_UNORM_SRGB BC2UnormSrgb = 75, + /// /// DXGI_FORMAT_BC3_TYPELESS BC3Typeless = 76, + /// /// DXGI_FORMAT_BC3_UNORM BC3Unorm = 77, + /// /// DXGI_FORMAT_BC3_UNORM_SRGB BC3UnormSrgb = 78, + /// /// DXGI_FORMAT_BC4_TYPELESS BC4Typeless = 79, + /// /// DXGI_FORMAT_BC4_UNORM BC4Unorm = 80, + /// /// DXGI_FORMAT_BC4_SNORM BC4Snorm = 81, + /// /// DXGI_FORMAT_BC5_TYPELESS BC5Typeless = 82, + /// /// DXGI_FORMAT_BC5_UNORM BC5Unorm = 83, + /// /// DXGI_FORMAT_BC5_SNORM BC5Snorm = 84, + /// /// DXGI_FORMAT_B5G6R5_UNORM B5G6R5Unorm = 85, + /// /// DXGI_FORMAT_B5G5R5A1_UNORM B5G5R5A1Unorm = 86, + /// /// DXGI_FORMAT_B8G8R8A8_UNORM B8G8R8A8Unorm = 87, + /// /// DXGI_FORMAT_B8G8R8X8_UNORM B8G8R8X8Unorm = 88, + /// /// DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM R10G10B10XRBIASA2Unorm = 89, + /// /// DXGI_FORMAT_B8G8R8A8_TYPELESS B8G8R8A8Typeless = 90, + /// /// DXGI_FORMAT_B8G8R8A8_UNORM_SRGB B8G8R8A8UnormSrgb = 91, + /// /// DXGI_FORMAT_B8G8R8X8_TYPELESS B8G8R8X8Typeless = 92, + /// /// DXGI_FORMAT_B8G8R8X8_UNORM_SRGB B8G8R8X8UnormSrgb = 93, + /// /// DXGI_FORMAT_BC6H_TYPELESS BC6HTypeless = 94, + /// /// DXGI_FORMAT_BC6H_UF16 BC6HUF16 = 95, + /// /// DXGI_FORMAT_BC6H_SF16 BC6HSF16 = 96, + /// /// DXGI_FORMAT_BC7_TYPELESS BC7Typeless = 97, + /// /// DXGI_FORMAT_BC7_UNORM BC7Unorm = 98, + /// /// DXGI_FORMAT_BC7_UNORM_SRGB BC7UnormSrgb = 99, + /// /// DXGI_FORMAT_AYUV AYUV = 100, + /// /// DXGI_FORMAT_Y410 Y410 = 101, + /// /// DXGI_FORMAT_Y416 Y416 = 102, + /// /// DXGI_FORMAT_NV12 NV12 = 103, + /// /// DXGI_FORMAT_P010 P010 = 104, + /// /// DXGI_FORMAT_P016 P016 = 105, + /// /// DXGI_FORMAT_420_OPAQUE Opaque420 = 106, + /// /// DXGI_FORMAT_YUY2 YUY2 = 107, + /// /// DXGI_FORMAT_Y210 Y210 = 108, + /// /// DXGI_FORMAT_Y216 Y216 = 109, + /// /// DXGI_FORMAT_NV11 NV11 = 110, + /// /// DXGI_FORMAT_AI44 AI44 = 111, + /// /// DXGI_FORMAT_IA44 IA44 = 112, + /// /// DXGI_FORMAT_P8 P8 = 113, + /// /// DXGI_FORMAT_A8P8 A8P8 = 114, + /// /// DXGI_FORMAT_B4G4R4A4_UNORM B4G4R4A4Unorm = 115, + /// /// DXGI_FORMAT_P208 P208 = 130, + /// /// DXGI_FORMAT_V208 V208 = 131, + /// /// DXGI_FORMAT_V408 V408 = 132, + /// /// DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE SamplerFeedbackMinMipOpaque = 189, + /// /// DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE SamplerFeedbackMipRegionUsedOpaque = 190, } +/// /// DXGI_MODE_SCANLINE_ORDER public enum ModeScanlineOrder : int { + /// /// DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED Unspecified = 0, + /// /// DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE Progressive = 1, + /// /// DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST UpperFieldFirst = 2, + /// /// DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST LowerFieldFirst = 3, } +/// /// DXGI_MODE_SCALING public enum ModeScaling : int { + /// /// DXGI_MODE_SCALING_UNSPECIFIED Unspecified = 0, + /// /// DXGI_MODE_SCALING_CENTERED Centered = 1, + /// /// DXGI_MODE_SCALING_STRETCHED Stretched = 2, } +/// /// DXGI_MODE_ROTATION public enum ModeRotation : int { + /// /// DXGI_MODE_ROTATION_UNSPECIFIED Unspecified = 0, + /// /// DXGI_MODE_ROTATION_IDENTITY Identity = 1, + /// /// DXGI_MODE_ROTATION_ROTATE90 Rotate90 = 2, + /// /// DXGI_MODE_ROTATION_ROTATE180 Rotate180 = 3, + /// /// DXGI_MODE_ROTATION_ROTATE270 Rotate270 = 4, } +/// /// DXGI_ALPHA_MODE public enum AlphaMode : uint { + /// /// DXGI_ALPHA_MODE_UNSPECIFIED Unspecified = 0, + /// /// DXGI_ALPHA_MODE_PREMULTIPLIED Premultiplied = 1, + /// /// DXGI_ALPHA_MODE_STRAIGHT Straight = 2, + /// /// DXGI_ALPHA_MODE_IGNORE Ignore = 3, } @@ -401,33 +570,47 @@ public enum CpuAccess : uint #endregion Generated Enums #region Structs +/// /// DXGI_RATIONAL public partial struct Rational { + /// public uint Numerator; + /// public uint Denominator; } +/// /// DXGI_SAMPLE_DESC public partial struct SampleDescription { + /// public uint Count; + /// public uint Quality; } +/// /// DXGI_RGB public partial struct Rgb { + /// public float Red; + /// public float Green; + /// public float Blue; } +/// /// DXGI_GAMMA_CONTROL public partial struct GammaControl { + /// public Rgb Scale; + /// public Rgb Offset; + /// public GammaCurve__FixedBuffer GammaCurve; public unsafe struct GammaCurve__FixedBuffer @@ -1477,44 +1660,65 @@ public partial struct GammaControl } } +/// /// DXGI_GAMMA_CONTROL_CAPABILITIES public partial struct GammaControlCapabilities { + /// public Bool32 ScaleAndOffsetSupported; + /// public float MaxConvertedValue; + /// public float MinConvertedValue; + /// public uint NumGammaControlPoints; + /// public unsafe fixed float ControlPointPositions[1025]; } +/// /// DXGI_MODE_DESC public partial struct ModeDescription { + /// public uint Width; + /// public uint Height; + /// public Rational RefreshRate; + /// public Format Format; + /// public ModeScanlineOrder ScanlineOrdering; + /// public ModeScaling Scaling; } +/// /// DXGI_JPEG_DC_HUFFMAN_TABLE public partial struct JpegDcHuffmanTable { + /// public unsafe fixed byte CodeCounts[12]; + /// public unsafe fixed byte CodeValues[12]; } +/// /// DXGI_JPEG_AC_HUFFMAN_TABLE public partial struct JpegAcHuffmanTable { + /// public unsafe fixed byte CodeCounts[16]; + /// public unsafe fixed byte CodeValues[162]; } +/// /// DXGI_JPEG_QUANTIZATION_TABLE public partial struct JpegQuantizationTable { + /// public unsafe fixed byte Elements[64]; } diff --git a/src/Vortice.Win32/Generated/Graphics/Dxgi.cs b/src/Vortice.Win32/Generated/Graphics/Dxgi.cs index f9e0fc0..c9ab871 100644 --- a/src/Vortice.Win32/Generated/Graphics/Dxgi.cs +++ b/src/Vortice.Win32/Generated/Graphics/Dxgi.cs @@ -65,1016 +65,1478 @@ public static partial class Apis } #region Enums +/// /// DXGI_RESOURCE_PRIORITY public enum ResourcePriority : uint { + /// /// DXGI_RESOURCE_PRIORITY_MINIMUM Minimum = 671088640, + /// /// DXGI_RESOURCE_PRIORITY_LOW Low = 1342177280, + /// /// DXGI_RESOURCE_PRIORITY_NORMAL Normal = 2013265920, + /// /// DXGI_RESOURCE_PRIORITY_HIGH High = 2684354560, + /// /// DXGI_RESOURCE_PRIORITY_MAXIMUM Maximum = 3355443200, } +/// /// DXGI_RESIDENCY public enum Residency : int { + /// /// DXGI_RESIDENCY_FULLY_RESIDENT FullyResident = 1, + /// /// DXGI_RESIDENCY_RESIDENT_IN_SHARED_MEMORY ResidentInSharedMemory = 2, + /// /// DXGI_RESIDENCY_EVICTED_TO_DISK EvictedToDisk = 3, } +/// /// DXGI_SWAP_EFFECT public enum SwapEffect : int { + /// /// DXGI_SWAP_EFFECT_DISCARD Discard = 0, + /// /// DXGI_SWAP_EFFECT_SEQUENTIAL Sequential = 1, + /// /// DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL FlipSequential = 3, + /// /// DXGI_SWAP_EFFECT_FLIP_DISCARD FlipDiscard = 4, } +/// /// DXGI_SWAP_CHAIN_FLAG public enum SwapChainFlags : int { + /// /// DXGI_SWAP_CHAIN_FLAG_NONPREROTATED NonPrerotated = 1, + /// /// DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH AllowModeSwitch = 2, + /// /// DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE GDICompatible = 4, + /// /// DXGI_SWAP_CHAIN_FLAG_RESTRICTED_CONTENT RestrictedContent = 8, + /// /// DXGI_SWAP_CHAIN_FLAG_RESTRICT_SHARED_RESOURCE_DRIVER RestrictSharedResourceDriver = 16, + /// /// DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY DisplayOnly = 32, + /// /// DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT FrameLatencyWaitableObject = 64, + /// /// DXGI_SWAP_CHAIN_FLAG_FOREGROUND_LAYER ForegroundLayer = 128, + /// /// DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO FullscreenVideo = 256, + /// /// DXGI_SWAP_CHAIN_FLAG_YUV_VIDEO YUVVideo = 512, + /// /// DXGI_SWAP_CHAIN_FLAG_HW_PROTECTED HWProtected = 1024, + /// /// DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING AllowTearing = 2048, + /// /// DXGI_SWAP_CHAIN_FLAG_RESTRICTED_TO_ALL_HOLOGRAPHIC_DISPLAYS RestrictedToAllHolographicDisplays = 4096, } +/// /// DXGI_ADAPTER_FLAG [Flags] public enum AdapterFlags : uint { + /// /// DXGI_ADAPTER_FLAG_NONE None = 0, + /// /// DXGI_ADAPTER_FLAG_REMOTE Remote = 1, + /// /// DXGI_ADAPTER_FLAG_SOFTWARE Software = 2, } +/// /// DXGI_OUTDUPL_POINTER_SHAPE_TYPE public enum OutduplPointerShapeType : int { + /// /// DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME Monochrome = 1, + /// /// DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR Color = 2, + /// /// DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR MaskedColor = 4, } +/// /// DXGI_OFFER_RESOURCE_PRIORITY public enum OfferResourcePriority : int { + /// /// DXGI_OFFER_RESOURCE_PRIORITY_LOW Low = 1, + /// /// DXGI_OFFER_RESOURCE_PRIORITY_NORMAL Normal = 2, + /// /// DXGI_OFFER_RESOURCE_PRIORITY_HIGH High = 3, } +/// /// DXGI_SCALING public enum Scaling : int { + /// /// DXGI_SCALING_STRETCH Stretch = 0, + /// /// DXGI_SCALING_NONE None = 1, + /// /// DXGI_SCALING_ASPECT_RATIO_STRETCH AspectRatioStretch = 2, } +/// /// DXGI_GRAPHICS_PREEMPTION_GRANULARITY public enum GraphicsPreemptionGranularity : int { + /// /// DXGI_GRAPHICS_PREEMPTION_DMA_BUFFER_BOUNDARY DmaBufferBoundary = 0, + /// /// DXGI_GRAPHICS_PREEMPTION_PRIMITIVE_BOUNDARY PrimitiveBoundary = 1, + /// /// DXGI_GRAPHICS_PREEMPTION_TRIANGLE_BOUNDARY TriangleBoundary = 2, + /// /// DXGI_GRAPHICS_PREEMPTION_PIXEL_BOUNDARY PixelBoundary = 3, + /// /// DXGI_GRAPHICS_PREEMPTION_INSTRUCTION_BOUNDARY InstructionBoundary = 4, } +/// /// DXGI_COMPUTE_PREEMPTION_GRANULARITY public enum ComputePreemptionGranularity : int { + /// /// DXGI_COMPUTE_PREEMPTION_DMA_BUFFER_BOUNDARY DmaBufferBoundary = 0, + /// /// DXGI_COMPUTE_PREEMPTION_DISPATCH_BOUNDARY DispatchBoundary = 1, + /// /// DXGI_COMPUTE_PREEMPTION_THREAD_GROUP_BOUNDARY ThreadGroupBoundary = 2, + /// /// DXGI_COMPUTE_PREEMPTION_THREAD_BOUNDARY ThreadBoundary = 3, + /// /// DXGI_COMPUTE_PREEMPTION_INSTRUCTION_BOUNDARY InstructionBoundary = 4, } +/// /// DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAGS public enum MultiplaneOverlayYcbcrFlags : int { + /// /// DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAG_NOMINAL_RANGE YcbcrFlagNominalRange = 1, + /// /// DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAG_BT709 YcbcrFlagBt709 = 2, + /// /// DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAG_xvYCC YcbcrFlagXvycc = 4, } +/// /// DXGI_FRAME_PRESENTATION_MODE public enum FramePresentationMode : int { + /// /// DXGI_FRAME_PRESENTATION_MODE_COMPOSED Composed = 0, + /// /// DXGI_FRAME_PRESENTATION_MODE_OVERLAY Overlay = 1, + /// /// DXGI_FRAME_PRESENTATION_MODE_NONE None = 2, + /// /// DXGI_FRAME_PRESENTATION_MODE_COMPOSITION_FAILURE CompositionFailure = 3, } +/// /// DXGI_OVERLAY_SUPPORT_FLAG public enum OverlaySupportFlag : int { + /// /// DXGI_OVERLAY_SUPPORT_FLAG_DIRECT Direct = 1, + /// /// DXGI_OVERLAY_SUPPORT_FLAG_SCALING Scaling = 2, } +/// /// DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG public enum SwapChainColorSpaceSupportFlag : int { + /// /// DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT Present = 1, + /// /// DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_OVERLAY_PRESENT OverlayPresent = 2, } +/// /// DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG public enum OverlayColorSpaceSupportFlag : int { + /// /// DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG_PRESENT Present = 1, } +/// /// DXGI_MEMORY_SEGMENT_GROUP public enum MemorySegmentGroup : int { + /// /// DXGI_MEMORY_SEGMENT_GROUP_LOCAL Local = 0, + /// /// DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL NonLocal = 1, } +/// /// DXGI_OUTDUPL_FLAG public enum OutduplFlag : int { + /// /// DXGI_OUTDUPL_COMPOSITED_UI_CAPTURE_ONLY CompositedUICaptureOnly = 1, } +/// /// DXGI_HDR_METADATA_TYPE public enum HdrMetadataType : int { + /// /// DXGI_HDR_METADATA_TYPE_NONE None = 0, + /// /// DXGI_HDR_METADATA_TYPE_HDR10 Hdr10 = 1, + /// /// DXGI_HDR_METADATA_TYPE_HDR10PLUS Hdr10plus = 2, } +/// /// DXGI_OFFER_RESOURCE_FLAGS public enum OfferResourceFlags : int { + /// /// DXGI_OFFER_RESOURCE_FLAG_ALLOW_DECOMMIT AllowDecommit = 1, } +/// /// DXGI_RECLAIM_RESOURCE_RESULTS public enum ReclaimResourceResults : int { + /// /// DXGI_RECLAIM_RESOURCE_RESULT_OK Ok = 0, + /// /// DXGI_RECLAIM_RESOURCE_RESULT_DISCARDED Discarded = 1, + /// /// DXGI_RECLAIM_RESOURCE_RESULT_NOT_COMMITTED NotCommitted = 2, } +/// /// DXGI_FEATURE public enum Feature : int { + /// /// DXGI_FEATURE_PRESENT_ALLOW_TEARING PresentAllowTearing = 0, } +/// /// DXGI_ADAPTER_FLAG3 [Flags] public enum AdapterFlags3 : uint { + /// /// DXGI_ADAPTER_FLAG3_NONE None = 0, + /// /// DXGI_ADAPTER_FLAG3_REMOTE Remote = 1, + /// /// DXGI_ADAPTER_FLAG3_SOFTWARE Software = 2, + /// /// DXGI_ADAPTER_FLAG3_ACG_COMPATIBLE AcgCompatible = 4, + /// /// DXGI_ADAPTER_FLAG3_SUPPORT_MONITORED_FENCES SupportMonitoredFences = 8, + /// /// DXGI_ADAPTER_FLAG3_SUPPORT_NON_MONITORED_FENCES SupportNonMonitoredFences = 16, + /// /// DXGI_ADAPTER_FLAG3_KEYED_MUTEX_CONFORMANCE KeyedMutexConformance = 32, } +/// /// DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAGS [Flags] public enum HardwareCompositionSupportFlags : uint { None = 0, + /// /// DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAG_FULLSCREEN Fullscreen = 1, + /// /// DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAG_WINDOWED Windowed = 2, + /// /// DXGI_HARDWARE_COMPOSITION_SUPPORT_FLAG_CURSOR_STRETCHED CursorStretched = 4, } +/// /// DXGI_GPU_PREFERENCE public enum GpuPreference : int { + /// /// DXGI_GPU_PREFERENCE_UNSPECIFIED Unspecified = 0, + /// /// DXGI_GPU_PREFERENCE_MINIMUM_POWER MinimumPower = 1, + /// /// DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE HighPerformance = 2, } +/// /// DXGI_DEBUG_RLO_FLAGS [Flags] public enum DebugRloFlags : uint { None = 0, + /// /// DXGI_DEBUG_RLO_SUMMARY Summary = 1, + /// /// DXGI_DEBUG_RLO_DETAIL Detail = 2, + /// /// DXGI_DEBUG_RLO_IGNORE_INTERNAL IgnoreInternal = 4, + /// /// DXGI_DEBUG_RLO_ALL All = 7, } +/// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY public enum InfoQueueMessageCategory : int { + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_UNKNOWN Unknown = 0, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_MISCELLANEOUS Miscellaneous = 1, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_INITIALIZATION Initialization = 2, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_CLEANUP Cleanup = 3, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_COMPILATION Compilation = 4, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_CREATION StateCreation = 5, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_SETTING StateSetting = 6, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_STATE_GETTING StateGetting = 7, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_RESOURCE_MANIPULATION ResourceManipulation = 8, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_EXECUTION Execution = 9, + /// /// DXGI_INFO_QUEUE_MESSAGE_CATEGORY_SHADER Shader = 10, } +/// /// DXGI_INFO_QUEUE_MESSAGE_SEVERITY public enum InfoQueueMessageSeverity : int { + /// /// DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION Corruption = 0, + /// /// DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR Error = 1, + /// /// DXGI_INFO_QUEUE_MESSAGE_SEVERITY_WARNING Warning = 2, + /// /// DXGI_INFO_QUEUE_MESSAGE_SEVERITY_INFO Info = 3, + /// /// DXGI_INFO_QUEUE_MESSAGE_SEVERITY_MESSAGE Message = 4, } +/// /// DXGI_Message_Id public enum MessageId : int { + /// /// DXGI_MSG_IDXGISwapChain_CreationOrResizeBuffers_InvalidOutputWindow IDXGISwapChain_CreationOrResizeBuffers_InvalidOutputWindow = 0, + /// /// DXGI_MSG_IDXGISwapChain_CreationOrResizeBuffers_BufferWidthInferred IDXGISwapChain_CreationOrResizeBuffers_BufferWidthInferred = 1, + /// /// DXGI_MSG_IDXGISwapChain_CreationOrResizeBuffers_BufferHeightInferred IDXGISwapChain_CreationOrResizeBuffers_BufferHeightInferred = 2, + /// /// DXGI_MSG_IDXGISwapChain_CreationOrResizeBuffers_NoScanoutFlagChanged IDXGISwapChain_CreationOrResizeBuffers_NoScanoutFlagChanged = 3, + /// /// DXGI_MSG_IDXGISwapChain_Creation_MaxBufferCountExceeded IDXGISwapChain_Creation_MaxBufferCountExceeded = 4, + /// /// DXGI_MSG_IDXGISwapChain_Creation_TooFewBuffers IDXGISwapChain_Creation_TooFewBuffers = 5, + /// /// DXGI_MSG_IDXGISwapChain_Creation_NoOutputWindow IDXGISwapChain_Creation_NoOutputWindow = 6, + /// /// DXGI_MSG_IDXGISwapChain_Destruction_OtherMethodsCalled IDXGISwapChain_Destruction_OtherMethodsCalled = 7, + /// /// DXGI_MSG_IDXGISwapChain_GetDesc_pDescIsNULL IDXGISwapChain_GetDesc_pDescIsNULL = 8, + /// /// DXGI_MSG_IDXGISwapChain_GetBuffer_ppSurfaceIsNULL IDXGISwapChain_GetBuffer_ppSurfaceIsNULL = 9, + /// /// DXGI_MSG_IDXGISwapChain_GetBuffer_NoAllocatedBuffers IDXGISwapChain_GetBuffer_NoAllocatedBuffers = 10, + /// /// DXGI_MSG_IDXGISwapChain_GetBuffer_iBufferMustBeZero IDXGISwapChain_GetBuffer_iBufferMustBeZero = 11, + /// /// DXGI_MSG_IDXGISwapChain_GetBuffer_iBufferOOB IDXGISwapChain_GetBuffer_iBufferOOB = 12, + /// /// DXGI_MSG_IDXGISwapChain_GetContainingOutput_ppOutputIsNULL IDXGISwapChain_GetContainingOutput_ppOutputIsNULL = 13, + /// /// DXGI_MSG_IDXGISwapChain_Present_SyncIntervalOOB IDXGISwapChain_Present_SyncIntervalOOB = 14, + /// /// DXGI_MSG_IDXGISwapChain_Present_InvalidNonPreRotatedFlag IDXGISwapChain_Present_InvalidNonPreRotatedFlag = 15, + /// /// DXGI_MSG_IDXGISwapChain_Present_NoAllocatedBuffers IDXGISwapChain_Present_NoAllocatedBuffers = 16, + /// /// DXGI_MSG_IDXGISwapChain_Present_GetDXGIAdapterFailed IDXGISwapChain_Present_GetDXGIAdapterFailed = 17, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_BufferCountOOB IDXGISwapChain_ResizeBuffers_BufferCountOOB = 18, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_UnreleasedReferences IDXGISwapChain_ResizeBuffers_UnreleasedReferences = 19, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_InvalidSwapChainFlag IDXGISwapChain_ResizeBuffers_InvalidSwapChainFlag = 20, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_InvalidNonPreRotatedFlag IDXGISwapChain_ResizeBuffers_InvalidNonPreRotatedFlag = 21, + /// /// DXGI_MSG_IDXGISwapChain_ResizeTarget_RefreshRateDivideByZero IDXGISwapChain_ResizeTarget_RefreshRateDivideByZero = 22, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_InvalidTarget IDXGISwapChain_SetFullscreenState_InvalidTarget = 23, + /// /// DXGI_MSG_IDXGISwapChain_GetFrameStatistics_pStatsIsNULL IDXGISwapChain_GetFrameStatistics_pStatsIsNULL = 24, + /// /// DXGI_MSG_IDXGISwapChain_GetLastPresentCount_pLastPresentCountIsNULL IDXGISwapChain_GetLastPresentCount_pLastPresentCountIsNULL = 25, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_RemoteNotSupported IDXGISwapChain_SetFullscreenState_RemoteNotSupported = 26, + /// /// DXGI_MSG_IDXGIOutput_TakeOwnership_FailedToAcquireFullscreenMutex IDXGIOutput_TakeOwnership_FailedToAcquireFullscreenMutex = 27, + /// /// DXGI_MSG_IDXGIFactory_CreateSoftwareAdapter_ppAdapterInterfaceIsNULL IDXGIFactory_CreateSoftwareAdapter_ppAdapterInterfaceIsNULL = 28, + /// /// DXGI_MSG_IDXGIFactory_EnumAdapters_ppAdapterInterfaceIsNULL IDXGIFactory_EnumAdapters_ppAdapterInterfaceIsNULL = 29, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_ppSwapChainIsNULL IDXGIFactory_CreateSwapChain_ppSwapChainIsNULL = 30, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_pDescIsNULL IDXGIFactory_CreateSwapChain_pDescIsNULL = 31, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_UnknownSwapEffect IDXGIFactory_CreateSwapChain_UnknownSwapEffect = 32, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_InvalidFlags IDXGIFactory_CreateSwapChain_InvalidFlags = 33, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_NonPreRotatedFlagAndWindowed IDXGIFactory_CreateSwapChain_NonPreRotatedFlagAndWindowed = 34, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_NullDeviceInterface IDXGIFactory_CreateSwapChain_NullDeviceInterface = 35, + /// /// DXGI_MSG_IDXGIFactory_GetWindowAssociation_phWndIsNULL IDXGIFactory_GetWindowAssociation_phWndIsNULL = 36, + /// /// DXGI_MSG_IDXGIFactory_MakeWindowAssociation_InvalidFlags IDXGIFactory_MakeWindowAssociation_InvalidFlags = 37, + /// /// DXGI_MSG_IDXGISurface_Map_InvalidSurface IDXGISurface_Map_InvalidSurface = 38, + /// /// DXGI_MSG_IDXGISurface_Map_FlagsSetToZero IDXGISurface_Map_FlagsSetToZero = 39, + /// /// DXGI_MSG_IDXGISurface_Map_DiscardAndReadFlagSet IDXGISurface_Map_DiscardAndReadFlagSet = 40, + /// /// DXGI_MSG_IDXGISurface_Map_DiscardButNotWriteFlagSet IDXGISurface_Map_DiscardButNotWriteFlagSet = 41, + /// /// DXGI_MSG_IDXGISurface_Map_NoCPUAccess IDXGISurface_Map_NoCPUAccess = 42, + /// /// DXGI_MSG_IDXGISurface_Map_ReadFlagSetButCPUAccessIsDynamic IDXGISurface_Map_ReadFlagSetButCPUAccessIsDynamic = 43, + /// /// DXGI_MSG_IDXGISurface_Map_DiscardFlagSetButCPUAccessIsNotDynamic IDXGISurface_Map_DiscardFlagSetButCPUAccessIsNotDynamic = 44, + /// /// DXGI_MSG_IDXGIOutput_GetDisplayModeList_pNumModesIsNULL IDXGIOutput_GetDisplayModeList_pNumModesIsNULL = 45, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_ModeHasInvalidWidthOrHeight IDXGIOutput_FindClosestMatchingMode_ModeHasInvalidWidthOrHeight = 46, + /// /// DXGI_MSG_IDXGIOutput_GetCammaControlCapabilities_NoOwnerDevice IDXGIOutput_GetCammaControlCapabilities_NoOwnerDevice = 47, + /// /// DXGI_MSG_IDXGIOutput_TakeOwnership_pDeviceIsNULL IDXGIOutput_TakeOwnership_pDeviceIsNULL = 48, + /// /// DXGI_MSG_IDXGIOutput_GetDisplaySurfaceData_NoOwnerDevice IDXGIOutput_GetDisplaySurfaceData_NoOwnerDevice = 49, + /// /// DXGI_MSG_IDXGIOutput_GetDisplaySurfaceData_pDestinationIsNULL IDXGIOutput_GetDisplaySurfaceData_pDestinationIsNULL = 50, + /// /// DXGI_MSG_IDXGIOutput_GetDisplaySurfaceData_MapOfDestinationFailed IDXGIOutput_GetDisplaySurfaceData_MapOfDestinationFailed = 51, + /// /// DXGI_MSG_IDXGIOutput_GetFrameStatistics_NoOwnerDevice IDXGIOutput_GetFrameStatistics_NoOwnerDevice = 52, + /// /// DXGI_MSG_IDXGIOutput_GetFrameStatistics_pStatsIsNULL IDXGIOutput_GetFrameStatistics_pStatsIsNULL = 53, + /// /// DXGI_MSG_IDXGIOutput_SetGammaControl_NoOwnerDevice IDXGIOutput_SetGammaControl_NoOwnerDevice = 54, + /// /// DXGI_MSG_IDXGIOutput_GetGammaControl_NoOwnerDevice IDXGIOutput_GetGammaControl_NoOwnerDevice = 55, + /// /// DXGI_MSG_IDXGIOutput_GetGammaControl_NoGammaControls IDXGIOutput_GetGammaControl_NoGammaControls = 56, + /// /// DXGI_MSG_IDXGIOutput_SetDisplaySurface_IDXGIResourceNotSupportedBypPrimary IDXGIOutput_SetDisplaySurface_IDXGIResourceNotSupportedBypPrimary = 57, + /// /// DXGI_MSG_IDXGIOutput_SetDisplaySurface_pPrimaryIsInvalid IDXGIOutput_SetDisplaySurface_pPrimaryIsInvalid = 58, + /// /// DXGI_MSG_IDXGIOutput_SetDisplaySurface_NoOwnerDevice IDXGIOutput_SetDisplaySurface_NoOwnerDevice = 59, + /// /// DXGI_MSG_IDXGIOutput_TakeOwnership_RemoteDeviceNotSupported IDXGIOutput_TakeOwnership_RemoteDeviceNotSupported = 60, + /// /// DXGI_MSG_IDXGIOutput_GetDisplayModeList_RemoteDeviceNotSupported IDXGIOutput_GetDisplayModeList_RemoteDeviceNotSupported = 61, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_RemoteDeviceNotSupported IDXGIOutput_FindClosestMatchingMode_RemoteDeviceNotSupported = 62, + /// /// DXGI_MSG_IDXGIDevice_CreateSurface_InvalidParametersWithpSharedResource IDXGIDevice_CreateSurface_InvalidParametersWithpSharedResource = 63, + /// /// DXGI_MSG_IDXGIObject_GetPrivateData_puiDataSizeIsNULL IDXGIObject_GetPrivateData_puiDataSizeIsNULL = 64, + /// /// DXGI_MSG_IDXGISwapChain_Creation_InvalidOutputWindow IDXGISwapChain_Creation_InvalidOutputWindow = 65, + /// /// DXGI_MSG_IDXGISwapChain_Release_SwapChainIsFullscreen IDXGISwapChain_Release_SwapChainIsFullscreen = 66, + /// /// DXGI_MSG_IDXGIOutput_GetDisplaySurfaceData_InvalidTargetSurfaceFormat IDXGIOutput_GetDisplaySurfaceData_InvalidTargetSurfaceFormat = 67, + /// /// DXGI_MSG_IDXGIFactory_CreateSoftwareAdapter_ModuleIsNULL IDXGIFactory_CreateSoftwareAdapter_ModuleIsNULL = 68, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_IDXGIDeviceNotSupportedBypConcernedDevice IDXGIOutput_FindClosestMatchingMode_IDXGIDeviceNotSupportedBypConcernedDevice = 69, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_pModeToMatchOrpClosestMatchIsNULL IDXGIOutput_FindClosestMatchingMode_pModeToMatchOrpClosestMatchIsNULL = 70, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_ModeHasRefreshRateDenominatorZero IDXGIOutput_FindClosestMatchingMode_ModeHasRefreshRateDenominatorZero = 71, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_UnknownFormatIsInvalidForConfiguration IDXGIOutput_FindClosestMatchingMode_UnknownFormatIsInvalidForConfiguration = 72, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_InvalidDisplayModeScanlineOrdering IDXGIOutput_FindClosestMatchingMode_InvalidDisplayModeScanlineOrdering = 73, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_InvalidDisplayModeScaling IDXGIOutput_FindClosestMatchingMode_InvalidDisplayModeScaling = 74, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_InvalidDisplayModeFormatAndDeviceCombination IDXGIOutput_FindClosestMatchingMode_InvalidDisplayModeFormatAndDeviceCombination = 75, + /// /// DXGI_MSG_IDXGIFactory_Creation_CalledFromDllMain IDXGIFactory_Creation_CalledFromDllMain = 76, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_OutputNotOwnedBySwapChainDevice IDXGISwapChain_SetFullscreenState_OutputNotOwnedBySwapChainDevice = 77, + /// /// DXGI_MSG_IDXGISwapChain_Creation_InvalidWindowStyle IDXGISwapChain_Creation_InvalidWindowStyle = 78, + /// /// DXGI_MSG_IDXGISwapChain_GetFrameStatistics_UnsupportedStatistics IDXGISwapChain_GetFrameStatistics_UnsupportedStatistics = 79, + /// /// DXGI_MSG_IDXGISwapChain_GetContainingOutput_SwapchainAdapterDoesNotControlOutput IDXGISwapChain_GetContainingOutput_SwapchainAdapterDoesNotControlOutput = 80, + /// /// DXGI_MSG_IDXGIOutput_SetOrGetGammaControl_pArrayIsNULL IDXGIOutput_SetOrGetGammaControl_pArrayIsNULL = 81, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_FullscreenInvalidForChildWindows IDXGISwapChain_SetFullscreenState_FullscreenInvalidForChildWindows = 82, + /// /// DXGI_MSG_IDXGIFactory_Release_CalledFromDllMain IDXGIFactory_Release_CalledFromDllMain = 83, + /// /// DXGI_MSG_IDXGISwapChain_Present_UnreleasedHDC IDXGISwapChain_Present_UnreleasedHDC = 84, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_NonPreRotatedAndGDICompatibleFlags IDXGISwapChain_ResizeBuffers_NonPreRotatedAndGDICompatibleFlags = 85, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_NonPreRotatedAndGDICompatibleFlags IDXGIFactory_CreateSwapChain_NonPreRotatedAndGDICompatibleFlags = 86, + /// /// DXGI_MSG_IDXGISurface1_GetDC_pHdcIsNULL IDXGISurface1_GetDC_pHdcIsNULL = 87, + /// /// DXGI_MSG_IDXGISurface1_GetDC_SurfaceNotTexture2D IDXGISurface1_GetDC_SurfaceNotTexture2D = 88, + /// /// DXGI_MSG_IDXGISurface1_GetDC_GDICompatibleFlagNotSet IDXGISurface1_GetDC_GDICompatibleFlagNotSet = 89, + /// /// DXGI_MSG_IDXGISurface1_GetDC_UnreleasedHDC IDXGISurface1_GetDC_UnreleasedHDC = 90, + /// /// DXGI_MSG_IDXGISurface_Map_NoCPUAccess2 IDXGISurface_Map_NoCPUAccess2 = 91, + /// /// DXGI_MSG_IDXGISurface1_ReleaseDC_GetDCNotCalled IDXGISurface1_ReleaseDC_GetDCNotCalled = 92, + /// /// DXGI_MSG_IDXGISurface1_ReleaseDC_InvalidRectangleDimensions IDXGISurface1_ReleaseDC_InvalidRectangleDimensions = 93, + /// /// DXGI_MSG_IDXGIOutput_TakeOwnership_RemoteOutputNotSupported IDXGIOutput_TakeOwnership_RemoteOutputNotSupported = 94, + /// /// DXGI_MSG_IDXGIOutput_FindClosestMatchingMode_RemoteOutputNotSupported IDXGIOutput_FindClosestMatchingMode_RemoteOutputNotSupported = 95, + /// /// DXGI_MSG_IDXGIOutput_GetDisplayModeList_RemoteOutputNotSupported IDXGIOutput_GetDisplayModeList_RemoteOutputNotSupported = 96, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_pDeviceHasMismatchedDXGIFactory IDXGIFactory_CreateSwapChain_pDeviceHasMismatchedDXGIFactory = 97, + /// /// DXGI_MSG_IDXGISwapChain_Present_NonOptimalFSConfiguration IDXGISwapChain_Present_NonOptimalFSConfiguration = 98, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_FlipSequentialNotSupportedOnD3D10 IDXGIFactory_CreateSwapChain_FlipSequentialNotSupportedOnD3D10 = 99, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_BufferCountOOBForFlipSequential IDXGIFactory_CreateSwapChain_BufferCountOOBForFlipSequential = 100, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_InvalidFormatForFlipSequential IDXGIFactory_CreateSwapChain_InvalidFormatForFlipSequential = 101, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_MultiSamplingNotSupportedForFlipSequential IDXGIFactory_CreateSwapChain_MultiSamplingNotSupportedForFlipSequential = 102, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_BufferCountOOBForFlipSequential IDXGISwapChain_ResizeBuffers_BufferCountOOBForFlipSequential = 103, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_InvalidFormatForFlipSequential IDXGISwapChain_ResizeBuffers_InvalidFormatForFlipSequential = 104, + /// /// DXGI_MSG_IDXGISwapChain_Present_PartialPresentationBeforeStandardPresentation IDXGISwapChain_Present_PartialPresentationBeforeStandardPresentation = 105, + /// /// DXGI_MSG_IDXGISwapChain_Present_FullscreenPartialPresentIsInvalid IDXGISwapChain_Present_FullscreenPartialPresentIsInvalid = 106, + /// /// DXGI_MSG_IDXGISwapChain_Present_InvalidPresentTestOrDoNotSequenceFlag IDXGISwapChain_Present_InvalidPresentTestOrDoNotSequenceFlag = 107, + /// /// DXGI_MSG_IDXGISwapChain_Present_ScrollInfoWithNoDirtyRectsSpecified IDXGISwapChain_Present_ScrollInfoWithNoDirtyRectsSpecified = 108, + /// /// DXGI_MSG_IDXGISwapChain_Present_EmptyScrollRect IDXGISwapChain_Present_EmptyScrollRect = 109, + /// /// DXGI_MSG_IDXGISwapChain_Present_ScrollRectOutOfBackbufferBounds IDXGISwapChain_Present_ScrollRectOutOfBackbufferBounds = 110, + /// /// DXGI_MSG_IDXGISwapChain_Present_ScrollRectOutOfBackbufferBoundsWithOffset IDXGISwapChain_Present_ScrollRectOutOfBackbufferBoundsWithOffset = 111, + /// /// DXGI_MSG_IDXGISwapChain_Present_EmptyDirtyRect IDXGISwapChain_Present_EmptyDirtyRect = 112, + /// /// DXGI_MSG_IDXGISwapChain_Present_DirtyRectOutOfBackbufferBounds IDXGISwapChain_Present_DirtyRectOutOfBackbufferBounds = 113, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_UnsupportedBufferUsageFlags IDXGIFactory_CreateSwapChain_UnsupportedBufferUsageFlags = 114, + /// /// DXGI_MSG_IDXGISwapChain_Present_DoNotSequenceFlagSetButPreviousBufferIsUndefined IDXGISwapChain_Present_DoNotSequenceFlagSetButPreviousBufferIsUndefined = 115, + /// /// DXGI_MSG_IDXGISwapChain_Present_UnsupportedFlags IDXGISwapChain_Present_UnsupportedFlags = 116, + /// /// DXGI_MSG_IDXGISwapChain_Present_FlipModelChainMustResizeOrCreateOnFSTransition IDXGISwapChain_Present_FlipModelChainMustResizeOrCreateOnFSTransition = 117, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_pRestrictToOutputFromOtherIDXGIFactory IDXGIFactory_CreateSwapChain_pRestrictToOutputFromOtherIDXGIFactory = 118, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_RestrictOutputNotSupportedOnAdapter IDXGIFactory_CreateSwapChain_RestrictOutputNotSupportedOnAdapter = 119, + /// /// DXGI_MSG_IDXGISwapChain_Present_RestrictToOutputFlagSetButInvalidpRestrictToOutput IDXGISwapChain_Present_RestrictToOutputFlagSetButInvalidpRestrictToOutput = 120, + /// /// DXGI_MSG_IDXGISwapChain_Present_RestrictToOutputFlagdWithFullscreen IDXGISwapChain_Present_RestrictToOutputFlagdWithFullscreen = 121, + /// /// DXGI_MSG_IDXGISwapChain_Present_RestrictOutputFlagWithStaleSwapChain IDXGISwapChain_Present_RestrictOutputFlagWithStaleSwapChain = 122, + /// /// DXGI_MSG_IDXGISwapChain_Present_OtherFlagsCausingInvalidPresentTestFlag IDXGISwapChain_Present_OtherFlagsCausingInvalidPresentTestFlag = 123, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_UnavailableInSession0 IDXGIFactory_CreateSwapChain_UnavailableInSession0 = 124, + /// /// DXGI_MSG_IDXGIFactory_MakeWindowAssociation_UnavailableInSession0 IDXGIFactory_MakeWindowAssociation_UnavailableInSession0 = 125, + /// /// DXGI_MSG_IDXGIFactory_GetWindowAssociation_UnavailableInSession0 IDXGIFactory_GetWindowAssociation_UnavailableInSession0 = 126, + /// /// DXGI_MSG_IDXGIAdapter_EnumOutputs_UnavailableInSession0 IDXGIAdapter_EnumOutputs_UnavailableInSession0 = 127, + /// /// DXGI_MSG_IDXGISwapChain_CreationOrSetFullscreenState_StereoDisabled IDXGISwapChain_CreationOrSetFullscreenState_StereoDisabled = 128, + /// /// DXGI_MSG_IDXGIFactory2_UnregisterStatus_CookieNotFound IDXGIFactory2_UnregisterStatus_CookieNotFound = 129, + /// /// DXGI_MSG_IDXGISwapChain_Present_ProtectedContentInWindowedModeWithoutFSOrOverlay IDXGISwapChain_Present_ProtectedContentInWindowedModeWithoutFSOrOverlay = 130, + /// /// DXGI_MSG_IDXGISwapChain_Present_ProtectedContentInWindowedModeWithoutFlipSequential IDXGISwapChain_Present_ProtectedContentInWindowedModeWithoutFlipSequential = 131, + /// /// DXGI_MSG_IDXGISwapChain_Present_ProtectedContentWithRDPDriver IDXGISwapChain_Present_ProtectedContentWithRDPDriver = 132, + /// /// DXGI_MSG_IDXGISwapChain_Present_ProtectedContentInWindowedModeWithDWMOffOrInvalidDisplayAffinity IDXGISwapChain_Present_ProtectedContentInWindowedModeWithDWMOffOrInvalidDisplayAffinity = 133, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainForComposition_WidthOrHeightIsZero IDXGIFactory_CreateSwapChainForComposition_WidthOrHeightIsZero = 134, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainForComposition_OnlyFlipSequentialSupported IDXGIFactory_CreateSwapChainForComposition_OnlyFlipSequentialSupported = 135, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainForComposition_UnsupportedOnAdapter IDXGIFactory_CreateSwapChainForComposition_UnsupportedOnAdapter = 136, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainForComposition_UnsupportedOnWindows7 IDXGIFactory_CreateSwapChainForComposition_UnsupportedOnWindows7 = 137, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_FSTransitionWithCompositionSwapChain IDXGISwapChain_SetFullscreenState_FSTransitionWithCompositionSwapChain = 138, + /// /// DXGI_MSG_IDXGISwapChain_ResizeTarget_InvalidWithCompositionSwapChain IDXGISwapChain_ResizeTarget_InvalidWithCompositionSwapChain = 139, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_WidthOrHeightIsZero IDXGISwapChain_ResizeBuffers_WidthOrHeightIsZero = 140, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_ScalingNoneIsFlipModelOnly IDXGIFactory_CreateSwapChain_ScalingNoneIsFlipModelOnly = 141, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_ScalingUnrecognized IDXGIFactory_CreateSwapChain_ScalingUnrecognized = 142, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_DisplayOnlyFullscreenUnsupported IDXGIFactory_CreateSwapChain_DisplayOnlyFullscreenUnsupported = 143, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_DisplayOnlyUnsupported IDXGIFactory_CreateSwapChain_DisplayOnlyUnsupported = 144, + /// /// DXGI_MSG_IDXGISwapChain_Present_RestartIsFullscreenOnly IDXGISwapChain_Present_RestartIsFullscreenOnly = 145, + /// /// DXGI_MSG_IDXGISwapChain_Present_ProtectedWindowlessPresentationRequiresDisplayOnly IDXGISwapChain_Present_ProtectedWindowlessPresentationRequiresDisplayOnly = 146, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_DisplayOnlyUnsupported IDXGISwapChain_SetFullscreenState_DisplayOnlyUnsupported = 147, + /// /// DXGI_MSG_IDXGISwapChain1_SetBackgroundColor_OutOfRange IDXGISwapChain1_SetBackgroundColor_OutOfRange = 148, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_DisplayOnlyFullscreenUnsupported IDXGISwapChain_ResizeBuffers_DisplayOnlyFullscreenUnsupported = 149, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_DisplayOnlyUnsupported IDXGISwapChain_ResizeBuffers_DisplayOnlyUnsupported = 150, + /// /// DXGI_MSG_IDXGISwapchain_Present_ScrollUnsupported IDXGISwapchain_Present_ScrollUnsupported = 151, + /// /// DXGI_MSG_IDXGISwapChain1_SetRotation_UnsupportedOS IDXGISwapChain1_SetRotation_UnsupportedOS = 152, + /// /// DXGI_MSG_IDXGISwapChain1_GetRotation_UnsupportedOS IDXGISwapChain1_GetRotation_UnsupportedOS = 153, + /// /// DXGI_MSG_IDXGISwapchain_Present_FullscreenRotation IDXGISwapchain_Present_FullscreenRotation = 154, + /// /// DXGI_MSG_IDXGISwapChain_Present_PartialPresentationWithMSAABuffers IDXGISwapChain_Present_PartialPresentationWithMSAABuffers = 155, + /// /// DXGI_MSG_IDXGISwapChain1_SetRotation_FlipSequentialRequired IDXGISwapChain1_SetRotation_FlipSequentialRequired = 156, + /// /// DXGI_MSG_IDXGISwapChain1_SetRotation_InvalidRotation IDXGISwapChain1_SetRotation_InvalidRotation = 157, + /// /// DXGI_MSG_IDXGISwapChain1_GetRotation_FlipSequentialRequired IDXGISwapChain1_GetRotation_FlipSequentialRequired = 158, + /// /// DXGI_MSG_IDXGISwapChain_GetHwnd_WrongType IDXGISwapChain_GetHwnd_WrongType = 159, + /// /// DXGI_MSG_IDXGISwapChain_GetCompositionSurface_WrongType IDXGISwapChain_GetCompositionSurface_WrongType = 160, + /// /// DXGI_MSG_IDXGISwapChain_GetCoreWindow_WrongType IDXGISwapChain_GetCoreWindow_WrongType = 161, + /// /// DXGI_MSG_IDXGISwapChain_GetFullscreenDesc_NonHwnd IDXGISwapChain_GetFullscreenDesc_NonHwnd = 162, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_CoreWindow IDXGISwapChain_SetFullscreenState_CoreWindow = 163, + /// /// DXGI_MSG_IDXGIFactory2_CreateSwapChainForCoreWindow_UnsupportedOnWindows7 IDXGIFactory2_CreateSwapChainForCoreWindow_UnsupportedOnWindows7 = 164, + /// /// DXGI_MSG_IDXGIFactory2_CreateSwapChainForCoreWindow_pWindowIsNULL IDXGIFactory2_CreateSwapChainForCoreWindow_pWindowIsNULL = 165, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_FSUnsupportedForModernApps IDXGIFactory_CreateSwapChain_FSUnsupportedForModernApps = 166, + /// /// DXGI_MSG_IDXGIFactory_MakeWindowAssociation_ModernApp IDXGIFactory_MakeWindowAssociation_ModernApp = 167, + /// /// DXGI_MSG_IDXGISwapChain_ResizeTarget_ModernApp IDXGISwapChain_ResizeTarget_ModernApp = 168, + /// /// DXGI_MSG_IDXGISwapChain_ResizeTarget_pNewTargetParametersIsNULL IDXGISwapChain_ResizeTarget_pNewTargetParametersIsNULL = 169, + /// /// DXGI_MSG_IDXGIOutput_SetDisplaySurface_ModernApp IDXGIOutput_SetDisplaySurface_ModernApp = 170, + /// /// DXGI_MSG_IDXGIOutput_TakeOwnership_ModernApp IDXGIOutput_TakeOwnership_ModernApp = 171, + /// /// DXGI_MSG_IDXGIFactory2_CreateSwapChainForCoreWindow_pWindowIsInvalid IDXGIFactory2_CreateSwapChainForCoreWindow_pWindowIsInvalid = 172, + /// /// DXGI_MSG_IDXGIFactory2_CreateSwapChainForCompositionSurface_InvalidHandle IDXGIFactory2_CreateSwapChainForCompositionSurface_InvalidHandle = 173, + /// /// DXGI_MSG_IDXGISurface1_GetDC_ModernApp IDXGISurface1_GetDC_ModernApp = 174, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_ScalingNoneRequiresWindows8OrNewer IDXGIFactory_CreateSwapChain_ScalingNoneRequiresWindows8OrNewer = 175, + /// /// DXGI_MSG_IDXGISwapChain_Present_TemporaryMonoAndPreferRight IDXGISwapChain_Present_TemporaryMonoAndPreferRight = 176, + /// /// DXGI_MSG_IDXGISwapChain_Present_TemporaryMonoOrPreferRightWithDoNotSequence IDXGISwapChain_Present_TemporaryMonoOrPreferRightWithDoNotSequence = 177, + /// /// DXGI_MSG_IDXGISwapChain_Present_TemporaryMonoOrPreferRightWithoutStereo IDXGISwapChain_Present_TemporaryMonoOrPreferRightWithoutStereo = 178, + /// /// DXGI_MSG_IDXGISwapChain_Present_TemporaryMonoUnsupported IDXGISwapChain_Present_TemporaryMonoUnsupported = 179, + /// /// DXGI_MSG_IDXGIOutput_GetDisplaySurfaceData_ArraySizeMismatch IDXGIOutput_GetDisplaySurfaceData_ArraySizeMismatch = 180, + /// /// DXGI_MSG_IDXGISwapChain_Present_PartialPresentationWithSwapEffectDiscard IDXGISwapChain_Present_PartialPresentationWithSwapEffectDiscard = 181, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_AlphaUnrecognized IDXGIFactory_CreateSwapChain_AlphaUnrecognized = 182, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_AlphaIsWindowlessOnly IDXGIFactory_CreateSwapChain_AlphaIsWindowlessOnly = 183, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_AlphaIsFlipModelOnly IDXGIFactory_CreateSwapChain_AlphaIsFlipModelOnly = 184, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_RestrictToOutputAdapterMismatch IDXGIFactory_CreateSwapChain_RestrictToOutputAdapterMismatch = 185, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_DisplayOnlyOnLegacy IDXGIFactory_CreateSwapChain_DisplayOnlyOnLegacy = 186, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_DisplayOnlyOnLegacy IDXGISwapChain_ResizeBuffers_DisplayOnlyOnLegacy = 187, + /// /// DXGI_MSG_IDXGIResource1_CreateSubresourceSurface_InvalidIndex IDXGIResource1_CreateSubresourceSurface_InvalidIndex = 188, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainForComposition_InvalidScaling IDXGIFactory_CreateSwapChainForComposition_InvalidScaling = 189, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainForCoreWindow_InvalidSwapEffect IDXGIFactory_CreateSwapChainForCoreWindow_InvalidSwapEffect = 190, + /// /// DXGI_MSG_IDXGIResource1_CreateSharedHandle_UnsupportedOS IDXGIResource1_CreateSharedHandle_UnsupportedOS = 191, + /// /// DXGI_MSG_IDXGIFactory2_RegisterOcclusionStatusWindow_UnsupportedOS IDXGIFactory2_RegisterOcclusionStatusWindow_UnsupportedOS = 192, + /// /// DXGI_MSG_IDXGIFactory2_RegisterOcclusionStatusEvent_UnsupportedOS IDXGIFactory2_RegisterOcclusionStatusEvent_UnsupportedOS = 193, + /// /// DXGI_MSG_IDXGIOutput1_DuplicateOutput_UnsupportedOS IDXGIOutput1_DuplicateOutput_UnsupportedOS = 194, + /// /// DXGI_MSG_IDXGIDisplayControl_IsStereoEnabled_UnsupportedOS IDXGIDisplayControl_IsStereoEnabled_UnsupportedOS = 195, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainForComposition_InvalidAlphaMode IDXGIFactory_CreateSwapChainForComposition_InvalidAlphaMode = 196, + /// /// DXGI_MSG_IDXGIFactory_GetSharedResourceAdapterLuid_InvalidResource IDXGIFactory_GetSharedResourceAdapterLuid_InvalidResource = 197, + /// /// DXGI_MSG_IDXGIFactory_GetSharedResourceAdapterLuid_InvalidLUID IDXGIFactory_GetSharedResourceAdapterLuid_InvalidLUID = 198, + /// /// DXGI_MSG_IDXGIFactory_GetSharedResourceAdapterLuid_UnsupportedOS IDXGIFactory_GetSharedResourceAdapterLuid_UnsupportedOS = 199, + /// /// DXGI_MSG_IDXGIOutput1_GetDisplaySurfaceData1_2DOnly IDXGIOutput1_GetDisplaySurfaceData1_2DOnly = 200, + /// /// DXGI_MSG_IDXGIOutput1_GetDisplaySurfaceData1_StagingOnly IDXGIOutput1_GetDisplaySurfaceData1_StagingOnly = 201, + /// /// DXGI_MSG_IDXGIOutput1_GetDisplaySurfaceData1_NeedCPUAccessWrite IDXGIOutput1_GetDisplaySurfaceData1_NeedCPUAccessWrite = 202, + /// /// DXGI_MSG_IDXGIOutput1_GetDisplaySurfaceData1_NoShared IDXGIOutput1_GetDisplaySurfaceData1_NoShared = 203, + /// /// DXGI_MSG_IDXGIOutput1_GetDisplaySurfaceData1_OnlyMipLevels1 IDXGIOutput1_GetDisplaySurfaceData1_OnlyMipLevels1 = 204, + /// /// DXGI_MSG_IDXGIOutput1_GetDisplaySurfaceData1_MappedOrOfferedResource IDXGIOutput1_GetDisplaySurfaceData1_MappedOrOfferedResource = 205, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_FSUnsupportedForModernApps IDXGISwapChain_SetFullscreenState_FSUnsupportedForModernApps = 206, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_FailedToGoFSButNonPreRotated IDXGIFactory_CreateSwapChain_FailedToGoFSButNonPreRotated = 207, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainOrRegisterOcclusionStatus_BlitModelUsedWhileRegisteredForOcclusionStatusEvents IDXGIFactory_CreateSwapChainOrRegisterOcclusionStatus_BlitModelUsedWhileRegisteredForOcclusionStatusEvents = 208, + /// /// DXGI_MSG_IDXGISwapChain_Present_BlitModelUsedWhileRegisteredForOcclusionStatusEvents IDXGISwapChain_Present_BlitModelUsedWhileRegisteredForOcclusionStatusEvents = 209, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_WaitableSwapChainsAreFlipModelOnly IDXGIFactory_CreateSwapChain_WaitableSwapChainsAreFlipModelOnly = 210, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_WaitableSwapChainsAreNotFullscreen IDXGIFactory_CreateSwapChain_WaitableSwapChainsAreNotFullscreen = 211, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_Waitable IDXGISwapChain_SetFullscreenState_Waitable = 212, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_CannotAddOrRemoveWaitableFlag IDXGISwapChain_ResizeBuffers_CannotAddOrRemoveWaitableFlag = 213, + /// /// DXGI_MSG_IDXGISwapChain_GetFrameLatencyWaitableObject_OnlyWaitable IDXGISwapChain_GetFrameLatencyWaitableObject_OnlyWaitable = 214, + /// /// DXGI_MSG_IDXGISwapChain_GetMaximumFrameLatency_OnlyWaitable IDXGISwapChain_GetMaximumFrameLatency_OnlyWaitable = 215, + /// /// DXGI_MSG_IDXGISwapChain_GetMaximumFrameLatency_pMaxLatencyIsNULL IDXGISwapChain_GetMaximumFrameLatency_pMaxLatencyIsNULL = 216, + /// /// DXGI_MSG_IDXGISwapChain_SetMaximumFrameLatency_OnlyWaitable IDXGISwapChain_SetMaximumFrameLatency_OnlyWaitable = 217, + /// /// DXGI_MSG_IDXGISwapChain_SetMaximumFrameLatency_MaxLatencyIsOutOfBounds IDXGISwapChain_SetMaximumFrameLatency_MaxLatencyIsOutOfBounds = 218, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_ForegroundIsCoreWindowOnly IDXGIFactory_CreateSwapChain_ForegroundIsCoreWindowOnly = 219, + /// /// DXGI_MSG_IDXGIFactory2_CreateSwapChainForCoreWindow_ForegroundUnsupportedOnAdapter IDXGIFactory2_CreateSwapChainForCoreWindow_ForegroundUnsupportedOnAdapter = 220, + /// /// DXGI_MSG_IDXGIFactory2_CreateSwapChainForCoreWindow_InvalidScaling IDXGIFactory2_CreateSwapChainForCoreWindow_InvalidScaling = 221, + /// /// DXGI_MSG_IDXGIFactory2_CreateSwapChainForCoreWindow_InvalidAlphaMode IDXGIFactory2_CreateSwapChainForCoreWindow_InvalidAlphaMode = 222, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_CannotAddOrRemoveForegroundFlag IDXGISwapChain_ResizeBuffers_CannotAddOrRemoveForegroundFlag = 223, + /// /// DXGI_MSG_IDXGISwapChain_SetMatrixTransform_MatrixPointerCannotBeNull IDXGISwapChain_SetMatrixTransform_MatrixPointerCannotBeNull = 224, + /// /// DXGI_MSG_IDXGISwapChain_SetMatrixTransform_RequiresCompositionSwapChain IDXGISwapChain_SetMatrixTransform_RequiresCompositionSwapChain = 225, + /// /// DXGI_MSG_IDXGISwapChain_SetMatrixTransform_MatrixMustBeFinite IDXGISwapChain_SetMatrixTransform_MatrixMustBeFinite = 226, + /// /// DXGI_MSG_IDXGISwapChain_SetMatrixTransform_MatrixMustBeTranslateAndOrScale IDXGISwapChain_SetMatrixTransform_MatrixMustBeTranslateAndOrScale = 227, + /// /// DXGI_MSG_IDXGISwapChain_GetMatrixTransform_MatrixPointerCannotBeNull IDXGISwapChain_GetMatrixTransform_MatrixPointerCannotBeNull = 228, + /// /// DXGI_MSG_IDXGISwapChain_GetMatrixTransform_RequiresCompositionSwapChain IDXGISwapChain_GetMatrixTransform_RequiresCompositionSwapChain = 229, + /// /// DXGI_MSG_DXGIGetDebugInterface1_NULL_ppDebug DXGIGetDebugInterface1_NULL_ppDebug = 230, + /// /// DXGI_MSG_DXGIGetDebugInterface1_InvalidFlags DXGIGetDebugInterface1_InvalidFlags = 231, + /// /// DXGI_MSG_IDXGISwapChain_Present_Decode IDXGISwapChain_Present_Decode = 232, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_Decode IDXGISwapChain_ResizeBuffers_Decode = 233, + /// /// DXGI_MSG_IDXGISwapChain_SetSourceSize_FlipModel IDXGISwapChain_SetSourceSize_FlipModel = 234, + /// /// DXGI_MSG_IDXGISwapChain_SetSourceSize_Decode IDXGISwapChain_SetSourceSize_Decode = 235, + /// /// DXGI_MSG_IDXGISwapChain_SetSourceSize_WidthHeight IDXGISwapChain_SetSourceSize_WidthHeight = 236, + /// /// DXGI_MSG_IDXGISwapChain_GetSourceSize_NullPointers IDXGISwapChain_GetSourceSize_NullPointers = 237, + /// /// DXGI_MSG_IDXGISwapChain_GetSourceSize_Decode IDXGISwapChain_GetSourceSize_Decode = 238, + /// /// DXGI_MSG_IDXGIDecodeSwapChain_SetColorSpace_InvalidFlags IDXGIDecodeSwapChain_SetColorSpace_InvalidFlags = 239, + /// /// DXGI_MSG_IDXGIDecodeSwapChain_SetSourceRect_InvalidRect IDXGIDecodeSwapChain_SetSourceRect_InvalidRect = 240, + /// /// DXGI_MSG_IDXGIDecodeSwapChain_SetTargetRect_InvalidRect IDXGIDecodeSwapChain_SetTargetRect_InvalidRect = 241, + /// /// DXGI_MSG_IDXGIDecodeSwapChain_SetDestSize_InvalidSize IDXGIDecodeSwapChain_SetDestSize_InvalidSize = 242, + /// /// DXGI_MSG_IDXGIDecodeSwapChain_GetSourceRect_InvalidPointer IDXGIDecodeSwapChain_GetSourceRect_InvalidPointer = 243, + /// /// DXGI_MSG_IDXGIDecodeSwapChain_GetTargetRect_InvalidPointer IDXGIDecodeSwapChain_GetTargetRect_InvalidPointer = 244, + /// /// DXGI_MSG_IDXGIDecodeSwapChain_GetDestSize_InvalidPointer IDXGIDecodeSwapChain_GetDestSize_InvalidPointer = 245, + /// /// DXGI_MSG_IDXGISwapChain_PresentBuffer_YUV IDXGISwapChain_PresentBuffer_YUV = 246, + /// /// DXGI_MSG_IDXGISwapChain_SetSourceSize_YUV IDXGISwapChain_SetSourceSize_YUV = 247, + /// /// DXGI_MSG_IDXGISwapChain_GetSourceSize_YUV IDXGISwapChain_GetSourceSize_YUV = 248, + /// /// DXGI_MSG_IDXGISwapChain_SetMatrixTransform_YUV IDXGISwapChain_SetMatrixTransform_YUV = 249, + /// /// DXGI_MSG_IDXGISwapChain_GetMatrixTransform_YUV IDXGISwapChain_GetMatrixTransform_YUV = 250, + /// /// DXGI_MSG_IDXGISwapChain_Present_PartialPresentation_YUV IDXGISwapChain_Present_PartialPresentation_YUV = 251, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_CannotAddOrRemoveFlag_YUV IDXGISwapChain_ResizeBuffers_CannotAddOrRemoveFlag_YUV = 252, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_Alignment_YUV IDXGISwapChain_ResizeBuffers_Alignment_YUV = 253, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_ShaderInputUnsupported_YUV IDXGIFactory_CreateSwapChain_ShaderInputUnsupported_YUV = 254, + /// /// DXGI_MSG_IDXGIOutput3_CheckOverlaySupport_NullPointers IDXGIOutput3_CheckOverlaySupport_NullPointers = 255, + /// /// DXGI_MSG_IDXGIOutput3_CheckOverlaySupport_IDXGIDeviceNotSupportedBypConcernedDevice IDXGIOutput3_CheckOverlaySupport_IDXGIDeviceNotSupportedBypConcernedDevice = 256, + /// /// DXGI_MSG_IDXGIAdapter_EnumOutputs2_InvalidEnumOutputs2Flag IDXGIAdapter_EnumOutputs2_InvalidEnumOutputs2Flag = 257, + /// /// DXGI_MSG_IDXGISwapChain_CreationOrSetFullscreenState_FSUnsupportedForFlipDiscard IDXGISwapChain_CreationOrSetFullscreenState_FSUnsupportedForFlipDiscard = 258, + /// /// DXGI_MSG_IDXGIOutput4_CheckOverlayColorSpaceSupport_NullPointers IDXGIOutput4_CheckOverlayColorSpaceSupport_NullPointers = 259, + /// /// DXGI_MSG_IDXGIOutput4_CheckOverlayColorSpaceSupport_IDXGIDeviceNotSupportedBypConcernedDevice IDXGIOutput4_CheckOverlayColorSpaceSupport_IDXGIDeviceNotSupportedBypConcernedDevice = 260, + /// /// DXGI_MSG_IDXGISwapChain3_CheckColorSpaceSupport_NullPointers IDXGISwapChain3_CheckColorSpaceSupport_NullPointers = 261, + /// /// DXGI_MSG_IDXGISwapChain3_SetColorSpace1_InvalidColorSpace IDXGISwapChain3_SetColorSpace1_InvalidColorSpace = 262, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_InvalidHwProtect IDXGIFactory_CreateSwapChain_InvalidHwProtect = 263, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_HwProtectUnsupported IDXGIFactory_CreateSwapChain_HwProtectUnsupported = 264, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_InvalidHwProtect IDXGISwapChain_ResizeBuffers_InvalidHwProtect = 265, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_HwProtectUnsupported IDXGISwapChain_ResizeBuffers_HwProtectUnsupported = 266, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers1_D3D12Only IDXGISwapChain_ResizeBuffers1_D3D12Only = 267, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers1_FlipModel IDXGISwapChain_ResizeBuffers1_FlipModel = 268, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers1_NodeMaskAndQueueRequired IDXGISwapChain_ResizeBuffers1_NodeMaskAndQueueRequired = 269, + /// /// DXGI_MSG_IDXGISwapChain_CreateSwapChain_InvalidHwProtectGdiFlag IDXGISwapChain_CreateSwapChain_InvalidHwProtectGdiFlag = 270, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_InvalidHwProtectGdiFlag IDXGISwapChain_ResizeBuffers_InvalidHwProtectGdiFlag = 271, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_10BitFormatNotSupported IDXGIFactory_CreateSwapChain_10BitFormatNotSupported = 272, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_FlipSwapEffectRequired IDXGIFactory_CreateSwapChain_FlipSwapEffectRequired = 273, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_InvalidDevice IDXGIFactory_CreateSwapChain_InvalidDevice = 274, + /// /// DXGI_MSG_IDXGIOutput_TakeOwnership_Unsupported IDXGIOutput_TakeOwnership_Unsupported = 275, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_InvalidQueue IDXGIFactory_CreateSwapChain_InvalidQueue = 276, + /// /// DXGI_MSG_IDXGISwapChain3_ResizeBuffers1_InvalidQueue IDXGISwapChain3_ResizeBuffers1_InvalidQueue = 277, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChainForHwnd_InvalidScaling IDXGIFactory_CreateSwapChainForHwnd_InvalidScaling = 278, + /// /// DXGI_MSG_IDXGISwapChain3_SetHDRMetaData_InvalidSize IDXGISwapChain3_SetHDRMetaData_InvalidSize = 279, + /// /// DXGI_MSG_IDXGISwapChain3_SetHDRMetaData_InvalidPointer IDXGISwapChain3_SetHDRMetaData_InvalidPointer = 280, + /// /// DXGI_MSG_IDXGISwapChain3_SetHDRMetaData_InvalidType IDXGISwapChain3_SetHDRMetaData_InvalidType = 281, + /// /// DXGI_MSG_IDXGISwapChain_Present_FullscreenAllowTearingIsInvalid IDXGISwapChain_Present_FullscreenAllowTearingIsInvalid = 282, + /// /// DXGI_MSG_IDXGISwapChain_Present_AllowTearingRequiresPresentIntervalZero IDXGISwapChain_Present_AllowTearingRequiresPresentIntervalZero = 283, + /// /// DXGI_MSG_IDXGISwapChain_Present_AllowTearingRequiresCreationFlag IDXGISwapChain_Present_AllowTearingRequiresCreationFlag = 284, + /// /// DXGI_MSG_IDXGISwapChain_ResizeBuffers_CannotAddOrRemoveAllowTearingFlag IDXGISwapChain_ResizeBuffers_CannotAddOrRemoveAllowTearingFlag = 285, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_AllowTearingFlagIsFlipModelOnly IDXGIFactory_CreateSwapChain_AllowTearingFlagIsFlipModelOnly = 286, + /// /// DXGI_MSG_IDXGIFactory_CheckFeatureSupport_InvalidFeature IDXGIFactory_CheckFeatureSupport_InvalidFeature = 287, + /// /// DXGI_MSG_IDXGIFactory_CheckFeatureSupport_InvalidSize IDXGIFactory_CheckFeatureSupport_InvalidSize = 288, + /// /// DXGI_MSG_IDXGIOutput6_CheckHardwareCompositionSupport_NullPointer IDXGIOutput6_CheckHardwareCompositionSupport_NullPointer = 289, + /// /// DXGI_MSG_IDXGISwapChain_SetFullscreenState_PerMonitorDpiShimApplied IDXGISwapChain_SetFullscreenState_PerMonitorDpiShimApplied = 290, + /// /// DXGI_MSG_IDXGIOutput_DuplicateOutput_PerMonitorDpiShimApplied IDXGIOutput_DuplicateOutput_PerMonitorDpiShimApplied = 291, + /// /// DXGI_MSG_IDXGIOutput_DuplicateOutput1_PerMonitorDpiRequired IDXGIOutput_DuplicateOutput1_PerMonitorDpiRequired = 292, + /// /// DXGI_MSG_IDXGIFactory7_UnregisterAdaptersChangedEvent_CookieNotFound IDXGIFactory7_UnregisterAdaptersChangedEvent_CookieNotFound = 293, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_LegacyBltModelSwapEffect IDXGIFactory_CreateSwapChain_LegacyBltModelSwapEffect = 294, + /// /// DXGI_MSG_IDXGISwapChain4_SetHDRMetaData_MetadataUnchanged IDXGISwapChain4_SetHDRMetaData_MetadataUnchanged = 295, + /// /// DXGI_MSG_IDXGISwapChain_Present_11On12_Released_Resource IDXGISwapChain_Present_11On12_Released_Resource = 296, + /// /// DXGI_MSG_IDXGIFactory_CreateSwapChain_MultipleSwapchainRefToSurface_DeferredDtr IDXGIFactory_CreateSwapChain_MultipleSwapchainRefToSurface_DeferredDtr = 297, + /// /// DXGI_MSG_IDXGIFactory_MakeWindowAssociation_NoOpBehavior IDXGIFactory_MakeWindowAssociation_NoOpBehavior = 298, + /// /// DXGI_MSG_Phone_IDXGIFactory_CreateSwapChain_NotForegroundWindow Phone_IDXGIFactory_CreateSwapChain_NotForegroundWindow = 1000, + /// /// DXGI_MSG_Phone_IDXGIFactory_CreateSwapChain_DISCARD_BufferCount Phone_IDXGIFactory_CreateSwapChain_DISCARD_BufferCount = 1001, + /// /// DXGI_MSG_Phone_IDXGISwapChain_SetFullscreenState_NotAvailable Phone_IDXGISwapChain_SetFullscreenState_NotAvailable = 1002, + /// /// DXGI_MSG_Phone_IDXGISwapChain_ResizeBuffers_NotAvailable Phone_IDXGISwapChain_ResizeBuffers_NotAvailable = 1003, + /// /// DXGI_MSG_Phone_IDXGISwapChain_ResizeTarget_NotAvailable Phone_IDXGISwapChain_ResizeTarget_NotAvailable = 1004, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidLayerIndex Phone_IDXGISwapChain_Present_InvalidLayerIndex = 1005, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_MultipleLayerIndex Phone_IDXGISwapChain_Present_MultipleLayerIndex = 1006, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidLayerFlag Phone_IDXGISwapChain_Present_InvalidLayerFlag = 1007, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidRotation Phone_IDXGISwapChain_Present_InvalidRotation = 1008, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidBlend Phone_IDXGISwapChain_Present_InvalidBlend = 1009, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidResource Phone_IDXGISwapChain_Present_InvalidResource = 1010, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidMultiPlaneOverlayResource Phone_IDXGISwapChain_Present_InvalidMultiPlaneOverlayResource = 1011, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidIndexForPrimary Phone_IDXGISwapChain_Present_InvalidIndexForPrimary = 1012, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidIndexForOverlay Phone_IDXGISwapChain_Present_InvalidIndexForOverlay = 1013, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidSubResourceIndex Phone_IDXGISwapChain_Present_InvalidSubResourceIndex = 1014, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidSourceRect Phone_IDXGISwapChain_Present_InvalidSourceRect = 1015, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidDestinationRect Phone_IDXGISwapChain_Present_InvalidDestinationRect = 1016, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_MultipleResource Phone_IDXGISwapChain_Present_MultipleResource = 1017, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_NotSharedResource Phone_IDXGISwapChain_Present_NotSharedResource = 1018, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidFlag Phone_IDXGISwapChain_Present_InvalidFlag = 1019, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_InvalidInterval Phone_IDXGISwapChain_Present_InvalidInterval = 1020, + /// /// DXGI_MSG_Phone_IDXGIFactory_CreateSwapChain_MSAA_NotSupported Phone_IDXGIFactory_CreateSwapChain_MSAA_NotSupported = 1021, + /// /// DXGI_MSG_Phone_IDXGIFactory_CreateSwapChain_ScalingAspectRatioStretch_Supported_ModernApp Phone_IDXGIFactory_CreateSwapChain_ScalingAspectRatioStretch_Supported_ModernApp = 1022, + /// /// DXGI_MSG_Phone_IDXGISwapChain_GetFrameStatistics_NotAvailable_ModernApp Phone_IDXGISwapChain_GetFrameStatistics_NotAvailable_ModernApp = 1023, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present_ReplaceInterval0With1 Phone_IDXGISwapChain_Present_ReplaceInterval0With1 = 1024, + /// /// DXGI_MSG_Phone_IDXGIFactory_CreateSwapChain_FailedRegisterWithCompositor Phone_IDXGIFactory_CreateSwapChain_FailedRegisterWithCompositor = 1025, + /// /// DXGI_MSG_Phone_IDXGIFactory_CreateSwapChain_NotForegroundWindow_AtRendering Phone_IDXGIFactory_CreateSwapChain_NotForegroundWindow_AtRendering = 1026, + /// /// DXGI_MSG_Phone_IDXGIFactory_CreateSwapChain_FLIP_SEQUENTIAL_BufferCount Phone_IDXGIFactory_CreateSwapChain_FLIP_SEQUENTIAL_BufferCount = 1027, + /// /// DXGI_MSG_Phone_IDXGIFactory_CreateSwapChain_FLIP_Modern_CoreWindow_Only Phone_IDXGIFactory_CreateSwapChain_FLIP_Modern_CoreWindow_Only = 1028, + /// /// DXGI_MSG_Phone_IDXGISwapChain_Present1_RequiresOverlays Phone_IDXGISwapChain_Present1_RequiresOverlays = 1029, + /// /// DXGI_MSG_Phone_IDXGISwapChain_SetBackgroundColor_FlipSequentialRequired Phone_IDXGISwapChain_SetBackgroundColor_FlipSequentialRequired = 1030, + /// /// DXGI_MSG_Phone_IDXGISwapChain_GetBackgroundColor_FlipSequentialRequired Phone_IDXGISwapChain_GetBackgroundColor_FlipSequentialRequired = 1031, } @@ -1174,333 +1636,539 @@ public enum WindowAssociationFlags : uint #endregion Generated Enums #region Structs +/// /// DXGI_RGBA public partial struct Rgba { + /// public float r; + /// public float g; + /// public float b; + /// public float a; } +/// /// DXGI_FRAME_STATISTICS public partial struct FrameStatistics { + /// public uint PresentCount; + /// public uint PresentRefreshCount; + /// public uint SyncRefreshCount; + /// public LargeInterger SyncQPCTime; + /// public LargeInterger SyncGPUTime; } +/// /// DXGI_MAPPED_RECT public partial struct MappedRect { + /// public int Pitch; + /// public unsafe byte* pBits; } +/// /// DXGI_ADAPTER_DESC public partial struct AdapterDescription { + /// public unsafe fixed ushort Description[128]; + /// public uint VendorId; + /// public uint DeviceId; + /// public uint SubSysId; + /// public uint Revision; + /// public nuint DedicatedVideoMemory; + /// public nuint DedicatedSystemMemory; + /// public nuint SharedSystemMemory; + /// public Luid AdapterLuid; } +/// /// DXGI_OUTPUT_DESC public partial struct OutputDescription { + /// public unsafe fixed ushort DeviceName[32]; + /// public RawRect DesktopCoordinates; + /// public Bool32 AttachedToDesktop; + /// public Common.ModeRotation Rotation; + /// public IntPtr Monitor; } +/// /// DXGI_SHARED_RESOURCE public partial struct SharedResource { + /// public IntPtr Handle; } +/// /// DXGI_SURFACE_DESC public partial struct SurfaceDescription { + /// public uint Width; + /// public uint Height; + /// public Common.Format Format; + /// public Common.SampleDescription SampleDesc; } +/// /// DXGI_SWAP_CHAIN_DESC public partial struct SwapChainDescription { + /// public Common.ModeDescription BufferDesc; + /// public Common.SampleDescription SampleDesc; + /// public Usage BufferUsage; + /// public uint BufferCount; + /// public IntPtr OutputWindow; + /// public Bool32 Windowed; + /// public SwapEffect SwapEffect; + /// public SwapChainFlags Flags; } +/// /// DXGI_ADAPTER_DESC1 public partial struct AdapterDescription1 { + /// public unsafe fixed ushort Description[128]; + /// public uint VendorId; + /// public uint DeviceId; + /// public uint SubSysId; + /// public uint Revision; + /// public nuint DedicatedVideoMemory; + /// public nuint DedicatedSystemMemory; + /// public nuint SharedSystemMemory; + /// public Luid AdapterLuid; + /// public AdapterFlags Flags; } +/// /// DXGI_DISPLAY_COLOR_SPACE public partial struct DisplayColorSpace { + /// public unsafe fixed float PrimaryCoordinates[16]; + /// public unsafe fixed float WhitePoints[32]; } +/// /// DXGI_OUTDUPL_MOVE_RECT public partial struct OutduplMoveRect { + /// public System.Drawing.Point SourcePoint; + /// public RawRect DestinationRect; } +/// /// DXGI_OUTDUPL_DESC public partial struct OutduplDescription { + /// public Common.ModeDescription ModeDesc; + /// public Common.ModeRotation Rotation; + /// public Bool32 DesktopImageInSystemMemory; } +/// /// DXGI_OUTDUPL_POINTER_POSITION public partial struct OutduplPointerPosition { + /// public System.Drawing.Point Position; + /// public Bool32 Visible; } +/// /// DXGI_OUTDUPL_POINTER_SHAPE_INFO public partial struct OutduplPointerShapeInfo { + /// public uint Type; + /// public uint Width; + /// public uint Height; + /// public uint Pitch; + /// public System.Drawing.Point HotSpot; } +/// /// DXGI_OUTDUPL_FRAME_INFO public partial struct OutduplFrameInfo { + /// public LargeInterger LastPresentTime; + /// public LargeInterger LastMouseUpdateTime; + /// public uint AccumulatedFrames; + /// public Bool32 RectsCoalesced; + /// public Bool32 ProtectedContentMaskedOut; + /// public OutduplPointerPosition PointerPosition; + /// public uint TotalMetadataBufferSize; + /// public uint PointerShapeBufferSize; } +/// /// DXGI_MODE_DESC1 public partial struct ModeDescription1 { + /// public uint Width; + /// public uint Height; + /// public Common.Rational RefreshRate; + /// public Common.Format Format; + /// public Common.ModeScanlineOrder ScanlineOrdering; + /// public Common.ModeScaling Scaling; + /// public Bool32 Stereo; } +/// /// DXGI_SWAP_CHAIN_DESC1 public partial struct SwapChainDescription1 { + /// public uint Width; + /// public uint Height; + /// public Common.Format Format; + /// public Bool32 Stereo; + /// public Common.SampleDescription SampleDesc; + /// public Usage BufferUsage; + /// public uint BufferCount; + /// public Scaling Scaling; + /// public SwapEffect SwapEffect; + /// public Common.AlphaMode AlphaMode; + /// public SwapChainFlags Flags; } +/// /// DXGI_SWAP_CHAIN_FULLSCREEN_DESC public partial struct SwapChainFullscreenDescription { + /// public Common.Rational RefreshRate; + /// public Common.ModeScanlineOrder ScanlineOrdering; + /// public Common.ModeScaling Scaling; + /// public Bool32 Windowed; } +/// /// DXGI_PRESENT_PARAMETERS public partial struct PresentParameters { + /// public uint DirtyRectsCount; + /// public unsafe RawRect* pDirtyRects; + /// public unsafe RawRect* pScrollRect; + /// public unsafe System.Drawing.Point* pScrollOffset; } +/// /// DXGI_ADAPTER_DESC2 public partial struct AdapterDescription2 { + /// public unsafe fixed ushort Description[128]; + /// public uint VendorId; + /// public uint DeviceId; + /// public uint SubSysId; + /// public uint Revision; + /// public nuint DedicatedVideoMemory; + /// public nuint DedicatedSystemMemory; + /// public nuint SharedSystemMemory; + /// public Luid AdapterLuid; + /// public uint Flags; + /// public GraphicsPreemptionGranularity GraphicsPreemptionGranularity; + /// public ComputePreemptionGranularity ComputePreemptionGranularity; } +/// /// DXGI_MATRIX_3X2_F public partial struct Matrix3x2F { + /// public float _11; + /// public float _12; + /// public float _21; + /// public float _22; + /// public float _31; + /// public float _32; } +/// /// DXGI_DECODE_SWAP_CHAIN_DESC public partial struct DecodeSwapChainDescription { + /// public uint Flags; } +/// /// DXGI_FRAME_STATISTICS_MEDIA public partial struct FrameStatisticsMedia { + /// public uint PresentCount; + /// public uint PresentRefreshCount; + /// public uint SyncRefreshCount; + /// public LargeInterger SyncQPCTime; + /// public LargeInterger SyncGPUTime; + /// public FramePresentationMode CompositionMode; + /// public uint ApprovedPresentDuration; } +/// /// DXGI_QUERY_VIDEO_MEMORY_INFO public partial struct QueryVideoMemoryInfo { + /// public ulong Budget; + /// public ulong CurrentUsage; + /// public ulong AvailableForReservation; + /// public ulong CurrentReservation; } +/// /// DXGI_HDR_METADATA_HDR10 public partial struct HdrMetadataHdr10 { + /// public unsafe fixed ushort RedPrimary[2]; + /// public unsafe fixed ushort GreenPrimary[2]; + /// public unsafe fixed ushort BluePrimary[2]; + /// public unsafe fixed ushort WhitePoint[2]; + /// public uint MaxMasteringLuminance; + /// public uint MinMasteringLuminance; + /// public ushort MaxContentLightLevel; + /// public ushort MaxFrameAverageLightLevel; } +/// /// DXGI_HDR_METADATA_HDR10PLUS public partial struct HdrMetadataHdr10plus { + /// public unsafe fixed byte Data[72]; } +/// /// DXGI_ADAPTER_DESC3 public partial struct AdapterDescription3 { + /// public unsafe fixed ushort Description[128]; + /// public uint VendorId; + /// public uint DeviceId; + /// public uint SubSysId; + /// public uint Revision; + /// public nuint DedicatedVideoMemory; + /// public nuint DedicatedSystemMemory; + /// public nuint SharedSystemMemory; + /// public Luid AdapterLuid; + /// public AdapterFlags3 Flags; + /// public GraphicsPreemptionGranularity GraphicsPreemptionGranularity; + /// public ComputePreemptionGranularity ComputePreemptionGranularity; } +/// /// DXGI_OUTPUT_DESC1 public partial struct OutputDescription1 { + /// public unsafe fixed ushort DeviceName[32]; + /// public RawRect DesktopCoordinates; + /// public Bool32 AttachedToDesktop; + /// public Common.ModeRotation Rotation; + /// public IntPtr Monitor; + /// public uint BitsPerColor; + /// public Common.ColorSpaceType ColorSpace; + /// public unsafe fixed float RedPrimary[2]; + /// public unsafe fixed float GreenPrimary[2]; + /// public unsafe fixed float BluePrimary[2]; + /// public unsafe fixed float WhitePoint[2]; + /// public float MinLuminance; + /// public float MaxLuminance; + /// public float MaxFullFrameLuminance; } +/// /// DXGI_INFO_QUEUE_MESSAGE public partial struct InfoQueueMessage { + /// public Guid Producer; + /// public InfoQueueMessageCategory Category; + /// public InfoQueueMessageSeverity Severity; + /// public int ID; + /// public unsafe byte* pDescription; + /// public nuint DescriptionByteLength; } +/// /// DXGI_INFO_QUEUE_FILTER_DESC public partial struct InfoQueueFilterDescription { + /// public uint NumCategories; + /// public unsafe InfoQueueMessageCategory* pCategoryList; + /// public uint NumSeverities; + /// public unsafe InfoQueueMessageSeverity* pSeverityList; + /// public uint NumIDs; + /// public unsafe int* pIDList; } +/// /// DXGI_INFO_QUEUE_FILTER public partial struct InfoQueueFilter { + /// public InfoQueueFilterDescription AllowList; + /// public InfoQueueFilterDescription DenyList; } diff --git a/src/Vortice.Win32/Vortice.Win32.csproj b/src/Vortice.Win32/Vortice.Win32.csproj index 0ff8034..e75913c 100644 --- a/src/Vortice.Win32/Vortice.Win32.csproj +++ b/src/Vortice.Win32/Vortice.Win32.csproj @@ -5,6 +5,7 @@ Windows API low level bindings. 1.0.0 + true diff --git a/src/samples/01-ClearScreen/Program.cs b/src/samples/01-ClearScreen/Program.cs index a5f9600..947d975 100644 --- a/src/samples/01-ClearScreen/Program.cs +++ b/src/samples/01-ClearScreen/Program.cs @@ -1,7 +1,8 @@ // Copyright © Amer Koleci and Contributors. // Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. -using System.Numerics; +using Win32.Graphics.Dxgi; +using Win32.Graphics.Dxgi.Common; namespace ClearScreen; @@ -9,6 +10,9 @@ public static unsafe class Program { public static void Main() { - + SampleDescription desc = new(1, 0); + desc.Count + + Scaling scaling = Scaling.Stretch; } }