add Nvidia overclocking options, integrate NvAPIWrapper/NvidiaML to enable and extend overclocking (curve), some other fixes

NvAPIWrapper/Display/ColorData.cs

@@ -0,0 +1,200 @@
+using System;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <inheritdoc cref="IColorData" />
+    public class ColorData : IColorData, IEquatable<ColorData>
+    {
+        /// <summary>
+        ///     Creates an instance of <see cref="ColorData" /> to modify the color data
+        /// </summary>
+        /// <param name="colorFormat">The color data color format.</param>
+        /// <param name="colorimetry">The color data color space.</param>
+        /// <param name="dynamicRange">The color data dynamic range.</param>
+        /// <param name="colorDepth">The color data color depth.</param>
+        /// <param name="colorSelectionPolicy">The color data selection policy.</param>
+        /// <param name="desktopColorDepth">The color data desktop color depth.</param>
+        public ColorData(
+            ColorDataFormat colorFormat = ColorDataFormat.Auto,
+            ColorDataColorimetry colorimetry = ColorDataColorimetry.Auto,
+            ColorDataDynamicRange? dynamicRange = null,
+            ColorDataDepth? colorDepth = null,
+            ColorDataSelectionPolicy? colorSelectionPolicy = null,
+            ColorDataDesktopDepth? desktopColorDepth = null
+        )
+        {
+            ColorFormat = colorFormat;
+            Colorimetry = colorimetry;
+            DynamicRange = dynamicRange;
+            ColorDepth = colorDepth;
+            SelectionPolicy = colorSelectionPolicy;
+            DesktopColorDepth = desktopColorDepth;
+        }
+
+        internal ColorData(IColorData colorData)
+        {
+            ColorDepth = colorData.ColorDepth;
+            DynamicRange = colorData.DynamicRange;
+            ColorFormat = colorData.ColorFormat;
+            Colorimetry = colorData.Colorimetry;
+            SelectionPolicy = colorData.SelectionPolicy;
+            DesktopColorDepth = colorData.DesktopColorDepth;
+        }
+
+        /// <inheritdoc />
+        public ColorDataDepth? ColorDepth { get; }
+
+        /// <inheritdoc />
+        public ColorDataFormat ColorFormat { get; }
+
+        /// <inheritdoc />
+        public ColorDataColorimetry Colorimetry { get; }
+
+        /// <inheritdoc />
+        public ColorDataDesktopDepth? DesktopColorDepth { get; }
+
+        /// <inheritdoc />
+        public ColorDataDynamicRange? DynamicRange { get; }
+
+        /// <inheritdoc />
+        public ColorDataSelectionPolicy? SelectionPolicy { get; }
+
+        /// <inheritdoc />
+        public bool Equals(ColorData other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return ColorDepth == other.ColorDepth &&
+                   ColorFormat == other.ColorFormat &&
+                   Colorimetry == other.Colorimetry &&
+                   DesktopColorDepth == other.DesktopColorDepth &&
+                   DynamicRange == other.DynamicRange &&
+                   SelectionPolicy == other.SelectionPolicy;
+        }
+
+        /// <summary>
+        ///     Compares two instances of <see cref="ColorData" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>true if two instances are equal; otherwise false.</returns>
+        public static bool operator ==(ColorData left, ColorData right)
+        {
+            return left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instances of <see cref="ColorData" /> for inequality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>true if two instances are not equal; otherwise false.</returns>
+        public static bool operator !=(ColorData left, ColorData right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((ColorData) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = ColorDepth.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) ColorFormat;
+                hashCode = (hashCode * 397) ^ (int) Colorimetry;
+                hashCode = (hashCode * 397) ^ DesktopColorDepth.GetHashCode();
+                hashCode = (hashCode * 397) ^ DynamicRange.GetHashCode();
+                hashCode = (hashCode * 397) ^ SelectionPolicy.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        internal ColorDataV1 AsColorDataV1(ColorDataCommand command)
+        {
+            return new ColorDataV1(
+                command,
+                ColorFormat,
+                Colorimetry
+            );
+        }
+
+        internal ColorDataV2 AsColorDataV2(ColorDataCommand command)
+        {
+            return new ColorDataV2(
+                command,
+                ColorFormat,
+                Colorimetry,
+                DynamicRange ?? ColorDataDynamicRange.Auto
+            );
+        }
+
+        internal ColorDataV3 AsColorDataV3(ColorDataCommand command)
+        {
+            return new ColorDataV3(
+                command,
+                ColorFormat,
+                Colorimetry,
+                DynamicRange ?? ColorDataDynamicRange.Auto,
+                ColorDepth ?? ColorDataDepth.Default
+            );
+        }
+
+        internal ColorDataV4 AsColorDataV4(ColorDataCommand command)
+        {
+            return new ColorDataV4(
+                command,
+                ColorFormat,
+                Colorimetry,
+                DynamicRange ?? ColorDataDynamicRange.Auto,
+                ColorDepth ?? ColorDataDepth.Default,
+                SelectionPolicy ?? ColorDataSelectionPolicy.Default
+            );
+        }
+
+        internal ColorDataV5 AsColorDataV5(ColorDataCommand command)
+        {
+            return new ColorDataV5(
+                command,
+                ColorFormat,
+                Colorimetry,
+                DynamicRange ?? ColorDataDynamicRange.Auto,
+                ColorDepth ?? ColorDataDepth.Default,
+                SelectionPolicy ?? ColorDataSelectionPolicy.Default,
+                DesktopColorDepth ?? ColorDataDesktopDepth.Default
+            );
+        }
+    }
+}

NvAPIWrapper/Display/CustomResolution.cs

@@ -0,0 +1,245 @@
+using System;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Hold information about a custom display resolution
+    /// </summary>
+    public class CustomResolution : IEquatable<CustomResolution>
+    {
+        /// <summary>
+        ///     Creates an instance of <see cref="CustomResolution" />.
+        /// </summary>
+        /// <param name="width">The screen width.</param>
+        /// <param name="height">The screen height.</param>
+        /// <param name="colorFormat">The color format.</param>
+        /// <param name="timing">The resolution timing.</param>
+        /// <param name="xRatio">The horizontal scaling ratio.</param>
+        /// <param name="yRatio">The vertical scaling ratio.</param>
+        public CustomResolution(
+            uint width,
+            uint height,
+            ColorFormat colorFormat,
+            Timing timing,
+            float xRatio = 1,
+            float yRatio = 1
+        )
+        {
+            if (xRatio <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(xRatio));
+            }
+
+            if (yRatio <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(yRatio));
+            }
+
+            Width = width;
+            Height = height;
+            ColorFormat = colorFormat;
+            XRatio = xRatio;
+            YRatio = yRatio;
+            Timing = timing;
+
+            switch (ColorFormat)
+            {
+                case ColorFormat.P8:
+                    ColorDepth = 8;
+
+                    break;
+                case ColorFormat.R5G6B5:
+                    ColorDepth = 16;
+
+                    break;
+                case ColorFormat.A8R8G8B8:
+                    ColorDepth = 24;
+
+                    break;
+                case ColorFormat.A16B16G16R16F:
+                    ColorDepth = 32;
+
+                    break;
+                default:
+                    throw new ArgumentException("Color format is invalid.", nameof(colorFormat));
+            }
+        }
+
+        /// <summary>
+        ///     Creates an instance of <see cref="CustomResolution" />.
+        /// </summary>
+        /// <param name="width">The screen width.</param>
+        /// <param name="height">The screen height.</param>
+        /// <param name="colorDepth">The color depth.</param>
+        /// <param name="timing">The resolution timing.</param>
+        /// <param name="xRatio">The horizontal scaling ratio.</param>
+        /// <param name="yRatio">The vertical scaling ratio.</param>
+        public CustomResolution(
+            uint width,
+            uint height,
+            uint colorDepth,
+            Timing timing,
+            float xRatio = 1,
+            float yRatio = 1)
+        {
+            if (xRatio <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(xRatio));
+            }
+
+            if (yRatio <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(yRatio));
+            }
+
+            if (colorDepth != 0 && colorDepth != 8 && colorDepth != 16 && colorDepth != 24 && colorDepth != 32)
+            {
+                throw new ArgumentOutOfRangeException(nameof(colorDepth));
+            }
+
+            Width = width;
+            Height = height;
+            ColorDepth = colorDepth;
+            ColorFormat = ColorFormat.Unknown;
+            XRatio = xRatio;
+            YRatio = yRatio;
+            Timing = timing;
+        }
+
+        internal CustomResolution(CustomDisplay customDisplay)
+        {
+            Width = customDisplay.Width;
+            Height = customDisplay.Height;
+            ColorDepth = customDisplay.Depth;
+            ColorFormat = customDisplay.ColorFormat;
+            Timing = customDisplay.Timing;
+            XRatio = customDisplay.XRatio;
+            YRatio = customDisplay.YRatio;
+        }
+
+        /// <summary>
+        ///     Gets the source surface color depth. "0" means all 8/16/32bpp.
+        /// </summary>
+        public uint ColorDepth { get; }
+
+        /// <summary>
+        ///     Gets the color format (optional)
+        /// </summary>
+        public ColorFormat ColorFormat { get; }
+
+        /// <summary>
+        ///     Gets the source surface (source mode) height.
+        /// </summary>
+        public uint Height { get; }
+
+        /// <summary>
+        ///     Gets the timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc.
+        /// </summary>
+        public Timing Timing { get; }
+
+        /// <summary>
+        ///     Gets the source surface (source mode) width.
+        /// </summary>
+        public uint Width { get; }
+
+        /// <summary>
+        ///     Gets the horizontal scaling ratio.
+        /// </summary>
+        public float XRatio { get; }
+
+        /// <summary>
+        ///     Gets the vertical scaling ratio.
+        /// </summary>
+        public float YRatio { get; }
+
+        /// <inheritdoc />
+        public bool Equals(CustomResolution other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Width == other.Width &&
+                   Height == other.Height &&
+                   ColorDepth == other.ColorDepth &&
+                   Timing.Equals(other.Timing) &&
+                   ColorFormat == other.ColorFormat &&
+                   XRatio.Equals(other.XRatio) &&
+                   YRatio.Equals(other.YRatio);
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="CustomResolution" /> for equality.
+        /// </summary>
+        /// <param name="left">An first instance of <see cref="CustomResolution" /> to compare.</param>
+        /// <param name="right">An Second instance of <see cref="CustomResolution" /> to compare.</param>
+        /// <returns>True if both instances are equal, otherwise false.</returns>
+        public static bool operator ==(CustomResolution left, CustomResolution right)
+        {
+            return Equals(left, right);
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="CustomResolution" /> for inequality.
+        /// </summary>
+        /// <param name="left">An first instance of <see cref="CustomResolution" /> to compare.</param>
+        /// <param name="right">An Second instance of <see cref="CustomResolution" /> to compare.</param>
+        /// <returns>True if both instances are not equal, otherwise false.</returns>
+        public static bool operator !=(CustomResolution left, CustomResolution right)
+        {
+            return !Equals(left, right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((CustomResolution) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = (int) Width;
+                hashCode = (hashCode * 397) ^ (int) Height;
+                hashCode = (hashCode * 397) ^ (int) ColorDepth;
+                hashCode = (hashCode * 397) ^ Timing.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) ColorFormat;
+                hashCode = (hashCode * 397) ^ XRatio.GetHashCode();
+                hashCode = (hashCode * 397) ^ YRatio.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        internal CustomDisplay AsCustomDisplay(bool hardwareModeSetOnly)
+        {
+            return new CustomDisplay(Width, Height, ColorDepth, ColorFormat, XRatio, YRatio, Timing,
+                hardwareModeSetOnly);
+        }
+    }
+}

NvAPIWrapper/Display/DVCInformation.cs

@@ -0,0 +1,325 @@
+using System;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     This class contains and provides a way to modify the Digital Vibrance Control information regarding the
+    ///     saturation level of the display or the output
+    /// </summary>
+    public class DVCInformation : IDisplayDVCInfo
+    {
+        private readonly DisplayHandle _displayHandle = DisplayHandle.DefaultHandle;
+        private readonly OutputId _outputId = OutputId.Invalid;
+        private bool? _isLegacy;
+
+        /// <summary>
+        ///     Creates a new instance of the class using a DisplayHandle
+        /// </summary>
+        /// <param name="displayHandle">The handle of the display.</param>
+        public DVCInformation(DisplayHandle displayHandle)
+        {
+            _displayHandle = displayHandle;
+        }
+
+        /// <summary>
+        ///     Creates a new instance of this class using a OutputId
+        /// </summary>
+        /// <param name="outputId">The output identification of a display or an output</param>
+        public DVCInformation(OutputId outputId)
+        {
+            _outputId = outputId;
+        }
+
+        /// <summary>
+        ///     Gets and sets the normalized saturation level in the [-1,1] inclusive range.
+        ///     a -1 value corresponds to the minimum saturation level and maximum under-saturation and the
+        ///     a 1 value corresponds to the maximum saturation level and maximum over-saturation.
+        ///     The value of 0 indicates the default saturation level.
+        /// </summary>
+        public double NormalizedLevel
+        {
+            get
+            {
+                var info = GetInfo();
+
+                if (info == null)
+                {
+                    return double.NaN;
+                }
+
+                var deviance = info.CurrentLevel - info.DefaultLevel;
+                var range = deviance >= 0
+                    ? info.MaximumLevel - info.DefaultLevel
+                    : info.DefaultLevel - info.MinimumLevel;
+
+                if (deviance == 0 || range == 0)
+                {
+                    return 0;
+                }
+
+                return Math.Max(Math.Min((double) deviance / range, 1), -1);
+            }
+            set
+            {
+                if (double.IsNaN(value) || double.IsInfinity(value))
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                var info = GetInfo();
+
+                if (info == null)
+                {
+                    return;
+                }
+
+                var range = value >= 0 ? info.MaximumLevel - info.DefaultLevel : info.DefaultLevel - info.MinimumLevel;
+                var level = Math.Max(Math.Min((int) (value * range) + info.DefaultLevel, info.MaximumLevel), info.MinimumLevel);
+
+                if (level == info.CurrentLevel)
+                {
+                    return;
+                }
+
+                SetLevel(level);
+            }
+        }
+
+        /// <summary>
+        ///     Gets and sets the current saturation level
+        /// </summary>
+        public int CurrentLevel
+        {
+            get => GetInfo()?.CurrentLevel ?? 0;
+            set
+            {
+                var info = GetInfo();
+
+                if (info == null)
+                {
+                    return;
+                }
+
+                value = Math.Max(Math.Min(value, info.MaximumLevel), info.MinimumLevel);
+
+                if (info.CurrentLevel == value)
+                {
+                    return;
+                }
+
+                SetLevel(value);
+            }
+        }
+
+        /// <inheritdoc />
+        public int DefaultLevel
+        {
+            get => GetInfo()?.DefaultLevel ?? 0;
+        }
+
+        /// <inheritdoc />
+        public int MaximumLevel
+        {
+            get => GetInfo()?.MaximumLevel ?? 0;
+        }
+
+        /// <inheritdoc />
+        public int MinimumLevel
+        {
+            get => GetInfo()?.MinimumLevel ?? 0;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"{CurrentLevel:D} @ [{MinimumLevel:D} <= {DefaultLevel:D} <= {MaximumLevel:D}] = {NormalizedLevel:F2}";
+        }
+
+        private IDisplayDVCInfo GetInfo()
+        {
+            if (_isLegacy == true)
+            {
+                return GetLegacyInfo();
+            }
+
+            if (_isLegacy == false)
+            {
+                return GetModernInfo();
+            }
+
+            var info = GetModernInfo() ?? GetLegacyInfo();
+
+            if (info == null)
+            {
+                // exception occured on both, force a mode
+                _isLegacy = false;
+
+                return GetInfo();
+            }
+
+            return info;
+        }
+
+        private IDisplayDVCInfo GetLegacyInfo()
+        {
+            try
+            {
+                var info = _outputId == OutputId.Invalid
+                    ? DisplayApi.GetDVCInfo(_displayHandle)
+                    : DisplayApi.GetDVCInfo(_outputId);
+
+                if (info.MaximumLevel == 0 && info.MinimumLevel == 0 && info.CurrentLevel == 0)
+                {
+                    return null;
+                }
+
+                if (!_isLegacy.HasValue)
+                {
+                    _isLegacy = true;
+                }
+
+
+                return info;
+            }
+            catch (Exception)
+            {
+                if (_isLegacy == true)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            return null;
+        }
+
+        private IDisplayDVCInfo GetModernInfo()
+        {
+            try
+            {
+                var info = _outputId == OutputId.Invalid
+                    ? DisplayApi.GetDVCInfoEx(_displayHandle)
+                    : DisplayApi.GetDVCInfoEx(_outputId);
+
+                if (info.MaximumLevel == 0 && info.MinimumLevel == 0 && info.CurrentLevel == 0)
+                {
+                    return null;
+                }
+
+                if (!_isLegacy.HasValue)
+                {
+                    _isLegacy = false;
+                }
+
+                return info;
+            }
+            catch (Exception)
+            {
+                if (_isLegacy == false)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            return null;
+        }
+
+        private bool SetLegacyLevel(int level)
+        {
+            try
+            {
+                if (_outputId == OutputId.Invalid)
+                {
+                    DisplayApi.SetDVCLevel(_displayHandle, level);
+                }
+                else
+                {
+                    DisplayApi.SetDVCLevel(_outputId, level);
+                }
+
+                if (!_isLegacy.HasValue)
+                {
+                    _isLegacy = true;
+                }
+
+                return true;
+            }
+            catch (Exception)
+            {
+                if (_isLegacy == true)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            return false;
+        }
+
+        private void SetLevel(int level)
+        {
+            if (_isLegacy == true)
+            {
+                SetLegacyLevel(level);
+            }
+            else if (_isLegacy == false)
+            {
+                SetModernLevel(level);
+            }
+            else
+            {
+                var success = SetModernLevel(level) || SetLegacyLevel(level);
+
+                if (!success)
+                {
+                    // exception occured on both, force a mode
+                    _isLegacy = false;
+
+                    SetLevel(level);
+                }
+            }
+        }
+
+        private bool SetModernLevel(int level)
+        {
+            try
+            {
+                if (_outputId == OutputId.Invalid)
+                {
+                    DisplayApi.SetDVCLevelEx(_displayHandle, level);
+                }
+                else
+                {
+                    DisplayApi.SetDVCLevelEx(_outputId, level);
+                }
+
+                if (!_isLegacy.HasValue)
+                {
+                    _isLegacy = false;
+                }
+
+                return true;
+            }
+            catch (Exception)
+            {
+                if (_isLegacy == false)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            return false;
+        }
+    }
+}

NvAPIWrapper/Display/Display.cs

@@ -0,0 +1,232 @@
+using System;
+using System.Linq;
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents an attached display
+    /// </summary>
+    public class Display : IEquatable<Display>
+    {
+        /// <summary>
+        ///     Creates a new Display
+        /// </summary>
+        /// <param name="handle">Handle of the display device</param>
+        public Display(DisplayHandle handle)
+        {
+            Handle = handle;
+        }
+
+        /// <summary>
+        ///     Creates a new Display
+        /// </summary>
+        /// <param name="displayName">Name of the display device</param>
+        public Display(string displayName)
+        {
+            Handle = DisplayApi.GetAssociatedNvidiaDisplayHandle(displayName);
+        }
+
+        /// <summary>
+        ///     Gets the corresponding Digital Vibrance Control information
+        /// </summary>
+        public DVCInformation DigitalVibranceControl
+        {
+            get => new DVCInformation(Handle);
+        }
+
+        /// <summary>
+        ///     Gets corresponding DisplayDevice based on display name
+        /// </summary>
+        public DisplayDevice DisplayDevice
+        {
+            get => new DisplayDevice(Name);
+        }
+
+        /// <summary>
+        ///     Gets display driver build title
+        /// </summary>
+        public string DriverBuildTitle
+        {
+            get => DisplayApi.GetDisplayDriverBuildTitle(Handle);
+        }
+
+        /// <summary>
+        ///     Gets display handle
+        /// </summary>
+        public DisplayHandle Handle { get; }
+
+        /// <summary>
+        ///     Gets the display HDMI support information
+        /// </summary>
+        public IHDMISupportInfo HDMISupportInfo
+        {
+            get
+            {
+                var outputId = OutputId.Invalid;
+                try
+                {
+                    outputId = DisplayApi.GetAssociatedDisplayOutputId(Handle);
+                }
+                catch (NVIDIAApiException)
+                {
+                    // ignore
+                }
+                return DisplayApi.GetHDMISupportInfo(Handle, outputId);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the corresponding HUE information
+        /// </summary>
+        public HUEInformation HUEControl
+        {
+            get => new HUEInformation(Handle);
+        }
+
+        /// <summary>
+        ///     Gets the driving logical GPU
+        /// </summary>
+        public LogicalGPU LogicalGPU
+        {
+            get => new LogicalGPU(GPUApi.GetLogicalGPUFromDisplay(Handle));
+        }
+
+        /// <summary>
+        ///     Gets display name
+        /// </summary>
+        public string Name
+        {
+            get => DisplayApi.GetAssociatedNvidiaDisplayName(Handle);
+        }
+
+        /// <summary>
+        ///     Gets the connected GPU output
+        /// </summary>
+        public GPUOutput Output
+        {
+            get => new GPUOutput(DisplayApi.GetAssociatedDisplayOutputId(Handle), PhysicalGPUs.FirstOrDefault());
+        }
+
+        /// <summary>
+        ///     Gets the list of all physical GPUs responsible for this display, with the first GPU returned as the one with the
+        ///     attached active output.
+        /// </summary>
+        public PhysicalGPU[] PhysicalGPUs
+        {
+            get => GPUApi.GetPhysicalGPUsFromDisplay(Handle).Select(handle => new PhysicalGPU(handle)).ToArray();
+        }
+
+        /// <inheritdoc />
+        public bool Equals(Display other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Handle.Equals(other.Handle);
+        }
+
+        /// <summary>
+        ///     This function returns all NVIDIA displays
+        ///     Note: Display handles can get invalidated on a modeset.
+        /// </summary>
+        /// <returns>An array of Display objects</returns>
+        public static Display[] GetDisplays()
+        {
+            return DisplayApi.EnumNvidiaDisplayHandle().Select(handle => new Display(handle)).ToArray();
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(Display left, Display right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(Display left, Display right)
+        {
+            return !(right == left);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((Display) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Handle.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return Name;
+        }
+
+        /// <summary>
+        ///     Gets all the supported NVIDIA display views (nView and Dualview modes) for this display.
+        /// </summary>
+        /// <returns></returns>
+        public TargetViewMode[] GetSupportedViews()
+        {
+            return DisplayApi.GetSupportedViews(Handle);
+        }
+
+        /// <summary>
+        ///     Overrides the refresh rate on this display.
+        ///     The new refresh rate can be applied right away or deferred to be applied with the next OS
+        ///     mode-set.
+        ///     The override is good for only one mode-set (regardless whether it's deferred or immediate).
+        /// </summary>
+        /// <param name="refreshRate">The refresh rate to be applied.</param>
+        /// <param name="isDeferred">
+        ///     A boolean value indicating if the refresh rate override should be deferred to the next OS
+        ///     mode-set.
+        /// </param>
+        public void OverrideRefreshRate(float refreshRate, bool isDeferred = false)
+        {
+            DisplayApi.SetRefreshRateOverride(Handle, refreshRate, isDeferred);
+        }
+    }
+}

NvAPIWrapper/Display/DisplayDevice.cs

@@ -0,0 +1,893 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Interfaces.Display;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents an NVIDIA display device
+    /// </summary>
+    public class DisplayDevice : IEquatable<DisplayDevice>
+    {
+        /// <summary>
+        ///     Creates a new DisplayDevice
+        /// </summary>
+        /// <param name="displayId">Display identification of the device</param>
+        public DisplayDevice(uint displayId)
+        {
+            DisplayId = displayId;
+            var extraInformation = PhysicalGPU.GetDisplayDevices().FirstOrDefault(ids => ids.DisplayId == DisplayId);
+
+            if (extraInformation != null)
+            {
+                IsAvailable = true;
+                ScanOutInformation = new ScanOutInformation(this);
+                ConnectionType = extraInformation.ConnectionType;
+                IsDynamic = extraInformation.IsDynamic;
+                IsMultiStreamRootNode = extraInformation.IsMultiStreamRootNode;
+                IsActive = extraInformation.IsActive;
+                IsCluster = extraInformation.IsCluster;
+                IsOSVisible = extraInformation.IsOSVisible;
+                IsWFD = extraInformation.IsWFD;
+                IsConnected = extraInformation.IsConnected;
+                IsPhysicallyConnected = extraInformation.IsPhysicallyConnected;
+            }
+        }
+
+        /// <summary>
+        ///     Creates a new DisplayDevice
+        /// </summary>
+        /// <param name="displayIds">Display identification and attributes of the display device</param>
+        public DisplayDevice(IDisplayIds displayIds)
+        {
+            IsAvailable = true;
+            DisplayId = displayIds.DisplayId;
+            ScanOutInformation = new ScanOutInformation(this);
+            ConnectionType = displayIds.ConnectionType;
+            IsDynamic = displayIds.IsDynamic;
+            IsMultiStreamRootNode = displayIds.IsMultiStreamRootNode;
+            IsActive = displayIds.IsActive;
+            IsCluster = displayIds.IsCluster;
+            IsOSVisible = displayIds.IsOSVisible;
+            IsWFD = displayIds.IsWFD;
+            IsConnected = displayIds.IsConnected;
+            IsPhysicallyConnected = displayIds.IsPhysicallyConnected;
+        }
+
+        /// <summary>
+        ///     Creates a new DisplayDevice
+        /// </summary>
+        /// <param name="displayName">Display name of the display device</param>
+        public DisplayDevice(string displayName) : this(DisplayApi.GetDisplayIdByDisplayName(displayName))
+        {
+        }
+
+        /// <summary>
+        ///     Gets the display device connection type
+        /// </summary>
+        public MonitorConnectionType ConnectionType { get; }
+
+        /// <summary>
+        ///     Gets the current display color data
+        /// </summary>
+        public ColorData CurrentColorData
+        {
+            get
+            {
+                var instances = new IColorData[]
+                {
+                    new ColorDataV5(ColorDataCommand.Get),
+                    new ColorDataV4(ColorDataCommand.Get),
+                    new ColorDataV3(ColorDataCommand.Get),
+                    new ColorDataV2(ColorDataCommand.Get),
+                    new ColorDataV1(ColorDataCommand.Get)
+                };
+
+                var instance = DisplayApi.ColorControl(DisplayId, instances);
+
+                return new ColorData(instance);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the current display device timing
+        /// </summary>
+        public Timing CurrentTiming
+        {
+            get => DisplayApi.GetTiming(DisplayId, new TimingInput(TimingOverride.Current));
+        }
+
+        /// <summary>
+        ///     Gets the default display color data
+        /// </summary>
+        public ColorData DefaultColorData
+        {
+            get
+            {
+                var instances = new IColorData[]
+                {
+                    new ColorDataV5(ColorDataCommand.GetDefault),
+                    new ColorDataV4(ColorDataCommand.GetDefault),
+                    new ColorDataV3(ColorDataCommand.GetDefault),
+                    new ColorDataV2(ColorDataCommand.GetDefault),
+                    new ColorDataV1(ColorDataCommand.GetDefault)
+                };
+
+                var instance = DisplayApi.ColorControl(DisplayId, instances);
+
+                return new ColorData(instance);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the NVIDIA display identification
+        /// </summary>
+        public uint DisplayId { get; }
+
+        /// <summary>
+        ///     Gets the monitor Display port capabilities
+        /// </summary>
+        public MonitorColorData[] DisplayPortColorCapabilities
+        {
+            get
+            {
+                if (ConnectionType != MonitorConnectionType.DisplayPort)
+                {
+                    return null;
+                }
+
+                return DisplayApi.GetMonitorColorCapabilities(DisplayId);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the display driver EDID specified HDR capabilities
+        /// </summary>
+        public HDRCapabilitiesV1 DriverHDRCapabilities
+        {
+            get => DisplayApi.GetHDRCapabilities(DisplayId, true);
+        }
+
+        /// <summary>
+        ///     Gets the display currently effective HDR capabilities
+        /// </summary>
+        public HDRCapabilitiesV1 EffectiveHDRCapabilities
+        {
+            get => DisplayApi.GetHDRCapabilities(DisplayId, false);
+        }
+
+        /// <summary>
+        ///     Gets the HDMI audio info-frame current information
+        /// </summary>
+        public InfoFrameAudio? HDMIAudioFrameCurrentInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.Get, InfoFrameDataType.AudioInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AudioInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+
+        /// <summary>
+        ///     Gets the HDMI audio info-frame default information
+        /// </summary>
+        public InfoFrameAudio? HDMIAudioFrameDefaultInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetDefault, InfoFrameDataType.AudioInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AudioInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI audio info-frame override information
+        /// </summary>
+        public InfoFrameAudio? HDMIAudioFrameOverrideInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetOverride, InfoFrameDataType.AudioInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AudioInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI audio info-frame property information
+        /// </summary>
+        public InfoFrameProperty? HDMIAudioFramePropertyInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetProperty, InfoFrameDataType.AudioInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.PropertyInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the device HDMI support information
+        /// </summary>
+        public IHDMISupportInfo HDMISupportInfo
+        {
+            get => DisplayApi.GetHDMISupportInfo(DisplayId);
+        }
+
+
+        /// <summary>
+        ///     Gets the HDMI auxiliary video info-frame current information
+        /// </summary>
+        public InfoFrameVideo? HDMIVideoFrameCurrentInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame =
+                        new InfoFrameData(InfoFrameCommand.Get, InfoFrameDataType.AuxiliaryVideoInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AuxiliaryVideoInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI auxiliary video info-frame default information
+        /// </summary>
+        public InfoFrameVideo? HDMIVideoFrameDefaultInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetDefault,
+                        InfoFrameDataType.AuxiliaryVideoInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AuxiliaryVideoInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI auxiliary video info-frame override information
+        /// </summary>
+        public InfoFrameVideo? HDMIVideoFrameOverrideInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetOverride,
+                        InfoFrameDataType.AuxiliaryVideoInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.AuxiliaryVideoInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDMI auxiliary video info-frame property information
+        /// </summary>
+        public InfoFrameProperty? HDMIVideoFramePropertyInformation
+        {
+            get
+            {
+                try
+                {
+                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetProperty,
+                        InfoFrameDataType.AuxiliaryVideoInformation);
+                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+
+                    return infoFrame.PropertyInformation;
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the HDR color data, or null if the HDR is disabled or unavailable
+        /// </summary>
+        public HDRColorData HDRColorData
+        {
+            get
+            {
+                try
+                {
+                    var instances = new IHDRColorData[]
+                    {
+                        new HDRColorDataV2(ColorDataHDRCommand.Get),
+                        new HDRColorDataV1(ColorDataHDRCommand.Get)
+                    };
+
+                    var instance = DisplayApi.HDRColorControl(DisplayId, instances);
+
+                    if (instance.HDRMode == ColorDataHDRMode.Off)
+                    {
+                        return null;
+                    }
+
+                    return new HDRColorData(instance);
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status == Status.NotSupported)
+                    {
+                        return null;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Indicates if the display is being actively driven
+        /// </summary>
+        public bool IsActive { get; }
+
+        /// <summary>
+        ///     Indicates if the display device is currently available
+        /// </summary>
+        public bool IsAvailable { get; }
+
+        /// <summary>
+        ///     Indicates if the display is the representative display
+        /// </summary>
+        public bool IsCluster { get; }
+
+        /// <summary>
+        ///     Indicates if the display is connected
+        /// </summary>
+        public bool IsConnected { get; }
+
+        /// <summary>
+        ///     Indicates if the display is part of MST topology and it's a dynamic
+        /// </summary>
+        public bool IsDynamic { get; }
+
+        /// <summary>
+        ///     Indicates if the display identification belongs to a multi stream enabled connector (root node). Note that when
+        ///     multi stream is enabled and a single multi stream capable monitor is connected to it, the monitor will share the
+        ///     display id with the RootNode.
+        ///     When there is more than one monitor connected in a multi stream topology, then the root node will have a separate
+        ///     displayId.
+        /// </summary>
+        public bool IsMultiStreamRootNode { get; }
+
+        /// <summary>
+        ///     Indicates if the display is reported to the OS
+        /// </summary>
+        public bool IsOSVisible { get; }
+
+        /// <summary>
+        ///     Indicates if the display is a physically connected display; Valid only when IsConnected is true
+        /// </summary>
+        public bool IsPhysicallyConnected { get; }
+
+        /// <summary>
+        ///     Indicates if the display is wireless
+        /// </summary>
+        public bool IsWFD { get; }
+
+        /// <summary>
+        ///     Gets the connected GPU output
+        /// </summary>
+        public GPUOutput Output
+        {
+            get
+            {
+                PhysicalGPUHandle handle;
+                var outputId = GPUApi.GetGPUAndOutputIdFromDisplayId(DisplayId, out handle);
+
+                return new GPUOutput(outputId, new PhysicalGPU(handle));
+            }
+        }
+
+        /// <summary>
+        ///     Gets the connected physical GPU
+        /// </summary>
+        public PhysicalGPU PhysicalGPU
+        {
+            get
+            {
+                try
+                {
+                    var gpuHandle = GPUApi.GetPhysicalGPUFromDisplayId(DisplayId);
+
+                    return new PhysicalGPU(gpuHandle);
+                }
+                catch
+                {
+                    // ignored
+                }
+
+                return Output.PhysicalGPU;
+            }
+        }
+
+        /// <summary>
+        ///     Gets information regarding the scan-out settings of this display device
+        /// </summary>
+        public ScanOutInformation ScanOutInformation { get; }
+
+        /// <summary>
+        ///     Gets monitor capabilities from the Video Capability Data Block if available, otherwise null
+        /// </summary>
+        public MonitorVCDBCapabilities? VCDBMonitorCapabilities
+        {
+            get => DisplayApi.GetMonitorCapabilities(DisplayId, MonitorCapabilitiesType.VCDB)?.VCDBCapabilities;
+        }
+
+        /// <summary>
+        ///     Gets monitor capabilities from the Vendor Specific Data Block if available, otherwise null
+        /// </summary>
+        public MonitorVSDBCapabilities? VSDBMonitorCapabilities
+        {
+            get => DisplayApi.GetMonitorCapabilities(DisplayId, MonitorCapabilitiesType.VSDB)?.VSDBCapabilities;
+        }
+
+        /// <inheritdoc />
+        public bool Equals(DisplayDevice other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return DisplayId == other.DisplayId;
+        }
+
+        /// <summary>
+        ///     Deletes a custom resolution.
+        /// </summary>
+        /// <param name="customResolution">The custom resolution to delete.</param>
+        /// <param name="displayIds">A list of display ids to remove the custom resolution from.</param>
+        public static void DeleteCustomResolution(CustomResolution customResolution, uint[] displayIds)
+        {
+            var customDisplay = customResolution.AsCustomDisplay(false);
+            DisplayApi.DeleteCustomDisplay(displayIds, customDisplay);
+        }
+
+        /// <summary>
+        ///     Returns an instance of <see cref="DisplayDevice" /> representing the primary GDI display device.
+        /// </summary>
+        /// <returns>An instance of <see cref="DisplayDevice" />.</returns>
+        public static DisplayDevice GetGDIPrimaryDisplayDevice()
+        {
+            var displayId = DisplayApi.GetGDIPrimaryDisplayId();
+
+            if (displayId == 0)
+            {
+                return null;
+            }
+
+            return new DisplayDevice(displayId);
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(DisplayDevice left, DisplayDevice right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(DisplayDevice left, DisplayDevice right)
+        {
+            return !(right == left);
+        }
+
+        /// <summary>
+        ///     Reverts the custom resolution currently on trial.
+        /// </summary>
+        /// <param name="displayIds">A list of display ids to revert the custom resolution from.</param>
+        public static void RevertCustomResolution(uint[] displayIds)
+        {
+            DisplayApi.RevertCustomDisplayTrial(displayIds);
+        }
+
+        /// <summary>
+        ///     Saves the custom resolution currently on trial.
+        /// </summary>
+        /// <param name="displayIds">A list of display ids to save the custom resolution for.</param>
+        /// <param name="isThisOutputIdOnly">
+        ///     If set, the saved custom display will only be applied on the monitor with the same
+        ///     outputId.
+        /// </param>
+        /// <param name="isThisMonitorOnly">
+        ///     If set, the saved custom display will only be applied on the monitor with the same EDID
+        ///     ID or the same TV connector in case of analog TV.
+        /// </param>
+        public static void SaveCustomResolution(uint[] displayIds, bool isThisOutputIdOnly, bool isThisMonitorOnly)
+        {
+            DisplayApi.SaveCustomDisplay(displayIds, isThisOutputIdOnly, isThisMonitorOnly);
+        }
+
+        /// <summary>
+        ///     Applies a custom resolution into trial
+        /// </summary>
+        /// <param name="customResolution">The custom resolution to apply.</param>
+        /// <param name="displayIds">A list of display ids to apply the custom resolution on.</param>
+        /// <param name="hardwareModeSetOnly">
+        ///     A boolean value indicating that a hardware mode-set without OS update should be
+        ///     performed.
+        /// </param>
+        public static void TrialCustomResolution(
+            CustomResolution customResolution,
+            uint[] displayIds,
+            bool hardwareModeSetOnly = true)
+        {
+            var customDisplay = customResolution.AsCustomDisplay(hardwareModeSetOnly);
+            DisplayApi.TryCustomDisplay(displayIds.ToDictionary(u => u, u => customDisplay));
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((DisplayDevice) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return (int) DisplayId;
+        }
+
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"Display #{DisplayId}";
+        }
+
+        /// <summary>
+        ///     Calculates a valid timing based on the argument passed
+        /// </summary>
+        /// <param name="width">The preferred width.</param>
+        /// <param name="height">The preferred height.</param>
+        /// <param name="refreshRate">The preferred refresh rate.</param>
+        /// <param name="isInterlaced">The boolean value indicating if the preferred resolution is an interlaced resolution.</param>
+        /// <returns>Returns a valid instance of <see cref="Timing" />.</returns>
+        public Timing CalculateTiming(uint width, uint height, float refreshRate, bool isInterlaced)
+        {
+            return DisplayApi.GetTiming(
+                DisplayId,
+                new TimingInput(width, height, refreshRate, TimingOverride.Auto, isInterlaced)
+            );
+        }
+
+        /// <summary>
+        ///     Deletes a custom resolution.
+        /// </summary>
+        /// <param name="customResolution">The custom resolution to delete.</param>
+        public void DeleteCustomResolution(CustomResolution customResolution)
+        {
+            DeleteCustomResolution(customResolution, new[] {DisplayId});
+        }
+
+        /// <summary>
+        ///     Retrieves the list of custom resolutions saved for this display device
+        /// </summary>
+        /// <returns>A list of <see cref="CustomResolution" /> instances.</returns>
+        public IEnumerable<CustomResolution> GetCustomResolutions()
+        {
+            return DisplayApi.EnumCustomDisplays(DisplayId).Select(custom => new CustomResolution(custom));
+        }
+
+        /// <summary>
+        ///     Checks if a color data is supported on this display
+        /// </summary>
+        /// <param name="colorData">The color data to be checked.</param>
+        /// <returns>true if the color data passed is supported; otherwise false</returns>
+        public bool IsColorDataSupported(ColorData colorData)
+        {
+            var instances = new IColorData[]
+            {
+                colorData.AsColorDataV5(ColorDataCommand.IsSupportedColor),
+                colorData.AsColorDataV4(ColorDataCommand.IsSupportedColor),
+                colorData.AsColorDataV3(ColorDataCommand.IsSupportedColor),
+                colorData.AsColorDataV2(ColorDataCommand.IsSupportedColor),
+                colorData.AsColorDataV1(ColorDataCommand.IsSupportedColor)
+            };
+
+            try
+            {
+                DisplayApi.ColorControl(DisplayId, instances);
+
+                return true;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status == Status.NotSupported)
+                {
+                    return false;
+                }
+
+                throw;
+            }
+        }
+
+        /// <summary>
+        ///     Resets the HDMI audio info-frame information to default
+        /// </summary>
+        public void ResetHDMIAudioFrameInformation()
+        {
+            var infoFrame = new InfoFrameData(
+                InfoFrameCommand.Reset,
+                InfoFrameDataType.AudioInformation
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Resets the HDMI auxiliary video info-frame information to default
+        /// </summary>
+        public void ResetHDMIVideoFrameInformation()
+        {
+            var infoFrame = new InfoFrameData(
+                InfoFrameCommand.Reset,
+                InfoFrameDataType.AuxiliaryVideoInformation
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Reverts the custom resolution currently on trial.
+        /// </summary>
+        public void RevertCustomResolution()
+        {
+            RevertCustomResolution(new[] {DisplayId});
+        }
+
+        /// <summary>
+        ///     Saves the custom resolution currently on trial.
+        /// </summary>
+        /// <param name="isThisOutputIdOnly">
+        ///     If set, the saved custom display will only be applied on the monitor with the same
+        ///     outputId.
+        /// </param>
+        /// <param name="isThisMonitorOnly">
+        ///     If set, the saved custom display will only be applied on the monitor with the same EDID
+        ///     ID or the same TV connector in case of analog TV.
+        /// </param>
+        public void SaveCustomResolution(bool isThisOutputIdOnly = true, bool isThisMonitorOnly = true)
+        {
+            SaveCustomResolution(new[] {DisplayId}, isThisOutputIdOnly, isThisMonitorOnly);
+        }
+
+        /// <summary>
+        ///     Changes the display current color data configuration
+        /// </summary>
+        /// <param name="colorData">The color data to be set.</param>
+        public void SetColorData(ColorData colorData)
+        {
+            var instances = new IColorData[]
+            {
+                colorData.AsColorDataV5(ColorDataCommand.Set),
+                colorData.AsColorDataV4(ColorDataCommand.Set),
+                colorData.AsColorDataV3(ColorDataCommand.Set),
+                colorData.AsColorDataV2(ColorDataCommand.Set),
+                colorData.AsColorDataV1(ColorDataCommand.Set)
+            };
+
+            DisplayApi.ColorControl(DisplayId, instances);
+        }
+
+        /// <summary>
+        ///     Sets the HDMI video info-frame current or override information
+        /// </summary>
+        /// <param name="audio">The new information.</param>
+        /// <param name="isOverride">A boolean value indicating if the changes should persist mode-set and OS restart.</param>
+        public void SetHDMIAudioFrameInformation(InfoFrameAudio audio, bool isOverride = false)
+        {
+            var infoFrame = new InfoFrameData(
+                isOverride ? InfoFrameCommand.SetOverride : InfoFrameCommand.Set,
+                audio
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Sets the HDMI audio info-frame property information
+        /// </summary>
+        /// <param name="property">The new property information.</param>
+        public void SetHDMIAudioFramePropertyInformation(InfoFrameProperty property)
+        {
+            var infoFrame = new InfoFrameData(
+                InfoFrameCommand.SetProperty,
+                InfoFrameDataType.AudioInformation,
+                property
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Sets the HDMI auxiliary video info-frame current or override information
+        /// </summary>
+        /// <param name="video">The new information.</param>
+        /// <param name="isOverride">A boolean value indicating if the changes should persist mode-set and OS restart.</param>
+        public void SetHDMIVideoFrameInformation(InfoFrameVideo video, bool isOverride = false)
+        {
+            var infoFrame = new InfoFrameData(
+                isOverride ? InfoFrameCommand.SetOverride : InfoFrameCommand.Set,
+                video
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Sets the HDMI auxiliary video info-frame property information
+        /// </summary>
+        /// <param name="property">The new property information.</param>
+        public void SetHDMIVideoFramePropertyInformation(InfoFrameProperty property)
+        {
+            var infoFrame = new InfoFrameData(
+                InfoFrameCommand.SetProperty,
+                InfoFrameDataType.AuxiliaryVideoInformation,
+                property
+            );
+            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
+        }
+
+        /// <summary>
+        ///     Changes the display HDR color data configuration
+        /// </summary>
+        /// <param name="colorData">The color data to be set.</param>
+        public void SetHDRColorData(HDRColorData colorData)
+        {
+            var instances = new IHDRColorData[]
+            {
+                colorData.AsHDRColorDataV2(ColorDataHDRCommand.Set),
+                colorData.AsHDRColorDataV1(ColorDataHDRCommand.Set)
+            };
+
+            DisplayApi.HDRColorControl(DisplayId, instances);
+        }
+
+        /// <summary>
+        ///     Applies a custom resolution into trial.
+        /// </summary>
+        /// <param name="customResolution">The custom resolution to apply.</param>
+        /// <param name="hardwareModeSetOnly">
+        ///     A boolean value indicating that a hardware mode-set without OS update should be
+        ///     performed.
+        /// </param>
+        public void TrialCustomResolution(CustomResolution customResolution, bool hardwareModeSetOnly = true)
+        {
+            TrialCustomResolution(customResolution, new[] {DisplayId}, hardwareModeSetOnly);
+        }
+    }
+}

NvAPIWrapper/Display/FloatTexture.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Linq;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a texture of float values
+    /// </summary>
+    public class FloatTexture : IEquatable<FloatTexture>
+    {
+        /// <summary>
+        ///     Underlying float array containing the values of all channels in all pixels
+        /// </summary>
+        protected readonly float[] UnderlyingArray;
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="FloatTexture" />.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        /// <param name="channels">The number of texture channels.</param>
+        public FloatTexture(int width, int height, int channels) : this(width, height, channels, null)
+        {
+        }
+
+        /// <summary>
+        ///     Creates a new instance of <see cref="FloatTexture" />.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        /// <param name="channels">The number of texture channels.</param>
+        /// <param name="array">The underlying array containing all float values.</param>
+        // ReSharper disable once TooManyDependencies
+        protected FloatTexture(int width, int height, int channels, float[] array)
+        {
+            Width = width;
+            Height = height;
+            Channels = channels;
+            UnderlyingArray = array ?? new float[width * height * channels];
+        }
+
+        /// <summary>
+        ///     Gets the number of texture channels
+        /// </summary>
+        public int Channels { get; }
+
+        /// <summary>
+        ///     Gets the texture height in pixel
+        /// </summary>
+        public int Height { get; }
+
+        /// <summary>
+        ///     Gets the texture width in pixels
+        /// </summary>
+        public int Width { get; }
+
+        /// <inheritdoc />
+        public bool Equals(FloatTexture other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            if (other.UnderlyingArray.Length != UnderlyingArray.Length)
+            {
+                return false;
+            }
+
+            if (other.Width != Width || other.Height != Height || other.Channels != Channels)
+            {
+                return false;
+            }
+
+            return !UnderlyingArray.Where((t, i) => Math.Abs(other.UnderlyingArray[i] - t) > 0.0001).Any();
+        }
+
+        /// <summary>
+        ///     Returns a new instance of FloatTexture from the passed array of float values.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        /// <param name="channels">The texture channels.</param>
+        /// <param name="floats">The array of float values.</param>
+        /// <returns>A new instance of <see cref="FloatTexture" />.</returns>
+        // ReSharper disable once TooManyArguments
+        public static FloatTexture FromFloatArray(int width, int height, int channels, float[] floats)
+        {
+            if (floats.Length != width * height * channels)
+            {
+                throw new ArgumentOutOfRangeException(nameof(floats));
+            }
+
+            return new FloatTexture(width, height, channels, floats.ToArray());
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="FloatTexture" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
+        public static bool operator ==(FloatTexture left, FloatTexture right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="FloatTexture" /> for in-equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
+        public static bool operator !=(FloatTexture left, FloatTexture right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as FloatTexture);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return UnderlyingArray.GetHashCode();
+        }
+
+        /// <summary>
+        ///     Gets the values of each channel at a specific location
+        /// </summary>
+        /// <param name="x">The horizontal location.</param>
+        /// <param name="y">The vertical location.</param>
+        /// <returns>An array of float values each representing a channel value.</returns>
+        public float[] GetValues(int x, int y)
+        {
+            return UnderlyingArray.Skip(y * Width + x).Take(Channels).ToArray();
+        }
+
+        /// <summary>
+        ///     Sets the value of each channel at a specific location
+        /// </summary>
+        /// <param name="x">The horizontal location.</param>
+        /// <param name="y">The vertical location.</param>
+        /// <param name="floats">An array of float values each representing a channel value.</param>
+        public void SetValues(int x, int y, params float[] floats)
+        {
+            var index = y * Width + x;
+
+            for (var i = 0; i < Math.Min(Channels, floats.Length); i++)
+            {
+                UnderlyingArray[index + i] = floats[i];
+            }
+        }
+
+        /// <summary>
+        ///     Returns this instance of <see cref="FloatTexture" /> as an array of float values.
+        /// </summary>
+        /// <returns>An array of float values representing this instance of <see cref="FloatTexture" />.</returns>
+        public float[] ToFloatArray()
+        {
+            // Returns a copy of the underlying array
+            return UnderlyingArray.ToArray();
+        }
+    }
+}

NvAPIWrapper/Display/HDRColorData.cs

@@ -0,0 +1,157 @@
+using System;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <inheritdoc cref="IHDRColorData" />
+    public class HDRColorData : IHDRColorData, IEquatable<HDRColorData>
+    {
+        /// <summary>
+        ///     Creates an instance of <see cref="HDRColorData" />.
+        /// </summary>
+        /// <param name="hdrMode">The hdr mode.</param>
+        /// <param name="masteringDisplayData">The display color space configurations.</param>
+        /// <param name="colorFormat">The color data color format.</param>
+        /// <param name="dynamicRange">The color data dynamic range.</param>
+        /// <param name="colorDepth">The color data color depth.</param>
+        public HDRColorData(
+            ColorDataHDRMode hdrMode,
+            MasteringDisplayColorData masteringDisplayData,
+            ColorDataFormat? colorFormat = null,
+            ColorDataDynamicRange? dynamicRange = null,
+            ColorDataDepth? colorDepth = null
+        )
+        {
+            HDRMode = hdrMode;
+            MasteringDisplayData = masteringDisplayData;
+            ColorFormat = colorFormat;
+            DynamicRange = dynamicRange;
+            ColorDepth = colorDepth;
+        }
+
+        internal HDRColorData(IHDRColorData colorData)
+        {
+            HDRMode = colorData.HDRMode;
+            MasteringDisplayData = colorData.MasteringDisplayData;
+            ColorDepth = colorData.ColorDepth;
+            ColorFormat = colorData.ColorFormat;
+            DynamicRange = colorData.DynamicRange;
+        }
+
+        /// <inheritdoc />
+        public bool Equals(HDRColorData other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return ColorDepth == other.ColorDepth &&
+                   ColorFormat == other.ColorFormat &&
+                   DynamicRange == other.DynamicRange &&
+                   HDRMode == other.HDRMode &&
+                   MasteringDisplayData.Equals(other.MasteringDisplayData);
+        }
+
+        /// <inheritdoc />
+        public ColorDataDepth? ColorDepth { get; }
+
+        /// <inheritdoc />
+        public ColorDataFormat? ColorFormat { get; }
+
+        /// <inheritdoc />
+        public ColorDataDynamicRange? DynamicRange { get; }
+
+        /// <inheritdoc />
+        public ColorDataHDRMode HDRMode { get; }
+
+        /// <inheritdoc />
+        public MasteringDisplayColorData MasteringDisplayData { get; }
+
+        /// <summary>
+        ///     Compares two instances of <see cref="HDRColorData" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>true if two instances are equal; otherwise false.</returns>
+        public static bool operator ==(HDRColorData left, HDRColorData right)
+        {
+            return left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instances of <see cref="HDRColorData" /> for inequality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>true if two instances are not equal; otherwise false.</returns>
+        public static bool operator !=(HDRColorData left, HDRColorData right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((HDRColorData) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = ColorDepth.GetHashCode();
+                hashCode = (hashCode * 397) ^ ColorFormat.GetHashCode();
+                hashCode = (hashCode * 397) ^ DynamicRange.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) HDRMode;
+                hashCode = (hashCode * 397) ^ MasteringDisplayData.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        internal HDRColorDataV1 AsHDRColorDataV1(ColorDataHDRCommand command)
+        {
+            return new HDRColorDataV1(
+                command,
+                HDRMode,
+                MasteringDisplayData
+            );
+        }
+
+        internal HDRColorDataV2 AsHDRColorDataV2(ColorDataHDRCommand command)
+        {
+            return new HDRColorDataV2(
+                command,
+                HDRMode,
+                MasteringDisplayData,
+                ColorFormat ?? ColorDataFormat.Auto,
+                DynamicRange ?? ColorDataDynamicRange.Auto,
+                ColorDepth ?? ColorDataDepth.Default
+            );
+        }
+    }
+}

NvAPIWrapper/Display/HUEInformation.cs

@@ -0,0 +1,97 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     This class contains and provides a way to modify the HUE angle
+    /// </summary>
+    public class HUEInformation
+    {
+        private readonly DisplayHandle _displayHandle = DisplayHandle.DefaultHandle;
+        private readonly OutputId _outputId = OutputId.Invalid;
+
+        /// <summary>
+        ///     Creates a new instance of the class using a DisplayHandle
+        /// </summary>
+        /// <param name="displayHandle">The handle of the display.</param>
+        public HUEInformation(DisplayHandle displayHandle)
+        {
+            _displayHandle = displayHandle;
+        }
+
+        /// <summary>
+        ///     Creates a new instance of this class using a OutputId
+        /// </summary>
+        /// <param name="outputId">The output identification of a display or an output</param>
+        public HUEInformation(OutputId outputId)
+        {
+            _outputId = outputId;
+        }
+
+        /// <summary>
+        ///     Gets or sets the current HUE offset angle [0-359]
+        /// </summary>
+        public int CurrentAngle
+        {
+            get
+            {
+                PrivateDisplayHUEInfo? hueInfo = null;
+
+                if (_displayHandle != DisplayHandle.DefaultHandle)
+                {
+                    hueInfo = DisplayApi.GetHUEInfo(_displayHandle);
+                }
+                else if (_outputId != OutputId.Invalid)
+                {
+                    hueInfo = DisplayApi.GetHUEInfo(_outputId);
+                }
+
+                return hueInfo?.CurrentAngle ?? 0;
+            }
+            set
+            {
+                value %= 360;
+
+                if (_displayHandle != DisplayHandle.DefaultHandle)
+                {
+                    DisplayApi.SetHUEAngle(_displayHandle, value);
+                }
+                else if (_outputId != OutputId.Invalid)
+                {
+                    DisplayApi.SetHUEAngle(_outputId, value);
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the default HUE offset angle [0-359]
+        /// </summary>
+        public int DefaultAngle
+        {
+            get
+            {
+                PrivateDisplayHUEInfo? hueInfo = null;
+
+                if (_displayHandle != DisplayHandle.DefaultHandle)
+                {
+                    hueInfo = DisplayApi.GetHUEInfo(_displayHandle);
+                }
+                else if (_outputId != OutputId.Invalid)
+                {
+                    hueInfo = DisplayApi.GetHUEInfo(_outputId);
+                }
+
+                return hueInfo?.DefaultAngle ?? 0;
+            }
+        }
+
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{CurrentAngle:D}º [{DefaultAngle:D}º]";
+        }
+    }
+}

NvAPIWrapper/Display/IntensityTexture.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Linq;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a texture of intensity values
+    /// </summary>
+    public class IntensityTexture : FloatTexture
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="IntensityTexture" />.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        public IntensityTexture(int width, int height) : base(width, height, 3)
+        {
+        }
+
+        private IntensityTexture(int width, int height, float[] floats) : base(width, height, 3, floats)
+        {
+        }
+
+        /// <summary>
+        ///     Returns a new instance of FloatTexture from the passed array of float values.
+        /// </summary>
+        /// <param name="width">The texture width.</param>
+        /// <param name="height">The texture height.</param>
+        /// <param name="floats">The array of float values.</param>
+        /// <returns>A new instance of <see cref="FloatTexture" />.</returns>
+        // ReSharper disable once TooManyArguments
+        public static IntensityTexture FromFloatArray(int width, int height, float[] floats)
+        {
+            if (floats.Length != width * height * 3)
+            {
+                throw new ArgumentOutOfRangeException(nameof(floats));
+            }
+
+            return new IntensityTexture(width, height, floats.ToArray());
+        }
+
+        /// <summary>
+        ///     Gets the value of intensity pixel at a specific location.
+        /// </summary>
+        /// <param name="x">The horizontal location.</param>
+        /// <param name="y">The vertical location.</param>
+        /// <returns>An instance of <see cref="IntensityTexturePixel" />.</returns>
+        public IntensityTexturePixel GetPixel(int x, int y)
+        {
+            return IntensityTexturePixel.FromFloatArray(UnderlyingArray, y * Width + x);
+        }
+
+        /// <summary>
+        ///     Sets the value of intensity pixel at a specific location
+        /// </summary>
+        /// <param name="x">The horizontal location.</param>
+        /// <param name="y">The vertical location.</param>
+        /// <param name="pixel">An instance of <see cref="IntensityTexturePixel" />.</param>
+        public void SetPixel(int x, int y, IntensityTexturePixel pixel)
+        {
+            var index = y * Width + x;
+            var floats = pixel.ToFloatArray();
+
+            for (var i = 0; i < Math.Min(Channels, floats.Length); i++)
+            {
+                UnderlyingArray[index + i] = floats[i];
+            }
+        }
+    }
+}

NvAPIWrapper/Display/IntensityTexturePixel.cs

@@ -0,0 +1,117 @@
+using System;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a RGB intensity texture pixel
+    /// </summary>
+    public class IntensityTexturePixel : IEquatable<IntensityTexturePixel>
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="IntensityTexturePixel" />.
+        /// </summary>
+        /// <param name="redIntensity">The intensity of the red light (0-1)</param>
+        /// <param name="greenIntensity">The intensity of the green light (0-1)</param>
+        /// <param name="blueIntensity">The intensity of the blue light (0-1)</param>
+        public IntensityTexturePixel(float redIntensity, float greenIntensity, float blueIntensity)
+        {
+            RedIntensity = Math.Max(Math.Min(redIntensity, 1), 0);
+            GreenIntensity = Math.Max(Math.Min(greenIntensity, 1), 0);
+            BlueIntensity = Math.Max(Math.Min(blueIntensity, 1), 0);
+        }
+
+        /// <summary>
+        ///     Gets the intensity of the blue light (0-1)
+        /// </summary>
+        public float BlueIntensity { get; }
+
+        /// <summary>
+        ///     Gets the intensity of the green light (0-1)
+        /// </summary>
+        public float GreenIntensity { get; }
+
+        /// <summary>
+        ///     Gets the intensity of the red light (0-1)
+        /// </summary>
+        public float RedIntensity { get; }
+
+        /// <inheritdoc />
+        public bool Equals(IntensityTexturePixel other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Math.Abs(RedIntensity - other.RedIntensity) < 0.0001 &&
+                   Math.Abs(GreenIntensity - other.GreenIntensity) < 0.0001 &&
+                   Math.Abs(BlueIntensity - other.BlueIntensity) < 0.0001;
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="IntensityTexturePixel" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
+        public static bool operator ==(IntensityTexturePixel left, IntensityTexturePixel right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="IntensityTexturePixel" /> for in-equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
+        public static bool operator !=(IntensityTexturePixel left, IntensityTexturePixel right)
+        {
+            return !(left == right);
+        }
+
+        internal static IntensityTexturePixel FromFloatArray(float[] floats, int index)
+        {
+            return new IntensityTexturePixel(floats[index], floats[index + 1], floats[index + 2]);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as IntensityTexturePixel);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = RedIntensity.GetHashCode();
+                hashCode = (hashCode * 397) ^ GreenIntensity.GetHashCode();
+                hashCode = (hashCode * 397) ^ BlueIntensity.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        internal float[] ToFloatArray()
+        {
+            return new[] {RedIntensity, GreenIntensity, BlueIntensity};
+        }
+    }
+}

NvAPIWrapper/Display/PathInfo.cs

@@ -0,0 +1,288 @@
+using System;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a configuration path
+    /// </summary>
+    public class PathInfo : IEquatable<PathInfo>
+    {
+        /// <summary>
+        ///     Creates a new PathInfo
+        /// </summary>
+        /// <param name="resolution">Display resolution</param>
+        /// <param name="colorFormat">Display color format</param>
+        /// <param name="targetInfos">Target configuration informations</param>
+        public PathInfo(Resolution resolution, ColorFormat colorFormat, PathTargetInfo[] targetInfos)
+        {
+            Resolution = resolution;
+            ColorFormat = colorFormat;
+            TargetsInfo = targetInfos;
+        }
+
+        /// <summary>
+        ///     Creates a new PathInfo
+        /// </summary>
+        /// <param name="info">IPathInfo implamented object</param>
+        public PathInfo(IPathInfo info)
+        {
+            SourceId = info.SourceId;
+            Resolution = info.SourceModeInfo.Resolution;
+            ColorFormat = info.SourceModeInfo.ColorFormat;
+            Position = info.SourceModeInfo.Position;
+            SpanningOrientation = info.SourceModeInfo.SpanningOrientation;
+            IsGDIPrimary = info.SourceModeInfo.IsGDIPrimary;
+            IsSLIFocus = info.SourceModeInfo.IsSLIFocus;
+            TargetsInfo =
+                info.TargetsInfo.Select(targetInfo => new PathTargetInfo(targetInfo)).ToArray();
+
+            if (info is PathInfoV2)
+            {
+                OSAdapterLUID = ((PathInfoV2) info).OSAdapterLUID;
+            }
+        }
+
+        /// <summary>
+        ///     Gets or sets the display color format
+        /// </summary>
+        public ColorFormat ColorFormat { get; set; }
+
+        /// <summary>
+        ///     Gets or sets a boolean value indicating if the this is the primary GDI display
+        /// </summary>
+        public bool IsGDIPrimary { get; set; }
+
+        /// <summary>
+        ///     Gets or sets a boolean value indicating if the this is the SLI focus display
+        /// </summary>
+        public bool IsSLIFocus { get; set; }
+
+        /// <summary>
+        ///     Gets OS Adapter of LUID for Non-NVIDIA adapters
+        /// </summary>
+        public LUID? OSAdapterLUID { get; }
+
+        /// <summary>
+        ///     Gets or sets the display position
+        /// </summary>
+        public Position Position { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the display resolution
+        /// </summary>
+        public Resolution Resolution { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the Windows CCD display source identification. This can be optionally set.
+        /// </summary>
+        public uint SourceId { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the display spanning orientation, valid for XP only
+        /// </summary>
+        public SpanningOrientation SpanningOrientation { get; set; }
+
+
+        /// <summary>
+        ///     Gets information about path targets
+        /// </summary>
+        public PathTargetInfo[] TargetsInfo { get; }
+
+
+        /// <summary>
+        ///     Checks for equality with a PathInfo instance
+        /// </summary>
+        /// <param name="other">The PathInfo object to check with</param>
+        /// <returns>true if both objects are equal, otherwise false</returns>
+        public bool Equals(PathInfo other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Resolution.Equals(other.Resolution) &&
+                   ColorFormat == other.ColorFormat &&
+                   Position.Equals(other.Position) &&
+                   SpanningOrientation == other.SpanningOrientation &&
+                   IsGDIPrimary == other.IsGDIPrimary &&
+                   IsSLIFocus == other.IsSLIFocus &&
+                   TargetsInfo.SequenceEqual(other.TargetsInfo);
+        }
+
+
+        /// <summary>
+        ///     Creates and fills a PathInfo object
+        /// </summary>
+        /// <returns>The newly created PathInfo object</returns>
+        public static PathInfo[] GetDisplaysConfig()
+        {
+            var configs = DisplayApi.GetDisplayConfig();
+            var logicalDisplays = configs.Select(info => new PathInfo(info)).ToArray();
+            configs.DisposeAll();
+
+            return logicalDisplays;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(PathInfo left, PathInfo right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(PathInfo left, PathInfo right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        ///     Applies one or more path information configurations
+        /// </summary>
+        /// <param name="pathInfos">An array of path information configuration</param>
+        /// <param name="flags">DisplayConfigFlags flags</param>
+        public static void SetDisplaysConfig(PathInfo[] pathInfos, DisplayConfigFlags flags)
+        {
+            try
+            {
+                var configsV2 = pathInfos.Select(config => config.GetPathInfoV2()).Cast<IPathInfo>().ToArray();
+                DisplayApi.SetDisplayConfig(configsV2, flags);
+                configsV2.DisposeAll();
+            }
+            catch (NVIDIAApiException ex)
+            {
+                if (ex.Status != Status.IncompatibleStructureVersion)
+                {
+                    throw;
+                }
+            }
+            catch (NVIDIANotSupportedException)
+            {
+                // ignore
+            }
+
+            var configsV1 = pathInfos.Select(config => config.GetPathInfoV1()).Cast<IPathInfo>().ToArray();
+            DisplayApi.SetDisplayConfig(configsV1, flags);
+            configsV1.DisposeAll();
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((PathInfo) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Resolution.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) ColorFormat;
+                hashCode = (hashCode * 397) ^ Position.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) SpanningOrientation;
+                hashCode = (hashCode * 397) ^ IsGDIPrimary.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsSLIFocus.GetHashCode();
+                hashCode = (hashCode * 397) ^ (TargetsInfo?.GetHashCode() ?? 0);
+
+                return hashCode;
+            }
+        }
+
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{Resolution} @ {Position} [{TargetsInfo.Length}]";
+        }
+
+        /// <summary>
+        ///     Creates and fills a GetPathInfoV1 object
+        /// </summary>
+        /// <returns>The newly created GetPathInfoV1 object</returns>
+        public PathInfoV1 GetPathInfoV1()
+        {
+            var sourceModeInfo = GetSourceModeInfo();
+            var pathTargetInfoV1 = GetPathTargetInfoV1Array();
+
+            return new PathInfoV1(pathTargetInfoV1, sourceModeInfo, SourceId);
+        }
+
+        /// <summary>
+        ///     Creates and fills a GetPathInfoV2 object
+        /// </summary>
+        /// <returns>The newly created GetPathInfoV2 object</returns>
+        public PathInfoV2 GetPathInfoV2()
+        {
+            var sourceModeInfo = GetSourceModeInfo();
+            var pathTargetInfoV2 = GetPathTargetInfoV2Array();
+
+            return new PathInfoV2(pathTargetInfoV2, sourceModeInfo, SourceId);
+        }
+
+        /// <summary>
+        ///     Creates and fills an array of GetPathTargetInfoV1 object
+        /// </summary>
+        /// <returns>The newly created array of GetPathTargetInfoV1 objects</returns>
+        public PathTargetInfoV1[] GetPathTargetInfoV1Array()
+        {
+            return TargetsInfo.Select(config => config.GetPathTargetInfoV1()).ToArray();
+        }
+
+        /// <summary>
+        ///     Creates and fills an array of GetPathTargetInfoV2 object
+        /// </summary>
+        /// <returns>The newly created array of GetPathTargetInfoV2 objects</returns>
+        public PathTargetInfoV2[] GetPathTargetInfoV2Array()
+        {
+            return TargetsInfo.Select(config => config.GetPathTargetInfoV2()).ToArray();
+        }
+
+        /// <summary>
+        ///     Creates and fills a SourceModeInfo object
+        /// </summary>
+        /// <returns>The newly created SourceModeInfo object</returns>
+        public SourceModeInfo GetSourceModeInfo()
+        {
+            return new SourceModeInfo(Resolution, ColorFormat, Position, SpanningOrientation, IsGDIPrimary, IsSLIFocus);
+        }
+    }
+}

NvAPIWrapper/Display/PathTargetInfo.cs

@@ -0,0 +1,304 @@
+using System;
+using System.Collections.Generic;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.Display;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a display configuration on a path
+    /// </summary>
+    public class PathTargetInfo : IEquatable<PathTargetInfo>
+    {
+        private TimingOverride _timingOverride;
+
+        /// <summary>
+        ///     Creates a new PathTargetInfo
+        /// </summary>
+        /// <param name="info">IPathTargetInfo implamented object</param>
+        public PathTargetInfo(IPathTargetInfo info)
+        {
+            DisplayDevice = new DisplayDevice(info.DisplayId);
+
+            if (info.Details.HasValue)
+            {
+                Rotation = info.Details.Value.Rotation;
+                Scaling = info.Details.Value.Scaling;
+                TVConnectorType = info.Details.Value.ConnectorType;
+                TVFormat = info.Details.Value.TVFormat;
+                RefreshRateInMillihertz = info.Details.Value.RefreshRateInMillihertz;
+                TimingOverride = info.Details.Value.TimingOverride;
+                IsInterlaced = info.Details.Value.IsInterlaced;
+                IsClonePrimary = info.Details.Value.IsClonePrimary;
+                IsClonePanAndScanTarget = info.Details.Value.IsClonePanAndScanTarget;
+                DisableVirtualModeSupport = info.Details.Value.DisableVirtualModeSupport;
+                IsPreferredUnscaledTarget = info.Details.Value.IsPreferredUnscaledTarget;
+            }
+
+            if (info is PathTargetInfoV2)
+            {
+                WindowsCCDTargetId = ((PathTargetInfoV2) info).WindowsCCDTargetId;
+            }
+        }
+
+        /// <summary>
+        ///     Creates a new PathTargetInfo
+        /// </summary>
+        /// <param name="device">DisplayDevice object</param>
+        public PathTargetInfo(DisplayDevice device)
+        {
+            DisplayDevice = device;
+        }
+
+        /// <summary>
+        ///     Gets or sets the virtual mode support
+        /// </summary>
+        public bool DisableVirtualModeSupport { get; set; }
+
+        /// <summary>
+        ///     Gets corresponding DisplayDevice
+        /// </summary>
+        public DisplayDevice DisplayDevice { get; }
+
+        /// <summary>
+        ///     Gets or sets the pan and scan is availability. Valid only when the target is part of clone
+        ///     topology.
+        /// </summary>
+        public bool IsClonePanAndScanTarget { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the primary display in clone configuration. This is *NOT* GDI Primary.
+        ///     Only one target can be primary per source. If no primary is specified, the first target will automatically be
+        ///     primary.
+        /// </summary>
+        public bool IsClonePrimary { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the interlaced mode flag, ignored if refreshRate == 0
+        /// </summary>
+        public bool IsInterlaced { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the preferred unscaled mode of target
+        /// </summary>
+        public bool IsPreferredUnscaledTarget { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored
+        ///     This is the value which driver reports to the OS.
+        /// </summary>
+        public uint RefreshRateInMillihertz { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the rotation setting
+        /// </summary>
+        public Rotate Rotation { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the scaling setting
+        /// </summary>
+        public Scaling Scaling { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the custom timing of display
+        ///     Ignored if TimingOverride == TimingOverride.Current
+        /// </summary>
+        public TimingOverride TimingOverride
+        {
+            get => _timingOverride;
+            set
+            {
+                if (value == TimingOverride.Custom)
+                {
+                    throw new NVIDIANotSupportedException("Custom timing is not supported yet.");
+                }
+
+                _timingOverride = value;
+            }
+        }
+
+        /// <summary>
+        ///     Gets and sets the connector type. For TV only, ignored if TVFormat == TVFormat.None.
+        /// </summary>
+        public ConnectorType TVConnectorType { get; set; }
+
+        /// <summary>
+        ///     Gets and sets the TV format. For TV only, otherwise set to TVFormat.None
+        /// </summary>
+        public TVFormat TVFormat { get; set; }
+
+        /// <summary>
+        ///     Gets the Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is
+        ///     ignored.
+        /// </summary>
+        public uint WindowsCCDTargetId { get; }
+
+        /// <summary>
+        ///     Checks for equality with a PathTargetInfo instance
+        /// </summary>
+        /// <param name="other">The PathTargetInfo object to check with</param>
+        /// <returns>true if both objects are equal, otherwise false</returns>
+        public bool Equals(PathTargetInfo other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return _timingOverride == other._timingOverride &&
+                   Rotation == other.Rotation &&
+                   Scaling == other.Scaling &&
+                   RefreshRateInMillihertz == other.RefreshRateInMillihertz &&
+                   (TVFormat == TVFormat.None || TVConnectorType == other.TVConnectorType) &&
+                   TVFormat == other.TVFormat &&
+                   DisplayDevice.Equals(other.DisplayDevice) &&
+                   IsInterlaced == other.IsInterlaced &&
+                   IsClonePrimary == other.IsClonePrimary &&
+                   IsClonePanAndScanTarget == other.IsClonePanAndScanTarget &&
+                   DisableVirtualModeSupport == other.DisableVirtualModeSupport &&
+                   IsPreferredUnscaledTarget == other.IsPreferredUnscaledTarget;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(PathTargetInfo left, PathTargetInfo right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(PathTargetInfo left, PathTargetInfo right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((PathTargetInfo) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = (int) _timingOverride;
+                hashCode = (hashCode * 397) ^ (int) Rotation;
+                hashCode = (hashCode * 397) ^ (int) Scaling;
+                hashCode = (hashCode * 397) ^ (int) RefreshRateInMillihertz;
+                hashCode = (hashCode * 397) ^ (int) TVFormat;
+                hashCode = (hashCode * 397) ^ (TVFormat != TVFormat.None ? (int) TVConnectorType : 0);
+                hashCode = (hashCode * 397) ^ (DisplayDevice?.GetHashCode() ?? 0);
+                hashCode = (hashCode * 397) ^ IsInterlaced.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsClonePrimary.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsClonePanAndScanTarget.GetHashCode();
+                hashCode = (hashCode * 397) ^ DisableVirtualModeSupport.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsPreferredUnscaledTarget.GetHashCode();
+
+                return hashCode;
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var strs = new List<string>
+            {
+                DisplayDevice.ToString()
+            };
+
+            if (RefreshRateInMillihertz > 0)
+            {
+                strs.Add($"@ {RefreshRateInMillihertz / 1000}hz");
+            }
+
+            if (TVFormat != TVFormat.None)
+            {
+                strs.Add($"- TV {TVFormat}");
+            }
+
+            strs.Add(IsInterlaced ? "Interlaced" : "Progressive");
+
+            if (Rotation != Rotate.Degree0)
+            {
+                strs.Add($"- Rotation: {Rotation}");
+            }
+
+            return string.Join(" ", strs);
+        }
+
+
+        /// <summary>
+        ///     Creates and fills a PathAdvancedTargetInfo object
+        /// </summary>
+        /// <returns>The newly created PathAdvancedTargetInfo object</returns>
+        public PathAdvancedTargetInfo GetPathAdvancedTargetInfo()
+        {
+            if (TVFormat == TVFormat.None)
+            {
+                return new PathAdvancedTargetInfo(Rotation, Scaling, RefreshRateInMillihertz, TimingOverride,
+                    IsInterlaced, IsClonePrimary, IsClonePanAndScanTarget, DisableVirtualModeSupport,
+                    IsPreferredUnscaledTarget);
+            }
+
+            return new PathAdvancedTargetInfo(Rotation, Scaling, TVFormat, TVConnectorType, RefreshRateInMillihertz,
+                TimingOverride, IsInterlaced, IsClonePrimary, IsClonePanAndScanTarget, DisableVirtualModeSupport,
+                IsPreferredUnscaledTarget);
+        }
+
+        /// <summary>
+        ///     Creates and fills a PathTargetInfoV1 object
+        /// </summary>
+        /// <returns>The newly created PathTargetInfoV1 object</returns>
+        public PathTargetInfoV1 GetPathTargetInfoV1()
+        {
+            var pathAdvancedTargetInfo = GetPathAdvancedTargetInfo();
+
+            return new PathTargetInfoV1(DisplayDevice.DisplayId, pathAdvancedTargetInfo);
+        }
+
+        /// <summary>
+        ///     Creates and fills a PathTargetInfoV2 object
+        /// </summary>
+        /// <returns>The newly created PathTargetInfoV2 object</returns>
+        public PathTargetInfoV2 GetPathTargetInfoV2()
+        {
+            var pathAdvancedTargetInfo = GetPathAdvancedTargetInfo();
+
+            return new PathTargetInfoV2(DisplayDevice.DisplayId, WindowsCCDTargetId, pathAdvancedTargetInfo);
+        }
+    }
+}

NvAPIWrapper/Display/ScanOutInformation.cs

@@ -0,0 +1,217 @@
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.General.Structures;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Contains information regarding the scan-out buffer settings of a display device
+    /// </summary>
+    public class ScanOutInformation
+    {
+        internal ScanOutInformation(DisplayDevice displayDevice)
+        {
+            DisplayDevice = displayDevice;
+        }
+
+        /// <summary>
+        ///     Gets the clone importance assigned to the target if the target is a cloned view of the SourceDesktopRectangle
+        ///     (0:primary,1 secondary,...).
+        /// </summary>
+        public uint CloneImportance
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).CloneImportance;
+        }
+
+        /// <summary>
+        ///     Gets the display device that this instance describes
+        /// </summary>
+        public DisplayDevice DisplayDevice { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if the display device scan out output is warped
+        /// </summary>
+        public bool IsDisplayWarped
+        {
+            get => DisplayApi.GetScanOutWarpingState(DisplayDevice.DisplayId).IsEnabled;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if the display device intensity is modified
+        /// </summary>
+        public bool IsIntensityModified
+        {
+            get => DisplayApi.GetScanOutIntensityState(DisplayDevice.DisplayId).IsEnabled;
+        }
+
+        /// <summary>
+        ///     Gets the operating system display device rectangle in desktop coordinates displayId is scanning out from.
+        /// </summary>
+        public Rectangle SourceDesktopRectangle
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceDesktopRectangle;
+        }
+
+        /// <summary>
+        ///     Gets the rotation performed between the SourceViewPortRectangle and the TargetViewPortRectangle.
+        /// </summary>
+        public Rotate SourceToTargetRotation
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceToTargetRotation;
+        }
+
+        /// <summary>
+        ///     Gets the area inside the SourceDesktopRectangle which is scanned out to the display.
+        /// </summary>
+        public Rectangle SourceViewPortRectangle
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceViewPortRectangle;
+        }
+
+        /// <summary>
+        ///     Gets the vertical size of the active resolution scanned out to the display.
+        /// </summary>
+        public uint TargetDisplayHeight
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetDisplayHeight;
+        }
+
+        /// <summary>
+        ///     Gets the horizontal size of the active resolution scanned out to the display.
+        /// </summary>
+        public uint TargetDisplayWidth
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetDisplayWidth;
+        }
+
+        /// <summary>
+        ///     Gets the area inside the rectangle described by targetDisplayWidth/Height SourceViewPortRectangle is scanned out
+        ///     to.
+        /// </summary>
+        public Rectangle TargetViewPortRectangle
+        {
+            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetViewPortRectangle;
+        }
+
+        /// <summary>
+        ///     Disables the intensity modification on the display device scan-out buffer.
+        /// </summary>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        public void DisableIntensityModifications(out bool isSticky)
+        {
+            DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, null, out isSticky);
+        }
+
+        /// <summary>
+        ///     Disables the warping of display device scan-out buffer.
+        /// </summary>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        public void DisableWarping(out bool isSticky)
+        {
+            var vorticesCount = 0;
+            DisplayApi.SetScanOutWarping(DisplayDevice.DisplayId, null, ref vorticesCount, out isSticky);
+        }
+
+        /// <summary>
+        ///     Enables the intensity modification on the display device scan-out buffer.
+        /// </summary>
+        /// <param name="intensityTexture">The intensity texture to apply to the scan-out buffer.</param>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        public void EnableIntensityModifications(IntensityTexture intensityTexture, out bool isSticky)
+        {
+            using (
+                var intensity = new ScanOutIntensityV1(
+                    (uint) intensityTexture.Width,
+                    (uint) intensityTexture.Height,
+                    intensityTexture.ToFloatArray()
+                )
+            )
+            {
+                DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, intensity, out isSticky);
+            }
+        }
+
+        /// <summary>
+        ///     Enables the intensity modification on the display device scan-out buffer.
+        /// </summary>
+        /// <param name="intensityTexture">The intensity texture to apply to the scan-out buffer.</param>
+        /// <param name="offsetTexture">The offset texture to apply to the scan-out buffer.</param>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        public void EnableIntensityModifications(
+            IntensityTexture intensityTexture,
+            FloatTexture offsetTexture,
+            out bool isSticky)
+        {
+            using (
+                var intensity = new ScanOutIntensityV2(
+                    (uint) intensityTexture.Width,
+                    (uint) intensityTexture.Height,
+                    intensityTexture.ToFloatArray(),
+                    (uint) offsetTexture.Channels,
+                    offsetTexture.ToFloatArray()
+                )
+            )
+            {
+                DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, intensity, out isSticky);
+            }
+        }
+
+        /// <summary>
+        ///     Enables the warping of display device scan-out buffer
+        /// </summary>
+        /// <param name="warpingVerticeFormat">The type of warping vortexes.</param>
+        /// <param name="vortices">An array of warping vortexes.</param>
+        /// <param name="textureRectangle">The rectangle in desktop coordinates describing the source area for the warping.</param>
+        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
+        // ReSharper disable once TooManyArguments
+        public void EnableWarping(
+            WarpingVerticeFormat warpingVerticeFormat,
+            XYUVRQVortex[] vortices,
+            Rectangle textureRectangle,
+            out bool isSticky)
+        {
+            using (
+                var warping = new ScanOutWarpingV1(
+                    warpingVerticeFormat,
+                    vortices.SelectMany(vortex => vortex.AsFloatArray()).ToArray(),
+                    textureRectangle
+                )
+            )
+            {
+                var vorticesCount = vortices.Length;
+                DisplayApi.SetScanOutWarping(DisplayDevice.DisplayId, warping, ref vorticesCount, out isSticky);
+            }
+        }
+
+        /// <summary>
+        ///     Queries the current state of one of the various scan-out composition parameters.
+        /// </summary>
+        /// <param name="parameter">The scan-out composition parameter.</param>
+        /// <param name="additionalValue">The additional value included with the parameter value.</param>
+        /// <returns>The scan-out composition parameter value.</returns>
+        public ScanOutCompositionParameterValue GetCompositionParameterValue(
+            ScanOutCompositionParameter parameter,
+            out float additionalValue)
+        {
+            return DisplayApi.GetScanOutCompositionParameter(DisplayDevice.DisplayId, parameter, out additionalValue);
+        }
+
+
+        /// <summary>
+        ///     Sets the current state of one of the various scan-out composition parameters.
+        /// </summary>
+        /// <param name="parameter">The scan-out composition parameter.</param>
+        /// <param name="parameterValue">The scan-out composition parameter value.</param>
+        /// <param name="additionalValue">The additional value included with the parameter value.</param>
+        public void SetCompositionParameterValue(
+            ScanOutCompositionParameter parameter,
+            ScanOutCompositionParameterValue parameterValue,
+            float additionalValue)
+        {
+            DisplayApi.SetScanOutCompositionParameter(DisplayDevice.DisplayId, parameter, parameterValue,
+                ref additionalValue);
+        }
+    }
+}

NvAPIWrapper/Display/UnAttachedDisplay.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Linq;
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Display.Structures;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents an unattached display
+    /// </summary>
+    public class UnAttachedDisplay : IEquatable<UnAttachedDisplay>
+    {
+        /// <summary>
+        ///     Creates a new UnAttachedDisplay
+        /// </summary>
+        /// <param name="handle">Handle of the unattached display device</param>
+        public UnAttachedDisplay(UnAttachedDisplayHandle handle)
+        {
+            Handle = handle;
+        }
+
+        /// <summary>
+        ///     Creates a new UnAttachedDisplay
+        /// </summary>
+        /// <param name="displayName">Name of the unattached display device</param>
+        public UnAttachedDisplay(string displayName)
+        {
+            Handle = DisplayApi.GetAssociatedUnAttachedNvidiaDisplayHandle(displayName);
+        }
+
+        /// <summary>
+        ///     Gets display handle
+        /// </summary>
+        public UnAttachedDisplayHandle Handle { get; }
+
+        /// <summary>
+        ///     Gets display name
+        /// </summary>
+        public string Name
+        {
+            get => DisplayApi.GetUnAttachedAssociatedDisplayName(Handle);
+        }
+
+        /// <summary>
+        ///     Gets corresponding physical GPU
+        /// </summary>
+        public PhysicalGPU PhysicalGPU
+        {
+            get => new PhysicalGPU(GPUApi.GetPhysicalGPUFromUnAttachedDisplay(Handle));
+        }
+
+        /// <summary>
+        ///     Checks for equality with a UnAttachedDisplay instance
+        /// </summary>
+        /// <param name="other">The Display object to check with</param>
+        /// <returns>true if both objects are equal, otherwise false</returns>
+        public bool Equals(UnAttachedDisplay other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Handle.Equals(other.Handle);
+        }
+
+        /// <summary>
+        ///     This function returns all unattached NVIDIA displays
+        ///     Note: Display handles can get invalidated on a modeset.
+        /// </summary>
+        /// <returns>An array of Display objects</returns>
+        public static UnAttachedDisplay[] GetUnAttachedDisplays()
+        {
+            return
+                DisplayApi.EnumNvidiaUnAttachedDisplayHandle().Select(handle => new UnAttachedDisplay(handle))
+                    .ToArray();
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(UnAttachedDisplay left, UnAttachedDisplay right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(UnAttachedDisplay left, UnAttachedDisplay right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((UnAttachedDisplay) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Handle.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return Name;
+        }
+
+        /// <summary>
+        ///     Creates a new active attached display from this unattached display
+        ///     At least one GPU must be present in the system and running an NVIDIA display driver.
+        /// </summary>
+        /// <returns>An active attached display</returns>
+        public Display CreateDisplay()
+        {
+            return new Display(DisplayApi.CreateDisplayFromUnAttachedDisplay(Handle));
+        }
+    }
+}

NvAPIWrapper/Display/XYUVRQVortex.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+
+namespace NvAPIWrapper.Display
+{
+    /// <summary>
+    ///     Represents a XYUVRQ scan-out warping vortex
+    /// </summary>
+    public class XYUVRQVortex : IEquatable<XYUVRQVortex>
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="XYUVRQVortex" />.
+        /// </summary>
+        /// <param name="x">The target view port mesh horizontal coordinate</param>
+        /// <param name="y">The target view port mesh vertical coordinate</param>
+        /// <param name="u">The desktop view port texture horizontal coordinate</param>
+        /// <param name="v">The desktop view port texture vertical coordinate</param>
+        /// <param name="r">The 3D warp perspective R factor</param>
+        /// <param name="q">The 3D warp perspective Q factor</param>
+        // ReSharper disable once TooManyDependencies
+        public XYUVRQVortex(int x, int y, int u, int v, float r, float q)
+        {
+            X = x;
+            Y = y;
+            U = u;
+            V = v;
+            R = r;
+            Q = q;
+        }
+
+        /// <summary>
+        ///     3D warp perspective Q factor
+        /// </summary>
+        public float Q { get; }
+
+        /// <summary>
+        ///     3D warp perspective R factor
+        /// </summary>
+        public float R { get; }
+
+        /// <summary>
+        ///     Desktop view port texture horizontal coordinate
+        /// </summary>
+        public int U { get; }
+
+        /// <summary>
+        ///     Desktop view port texture vertical coordinate
+        /// </summary>
+        public int V { get; }
+
+        /// <summary>
+        ///     Target view port mesh horizontal coordinate
+        /// </summary>
+        public int X { get; }
+
+        /// <summary>
+        ///     Target view port mesh vertical coordinate
+        /// </summary>
+        public int Y { get; }
+
+        /// <inheritdoc />
+        public bool Equals(XYUVRQVortex other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Math.Abs(Q - other.Q) < 0.0001 &&
+                   Math.Abs(R - other.R) < 0.0001 &&
+                   U == other.U &&
+                   V == other.V &&
+                   X == other.X &&
+                   Y == other.Y;
+        }
+
+        /// <summary>
+        ///     Parses an array of floats and returns the corresponding <see cref="XYUVRQVortex" />s.
+        /// </summary>
+        /// <param name="floats">The array of float representing one or more <see cref="XYUVRQVortex" />s.</param>
+        /// <returns>Instances of <see cref="XYUVRQVortex" />.</returns>
+        public static IEnumerable<XYUVRQVortex> FromFloatArray(float[] floats)
+        {
+            for (var i = 0; i + 6 <= floats.Length; i += 6)
+            {
+                yield return new XYUVRQVortex(
+                    (int) floats[i],
+                    (int) floats[i + 1],
+                    (int) floats[i + 2],
+                    (int) floats[i + 3],
+                    floats[i + 4],
+                    floats[i + 5]
+                );
+            }
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="XYUVRQVortex" /> for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
+        public static bool operator ==(XYUVRQVortex left, XYUVRQVortex right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Compares two instance of <see cref="XYUVRQVortex" /> for in-equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
+        public static bool operator !=(XYUVRQVortex left, XYUVRQVortex right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as XYUVRQVortex);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Q.GetHashCode();
+                hashCode = (hashCode * 397) ^ R.GetHashCode();
+                hashCode = (hashCode * 397) ^ U;
+                hashCode = (hashCode * 397) ^ V;
+                hashCode = (hashCode * 397) ^ X;
+                hashCode = (hashCode * 397) ^ Y;
+
+                return hashCode;
+            }
+        }
+
+        /// <summary>
+        /// Returns this instance of <see cref="XYUVRQVortex"/> as a float array.
+        /// </summary>
+        /// <returns>An array of float values representing this instance of <see cref="XYUVRQVortex"/>.</returns>
+        public float[] AsFloatArray()
+        {
+            return new[] {X, Y, U, V, R, Q};
+        }
+    }
+}

NvAPIWrapper/GPU/AGPInformation.cs

@@ -0,0 +1,30 @@
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the accelerated graphics connection
+    /// </summary>
+    public class AGPInformation
+    {
+        internal AGPInformation(int aperture, int currentRate)
+        {
+            ApertureInMB = aperture;
+            CurrentRate = currentRate;
+        }
+
+        /// <summary>
+        ///     Gets AGP aperture in megabytes
+        /// </summary>
+        public int ApertureInMB { get; }
+
+        /// <summary>
+        ///     Gets current AGP Rate (0 = AGP not present, 1 = 1x, 2 = 2x, etc.)
+        /// </summary>
+        public int CurrentRate { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"AGP Aperture: {ApertureInMB}MB, Current Rate: {CurrentRate}x";
+        }
+    }
+}

NvAPIWrapper/GPU/ECCMemoryInformation.cs

@@ -0,0 +1,201 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the ECC memory
+    /// </summary>
+    public class ECCMemoryInformation
+    {
+        internal ECCMemoryInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the number of aggregated ECC memory double bit errors
+        /// </summary>
+        public ulong AggregatedDoubleBitErrors
+        {
+            get
+            {
+                if (!IsSupported || !IsEnabled)
+                {
+                    return 0;
+                }
+
+                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).AggregatedErrors.DoubleBitErrors;
+            }
+        }
+
+
+        /// <summary>
+        ///     Gets the number of aggregated ECC memory single bit errors
+        /// </summary>
+        public ulong AggregatedSingleBitErrors
+        {
+            get
+            {
+                if (!IsSupported || !IsEnabled)
+                {
+                    return 0;
+                }
+
+                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).AggregatedErrors.SingleBitErrors;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the ECC memory configuration in regard to how changes are applied
+        /// </summary>
+        public ECCConfiguration Configuration
+        {
+            get
+            {
+                try
+                {
+                    return GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).ConfigurationOptions;
+                }
+                catch
+                {
+                    return ECCConfiguration.NotSupported;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the number of current ECC memory double bit errors
+        /// </summary>
+        public ulong CurrentDoubleBitErrors
+        {
+            get
+            {
+                if (!IsSupported || !IsEnabled)
+                {
+                    return 0;
+                }
+
+                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).CurrentErrors.DoubleBitErrors;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the number of current ECC memory single bit errors
+        /// </summary>
+        public ulong CurrentSingleBitErrors
+        {
+            get
+            {
+                if (!IsSupported || !IsEnabled)
+                {
+                    return 0;
+                }
+
+                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).CurrentErrors.SingleBitErrors;
+            }
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if ECC memory error correction is enabled
+        /// </summary>
+
+        public bool IsEnabled
+        {
+            get => IsSupported &&
+                   GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).IsEnabled &&
+                   GPUApi.GetECCConfigurationInfo(PhysicalGPU.Handle).IsEnabled;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if ECC memory is enabled by default
+        /// </summary>
+        public bool IsEnabledByDefault
+        {
+            get => IsSupported &&
+                   GPUApi.GetECCConfigurationInfo(PhysicalGPU.Handle).IsEnabledByDefault;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if ECC memory is supported and available
+        /// </summary>
+        public bool IsSupported
+        {
+            get
+            {
+                try
+                {
+                    return GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).IsSupported;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            if (!IsSupported)
+            {
+                return "[Not Supported]";
+            }
+
+            if (!IsEnabled)
+            {
+                return "[Disabled]";
+            }
+
+            return
+                $"{CurrentSingleBitErrors}, {CurrentDoubleBitErrors} ({AggregatedSingleBitErrors}, {AggregatedDoubleBitErrors})";
+        }
+
+        /// <summary>
+        ///     Clears aggregated error counters.
+        /// </summary>
+        public void ClearAggregatedErrors()
+        {
+            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, false, true);
+        }
+
+        /// <summary>
+        ///     Clears current error counters.
+        /// </summary>
+        public void ClearCurrentErrors()
+        {
+            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, true, false);
+        }
+
+        /// <summary>
+        ///     Clears all error counters.
+        /// </summary>
+        public void ClearErrors()
+        {
+            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, true, true);
+        }
+
+        /// <summary>
+        ///     Disables ECC memory error correction.
+        /// </summary>
+        /// <param name="immediate">A boolean value to indicate if this change should get applied immediately</param>
+        public void Disable(bool immediate)
+        {
+            GPUApi.SetECCConfiguration(PhysicalGPU.Handle, false, immediate);
+        }
+
+        /// <summary>
+        ///     Enables ECC memory error correction.
+        /// </summary>
+        /// <param name="immediate">A boolean value to indicate if this change should get applied immediately</param>
+        public void Enable(bool immediate)
+        {
+            GPUApi.SetECCConfiguration(PhysicalGPU.Handle, true, immediate);
+        }
+    }
+}

NvAPIWrapper/GPU/GPUArchitectInformation.cs

@@ -0,0 +1,115 @@
+using NvAPIWrapper.Native;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains physical GPU architect information
+    /// </summary>
+    public class GPUArchitectInformation
+    {
+        internal GPUArchitectInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets total number of cores defined for this GPU, or zero for older architectures
+        /// </summary>
+        public int NumberOfCores
+        {
+            get => (int) GPUApi.GetGPUCoreCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of graphics processing clusters (aka GPU Partitions)
+        /// </summary>
+        public int NumberOfGPC
+        {
+            get => (int) GPUApi.GetPartitionCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of render output units
+        /// </summary>
+        public int NumberOfROPs
+        {
+            get => (int) GPUApi.GetROPCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of shader pipelines
+        /// </summary>
+        public int NumberOfShaderPipelines
+        {
+            get => (int) GPUApi.GetShaderPipeCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of shader sub pipelines
+        /// </summary>
+        public int NumberOfShaderSubPipelines
+        {
+            get => (int) GPUApi.GetShaderSubPipeCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the number of video processing engines
+        /// </summary>
+        public int NumberOfVPEs
+        {
+            get => (int) GPUApi.GetVPECount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets the GPU revision number (should be displayed as a hex string)
+        /// </summary>
+        public int Revision
+        {
+            get => (int) GPUApi.GetArchitectInfo(PhysicalGPU.Handle).Revision;
+        }
+
+        /// <summary>
+        ///     Gets the GPU short name (aka Codename)
+        /// </summary>
+        public string ShortName
+        {
+            get => GPUApi.GetShortName(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the total number of streaming multiprocessors
+        /// </summary>
+        public int TotalNumberOfSMs
+        {
+            get => (int) GPUApi.GetTotalSMCount(PhysicalGPU.Handle);
+        }
+
+
+        /// <summary>
+        ///     Gets the total number of streaming processors
+        /// </summary>
+        public int TotalNumberOfSPs
+        {
+            get => (int) GPUApi.GetTotalSPCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the total number of texture processing clusters
+        /// </summary>
+        public int TotalNumberOfTPCs
+        {
+            get => (int) GPUApi.GetTotalTPCCount(PhysicalGPU.Handle);
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{ShortName} REV{Revision:X}] Cores: {NumberOfCores}";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUBusInformation.cs

@@ -0,0 +1,118 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the GPU bus
+    /// </summary>
+    public class GPUBusInformation
+    {
+        internal GPUBusInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets accelerated graphics port information
+        /// </summary>
+        public AGPInformation AGPInformation
+        {
+            get
+            {
+                if (BusType != GPUBusType.AGP)
+                {
+                    return null;
+                }
+
+                return new AGPInformation(
+                    GPUApi.GetAGPAperture(PhysicalGPU.Handle),
+                    GPUApi.GetCurrentAGPRate(PhysicalGPU.Handle)
+                );
+            }
+        }
+
+        /// <summary>
+        ///     Gets the bus identification
+        /// </summary>
+        public int BusId
+        {
+            get => GPUApi.GetBusId(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the bus slot identification
+        /// </summary>
+        public int BusSlot
+        {
+            get => GPUApi.GetBusSlotId(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the the bus type
+        /// </summary>
+        public GPUBusType BusType
+        {
+            get => GPUApi.GetBusType(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets number of PCIe lanes being used for the PCIe interface downstream
+        /// </summary>
+        public int CurrentPCIeLanes
+        {
+            get
+            {
+                if (BusType == GPUBusType.PCIExpress)
+                {
+                    return GPUApi.GetCurrentPCIEDownStreamWidth(PhysicalGPU.Handle);
+                }
+
+                return 0;
+            }
+        }
+
+        /// <summary>
+        ///     Gets GPU interrupt number
+        /// </summary>
+        public int IRQ
+        {
+            get => GPUApi.GetIRQ(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the PCI identifiers
+        /// </summary>
+        public PCIIdentifiers PCIIdentifiers
+        {
+            get
+            {
+                if (BusType == GPUBusType.FPCI || BusType == GPUBusType.PCI || BusType == GPUBusType.PCIExpress)
+                {
+                    GPUApi.GetPCIIdentifiers(
+                        PhysicalGPU.Handle,
+                        out var deviceId,
+                        out var subSystemId,
+                        out var revisionId,
+                        out var extDeviceId
+                    );
+
+                    return new PCIIdentifiers(deviceId, subSystemId, revisionId, (int) extDeviceId);
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{BusType}] Bus #{BusId}, Slot #{BusSlot}";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUCooler.cs

@@ -0,0 +1,130 @@
+using System;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a GPU cooler entry
+    /// </summary>
+    public class GPUCooler
+    {
+        internal GPUCooler(int coolerId, PrivateCoolerSettingsV1.CoolerSetting coolerSetting, int currentRPM = -1)
+        {
+            CoolerId = coolerId;
+            CurrentLevel = (int) coolerSetting.CurrentLevel;
+            DefaultMinimumLevel = (int) coolerSetting.DefaultMinimumLevel;
+            DefaultMaximumLevel = (int) coolerSetting.DefaultMaximumLevel;
+            CurrentMinimumLevel = (int) coolerSetting.CurrentMinimumLevel;
+            CurrentMaximumLevel = (int) coolerSetting.CurrentMaximumLevel;
+            CoolerType = coolerSetting.CoolerType;
+            CoolerController = coolerSetting.CoolerController;
+            DefaultPolicy = coolerSetting.DefaultPolicy;
+            CurrentPolicy = coolerSetting.CurrentPolicy;
+            Target = coolerSetting.Target;
+            ControlMode = coolerSetting.ControlMode;
+            CurrentFanSpeedInRPM = currentRPM;
+        }
+
+        // ReSharper disable once TooManyDependencies
+        internal GPUCooler(
+            PrivateFanCoolersInfoV1.FanCoolersInfoEntry infoEntry,
+            PrivateFanCoolersStatusV1.FanCoolersStatusEntry statusEntry,
+            PrivateFanCoolersControlV1.FanCoolersControlEntry controlEntry)
+        {
+            if (infoEntry.CoolerId != statusEntry.CoolerId || statusEntry.CoolerId != controlEntry.CoolerId)
+            {
+                throw new ArgumentException("Passed arguments are meant to be for different coolers.");
+            }
+
+            CoolerId = (int) statusEntry.CoolerId;
+            CurrentLevel = (int) statusEntry.CurrentLevel;
+            DefaultMinimumLevel = (int) statusEntry.CurrentMinimumLevel;
+            DefaultMaximumLevel = (int) statusEntry.CurrentMaximumLevel;
+            CurrentMinimumLevel = (int) statusEntry.CurrentMinimumLevel;
+            CurrentMaximumLevel = (int) statusEntry.CurrentMaximumLevel;
+            CoolerType = CoolerType.Fan;
+            CoolerController = CoolerController.Internal;
+            DefaultPolicy = CoolerPolicy.None;
+            CurrentPolicy = controlEntry.ControlMode == FanCoolersControlMode.Manual
+                ? CoolerPolicy.Manual
+                : CoolerPolicy.None;
+            Target = CoolerTarget.All;
+            ControlMode = CoolerControlMode.Variable;
+            CurrentFanSpeedInRPM = (int) statusEntry.CurrentRPM;
+        }
+
+        /// <summary>
+        ///     Gets the cooler control mode
+        /// </summary>
+        public CoolerControlMode ControlMode { get; }
+
+        /// <summary>
+        ///     Gets the cooler controller
+        /// </summary>
+        public CoolerController CoolerController { get; }
+
+        /// <summary>
+        ///     Gets the cooler identification number or index
+        /// </summary>
+        public int CoolerId { get; }
+
+        /// <summary>
+        ///     Gets the cooler type
+        /// </summary>
+        public CoolerType CoolerType { get; }
+
+        /// <summary>
+        ///     Gets the GPU fan speed in revolutions per minute
+        /// </summary>
+        public int CurrentFanSpeedInRPM { get; }
+
+        /// <summary>
+        ///     Gets the cooler current level in percentage
+        /// </summary>
+        public int CurrentLevel { get; }
+
+
+        /// <summary>
+        ///     Gets the cooler current maximum level in percentage
+        /// </summary>
+        public int CurrentMaximumLevel { get; }
+
+
+        /// <summary>
+        ///     Gets the cooler current minimum level in percentage
+        /// </summary>
+        public int CurrentMinimumLevel { get; }
+
+        /// <summary>
+        ///     Gets the cooler current policy
+        /// </summary>
+        public CoolerPolicy CurrentPolicy { get; }
+
+        /// <summary>
+        ///     Gets the cooler default maximum level in percentage
+        /// </summary>
+        public int DefaultMaximumLevel { get; }
+
+        /// <summary>
+        ///     Gets the cooler default minimum level in percentage
+        /// </summary>
+        public int DefaultMinimumLevel { get; }
+
+        /// <summary>
+        ///     Gets the cooler default policy
+        /// </summary>
+        public CoolerPolicy DefaultPolicy { get; }
+
+        /// <summary>
+        ///     Gets the cooler target
+        /// </summary>
+        public CoolerTarget Target { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{CoolerId} @ {CoolerController}] {Target}: {CurrentLevel}%";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUCoolerInformation.cs

@@ -0,0 +1,340 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the GPU coolers and current fan speed
+    /// </summary>
+    public class GPUCoolerInformation
+    {
+        internal GPUCoolerInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+
+            // TODO: Add Support For Pascal Only Policy Table Method
+            // TODO: GPUApi.GetCoolerPolicyTable & GPUApi.SetCoolerPolicyTable & GPUApi.RestoreCoolerPolicyTable
+            // TODO: Better support of ClientFanCoolers set of APIs
+        }
+
+        /// <summary>
+        ///     Gets a list of all available coolers along with their current settings and status
+        /// </summary>
+        public IEnumerable<GPUCooler> Coolers
+        {
+            get
+            {
+                PrivateCoolerSettingsV1? settings = null;
+
+                try
+                {
+                    settings = GPUApi.GetCoolerSettings(PhysicalGPU.Handle);
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status != Status.NotSupported)
+                    {
+                        throw;
+                    }
+                }
+
+                if (settings != null)
+                {
+                    for (var i = 0; i < settings.Value.CoolerSettings.Length; i++)
+                    {
+                        if (i == 0)
+                        {
+                            var currentRPM = -1;
+                            try
+                            {
+                                currentRPM = (int)GPUApi.GetTachReading(PhysicalGPU.Handle);
+                            }
+                            catch (NVIDIAApiException)
+                            {
+                                // ignored
+                            }
+
+                            if (currentRPM >= 0)
+                            {
+                                yield return new GPUCooler(
+                                    i,
+                                    settings.Value.CoolerSettings[i],
+                                    currentRPM
+                                );
+                                continue;
+                            }
+                        }
+
+                        yield return new GPUCooler(
+                            i,
+                            settings.Value.CoolerSettings[i]
+                        );
+                    }
+
+                    yield break;
+                }
+
+                PrivateFanCoolersStatusV1? status = null;
+                PrivateFanCoolersInfoV1? info = null;
+                PrivateFanCoolersControlV1? control = null;
+
+                try
+                {
+                    status = GPUApi.GetClientFanCoolersStatus(PhysicalGPU.Handle);
+                    info = GPUApi.GetClientFanCoolersInfo(PhysicalGPU.Handle);
+                    control = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
+                }
+                catch (NVIDIAApiException e)
+                {
+                    if (e.Status != Status.NotSupported)
+                    {
+                        throw;
+                    }
+                }
+
+                if (status != null && info != null && control != null)
+                {
+                    for (var i = 0; i < status.Value.FanCoolersStatusEntries.Length; i++)
+                    {
+                        if (info.Value.FanCoolersInfoEntries.Length > i &&
+                            control.Value.FanCoolersControlEntries.Length > i)
+                        {
+                            yield return new GPUCooler(
+                                info.Value.FanCoolersInfoEntries[i],
+                                status.Value.FanCoolersStatusEntries[i],
+                                control.Value.FanCoolersControlEntries[i]
+                            );
+                        }
+                    }
+
+                    yield break;
+                }
+
+                throw new NVIDIAApiException(Status.NotSupported);
+            }
+        }
+
+        /// <summary>
+        ///     Gets the GPU fan speed in revolutions per minute
+        /// </summary>
+        public int CurrentFanSpeedInRPM
+        {
+            get
+            {
+                try
+                {
+                    return (int) GPUApi.GetTachReading(PhysicalGPU.Handle);
+                }
+                catch
+                {
+                    return Coolers.FirstOrDefault(cooler => cooler.Target == CoolerTarget.All)?.CurrentFanSpeedInRPM ??
+                           0;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the current fan speed in percentage if available
+        /// </summary>
+        public int CurrentFanSpeedLevel
+        {
+            get
+            {
+                try
+                {
+                    return (int) GPUApi.GetCurrentFanSpeedLevel(PhysicalGPU.Handle);
+                }
+                catch
+                {
+                    return Coolers.FirstOrDefault(cooler => cooler.Target == CoolerTarget.All)?.CurrentLevel ?? 0;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{CurrentFanSpeedInRPM} RPM ({CurrentFanSpeedLevel}%)";
+        }
+
+        /// <summary>
+        ///     Resets all cooler settings to default.
+        /// </summary>
+        public void RestoreCoolerSettingsToDefault()
+        {
+            RestoreCoolerSettingsToDefault(Coolers.Select(cooler => cooler.CoolerId).ToArray());
+        }
+
+        /// <summary>
+        ///     Resets one or more cooler settings to default.
+        /// </summary>
+        /// <param name="coolerIds">The cooler identification numbers (indexes) to reset their settings to default.</param>
+        public void RestoreCoolerSettingsToDefault(params int[] coolerIds)
+        {
+            var availableCoolerIds = Coolers.Select(cooler => cooler.CoolerId).ToArray();
+
+            if (coolerIds.Any(i => !availableCoolerIds.Contains(i)))
+            {
+                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerIds));
+            }
+
+            try
+            {
+                GPUApi.RestoreCoolerSettings(PhysicalGPU.Handle, coolerIds.Select(i => (uint) i).ToArray());
+
+                return;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.NotSupported)
+                {
+                    throw;
+                }
+            }
+
+            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
+            var newControl = new PrivateFanCoolersControlV1(
+                currentControl.FanCoolersControlEntries.Select(
+                        entry => coolerIds.Contains((int) entry.CoolerId)
+                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
+                                entry.CoolerId,
+                                FanCoolersControlMode.Auto
+                            )
+                            : entry
+                    )
+                    .ToArray(),
+                currentControl.UnknownUInt
+            );
+            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
+        }
+
+        /// <summary>
+        ///     Changes a cooler settings by modifying the policy and the current level
+        /// </summary>
+        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
+        /// <param name="policy">The new cooler policy.</param>
+        /// <param name="newLevel">The new cooler level. Valid only if policy is set to manual.</param>
+        // ReSharper disable once TooManyDeclarations
+        public void SetCoolerSettings(int coolerId, CoolerPolicy policy, int newLevel)
+        {
+            if (Coolers.All(cooler => cooler.CoolerId != coolerId))
+            {
+                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerId));
+            }
+
+            try
+            {
+                GPUApi.SetCoolerLevels(
+                    PhysicalGPU.Handle,
+                    (uint) coolerId,
+                    new PrivateCoolerLevelsV1(new[]
+                        {
+                            new PrivateCoolerLevelsV1.CoolerLevel(policy, (uint) newLevel)
+                        }
+                    ),
+                    1
+                );
+
+                return;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.NotSupported)
+                {
+                    throw;
+                }
+            }
+
+            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
+            var newControl = new PrivateFanCoolersControlV1(
+                currentControl.FanCoolersControlEntries.Select(
+                        entry => entry.CoolerId == coolerId
+                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
+                                entry.CoolerId,
+                                policy == CoolerPolicy.Manual
+                                    ? FanCoolersControlMode.Manual
+                                    : FanCoolersControlMode.Auto,
+                                policy == CoolerPolicy.Manual ? (uint)newLevel : 0u)
+                            : entry
+                    )
+                    .ToArray(),
+                currentControl.UnknownUInt
+            );
+            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
+        }
+
+        /// <summary>
+        ///     Changes a cooler setting by modifying the policy
+        /// </summary>
+        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
+        /// <param name="policy">The new cooler policy.</param>
+        // ReSharper disable once TooManyDeclarations
+        public void SetCoolerSettings(int coolerId, CoolerPolicy policy)
+        {
+            if (Coolers.All(cooler => cooler.CoolerId != coolerId))
+            {
+                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerId));
+            }
+
+            try
+            {
+                GPUApi.SetCoolerLevels(
+                    PhysicalGPU.Handle,
+                    (uint) coolerId,
+                    new PrivateCoolerLevelsV1(new[]
+                        {
+                            new PrivateCoolerLevelsV1.CoolerLevel(policy)
+                        }
+                    ),
+                    1
+                );
+
+                return;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.NotSupported)
+                {
+                    throw;
+                }
+            }
+
+            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
+            var newControl = new PrivateFanCoolersControlV1(
+                currentControl.FanCoolersControlEntries.Select(
+                        entry => entry.CoolerId == coolerId
+                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
+                                entry.CoolerId,
+                                policy == CoolerPolicy.Manual
+                                    ? FanCoolersControlMode.Manual
+                                    : FanCoolersControlMode.Auto)
+                            : entry
+                    )
+                    .ToArray(),
+                currentControl.UnknownUInt
+            );
+            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
+        }
+
+        /// <summary>
+        ///     Changes a cooler settings by modifying the policy to manual and sets a new level
+        /// </summary>
+        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
+        /// <param name="newLevel">The new cooler level.</param>
+        public void SetCoolerSettings(int coolerId, int newLevel)
+        {
+            SetCoolerSettings(coolerId, CoolerPolicy.Manual, newLevel);
+        }
+    }
+}

NvAPIWrapper/GPU/GPUMemoryInformation.cs

@@ -0,0 +1,232 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+using System;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information regarding the available and total memory as well as the type of memory and other information
+    ///     regarding the GPU RAM and frame buffer
+    /// </summary>
+    public class GPUMemoryInformation : IDisplayDriverMemoryInfo
+    {
+        internal GPUMemoryInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the frame buffer bandwidth
+        /// </summary>
+
+        public int FrameBufferBandwidth
+        {
+            get
+            {
+                GPUApi.GetFrameBufferWidthAndLocation(PhysicalGPU.Handle, out var width, out _);
+
+                return (int)width;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the frame buffer location index
+        /// </summary>
+        public int FrameBufferLocation
+        {
+            get
+            {
+                GPUApi.GetFrameBufferWidthAndLocation(PhysicalGPU.Handle, out _, out var location);
+
+                return (int)location;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the internal clock to bus clock factor based on the type of RAM
+        /// </summary>
+        public int InternalClockToBusClockFactor
+        {
+            get => GetMemoryBusClockFactor(RAMType);
+        }
+
+        /// <summary>
+        ///     Gets the internal clock to transfer rate factor based on the type of RAM
+        /// </summary>
+        public int InternalClockToTransferRateFactor
+        {
+            get => GetMemoryTransferRateFactor(RAMType);
+        }
+
+        /// <summary>
+        ///     Gets GPU physical frame buffer size in KB. This does NOT include any system RAM that may be dedicated for use by
+        ///     the GPU.
+        /// </summary>
+        public int PhysicalFrameBufferSizeInkB
+        {
+            get => GPUApi.GetPhysicalFrameBufferSize(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets the number of memory banks
+        /// </summary>
+        public uint RAMBanks
+        {
+            get => GPUApi.GetRAMBankCount(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the memory bus width
+        /// </summary>
+        public uint RAMBusWidth
+        {
+            get => GPUApi.GetRAMBusWidth(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the memory maker (brand)
+        /// </summary>
+        public GPUMemoryMaker RAMMaker
+        {
+            get => GPUApi.GetRAMMaker(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the memory type
+        /// </summary>
+        public GPUMemoryType RAMType
+        {
+            get => GPUApi.GetRAMType(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets virtual size of frame-buffer in KB for this GPU. This includes the physical RAM plus any system RAM that has
+        ///     been dedicated for use by the GPU.
+        /// </summary>
+        public int VirtualFrameBufferSizeInkB
+        {
+            get => GPUApi.GetVirtualFrameBufferSize(PhysicalGPU.Handle);
+        }
+
+        /// <inheritdoc />
+        public uint AvailableDedicatedVideoMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).AvailableDedicatedVideoMemoryInkB;
+        }
+
+        /// <inheritdoc />
+        public uint CurrentAvailableDedicatedVideoMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).CurrentAvailableDedicatedVideoMemoryInkB;
+        }
+
+        /// <inheritdoc />
+        public uint DedicatedVideoMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).DedicatedVideoMemoryInkB;
+        }
+
+        /// <inheritdoc />
+        public uint SharedSystemMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).SharedSystemMemoryInkB;
+        }
+
+        /// <inheritdoc />
+        public uint SystemVideoMemoryInkB
+        {
+            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).SystemVideoMemoryInkB;
+        }
+
+        /// <summary>
+        ///     Gets the memory bus clock to internal memory clock factor
+        /// </summary>
+        /// <param name="memoryType"></param>
+        /// <returns>The value of X in X(InternalMemoryClock)=(BusMemoryClock)</returns>
+        public static int GetMemoryBusClockFactor(GPUMemoryType memoryType)
+        {
+            switch (memoryType)
+            {
+                case GPUMemoryType.SDRAM:
+
+                    // Bus Clocks Per Internal Clock = 1
+                    return 1;
+                case GPUMemoryType.DDR1:
+                case GPUMemoryType.DDR2:
+                case GPUMemoryType.DDR3:
+                case GPUMemoryType.GDDR2:
+                case GPUMemoryType.GDDR3:
+                case GPUMemoryType.GDDR4:
+                case GPUMemoryType.LPDDR2:
+                case GPUMemoryType.GDDR5:
+                case GPUMemoryType.GDDR5X:
+                case GPUMemoryType.GDDR6:
+                case GPUMemoryType.GDDR6X:
+
+                    // Bus Clocks Per Internal Clock = 2
+                    return 2;
+                default:
+
+                    throw new ArgumentOutOfRangeException(nameof(memoryType));
+            }
+        }
+
+        /// <summary>
+        ///     Gets the number of transfers per internal memory clock factor
+        /// </summary>
+        /// <param name="memoryType"></param>
+        /// <returns>The value of X in X(InternalMemoryClock)=(OperationsPerSecond)</returns>
+        public static int GetMemoryTransferRateFactor(GPUMemoryType memoryType)
+        {
+            switch (memoryType)
+            {
+                case GPUMemoryType.SDRAM:
+
+                    // Transfers Per Internal Clock = 1
+                    return 1;
+                case GPUMemoryType.DDR1:
+                case GPUMemoryType.DDR2:
+                case GPUMemoryType.DDR3:
+                case GPUMemoryType.GDDR2:
+                case GPUMemoryType.GDDR3:
+                case GPUMemoryType.GDDR4:
+                case GPUMemoryType.LPDDR2:
+
+                    // Transfers Per Internal Clock = 1
+                    return 2;
+                case GPUMemoryType.GDDR5:
+
+                    // Transfers Per Internal Clock = 2
+                    return 4;
+                case GPUMemoryType.GDDR5X:
+
+                    // Transfers Per Internal Clock = 4
+                    return 8;
+                case GPUMemoryType.GDDR6:
+
+                    // Transfers Per Internal Clock = 2
+                    return 4;
+                case GPUMemoryType.GDDR6X:
+
+                    // Transfers Per Internal Clock = 4
+                    return 8;
+                default:
+
+                    throw new ArgumentOutOfRangeException(nameof(memoryType));
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"[{RAMMaker} {RAMType}] Total: {AvailableDedicatedVideoMemoryInkB:N0} kB - Available: {CurrentAvailableDedicatedVideoMemoryInkB:N0} kB";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUOutput.cs

@@ -0,0 +1,264 @@
+using System;
+using NvAPIWrapper.Display;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a single GPU output
+    /// </summary>
+    public class GPUOutput : IEquatable<GPUOutput>
+    {
+        internal GPUOutput(OutputId outputId, PhysicalGPUHandle gpuHandle)
+        {
+            OutputId = outputId;
+            OutputType = !gpuHandle.IsNull ? GPUApi.GetOutputType(gpuHandle, outputId) : OutputType.Unknown;
+            PhysicalGPU = new PhysicalGPU(gpuHandle);
+        }
+
+        internal GPUOutput(OutputId outputId, PhysicalGPU gpu)
+            : this(outputId, gpu?.Handle ?? PhysicalGPUHandle.DefaultHandle)
+        {
+            PhysicalGPU = gpu;
+        }
+
+        /// <summary>
+        ///     Gets the corresponding Digital Vibrance Control information
+        /// </summary>
+        public DVCInformation DigitalVibranceControl
+        {
+            get => new DVCInformation(OutputId);
+        }
+
+        /// <summary>
+        ///     Gets the corresponding HUE information
+        /// </summary>
+        public HUEInformation HUEControl
+        {
+            get => new HUEInformation(OutputId);
+        }
+
+        /// <summary>
+        ///     Gets the output identification as a single bit unsigned integer
+        /// </summary>
+        public OutputId OutputId { get; }
+
+        /// <summary>
+        ///     Gets the output type
+        /// </summary>
+        public OutputType OutputType { get; }
+
+        /// <summary>
+        ///     Gets the corresponding physical GPU
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <inheritdoc />
+        public bool Equals(GPUOutput other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return PhysicalGPU.Equals(other.PhysicalGPU) && OutputId == other.OutputId;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(GPUOutput left, GPUOutput right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(GPUOutput left, GPUOutput right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((GPUOutput) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return ((PhysicalGPU != null ? PhysicalGPU.GetHashCode() : 0) * 397) ^ (int) OutputId;
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{OutputId} {OutputType} @ {PhysicalGPU}";
+        }
+
+        /// <summary>
+        ///     Overrides the refresh rate on this output.
+        ///     The new refresh rate can be applied right away or deferred to be applied with the next OS
+        ///     mode-set.
+        ///     The override is good for only one mode-set (regardless whether it's deferred or immediate).
+        /// </summary>
+        /// <param name="refreshRate">The refresh rate to be applied.</param>
+        /// <param name="isDeferred">
+        ///     A boolean value indicating if the refresh rate override should be deferred to the next OS
+        ///     mode-set.
+        /// </param>
+        public void OverrideRefreshRate(float refreshRate, bool isDeferred = false)
+        {
+            DisplayApi.SetRefreshRateOverride(OutputId, refreshRate, isDeferred);
+        }
+
+        /// <summary>
+        ///     Reads data from the I2C bus
+        /// </summary>
+        /// <param name="portId">The port id on which device is connected</param>
+        /// <param name="useDDCPort">A boolean value indicating that the DDC port should be used instead of the communication port</param>
+        /// <param name="deviceAddress">The device I2C slave address</param>
+        /// <param name="registerAddress">The target I2C register address</param>
+        /// <param name="readDataLength">The length of the buffer to allocate for the read operation.</param>
+        /// <param name="speed">The target speed of the transaction in kHz</param>
+        public byte[] ReadI2C(
+            byte? portId,
+            bool useDDCPort,
+            byte deviceAddress,
+            byte[] registerAddress,
+            uint readDataLength,
+            I2CSpeed speed = I2CSpeed.Default
+        )
+        {
+            try
+            {
+                // ReSharper disable once InconsistentNaming
+                var i2cInfoV3 = new I2CInfoV3(
+                    OutputId,
+                    portId,
+                    useDDCPort,
+                    deviceAddress,
+                    registerAddress,
+                    readDataLength,
+                    speed
+                );
+
+                return PhysicalGPU.ReadI2C(i2cInfoV3);
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.IncompatibleStructureVersion || portId != null)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            // ReSharper disable once InconsistentNaming
+            var i2cInfoV2 = new I2CInfoV2(
+                OutputId,
+                useDDCPort,
+                deviceAddress,
+                registerAddress,
+                readDataLength,
+                speed
+            );
+
+            return PhysicalGPU.ReadI2C(i2cInfoV2);
+        }
+
+        /// <summary>
+        ///     Writes data to the I2C bus
+        /// </summary>
+        /// <param name="portId">The port id on which device is connected</param>
+        /// <param name="useDDCPort">A boolean value indicating that the DDC port should be used instead of the communication port</param>
+        /// <param name="deviceAddress">The device I2C slave address</param>
+        /// <param name="registerAddress">The target I2C register address</param>
+        /// <param name="data">The payload data</param>
+        /// <param name="speed">The target speed of the transaction in kHz</param>
+        public void WriteI2C(
+            byte? portId,
+            bool useDDCPort,
+            byte deviceAddress,
+            byte[] registerAddress,
+            byte[] data,
+            I2CSpeed speed = I2CSpeed.Default
+        )
+        {
+            try
+            {
+                // ReSharper disable once InconsistentNaming
+                var i2cInfoV3 = new I2CInfoV3(
+                    OutputId,
+                    portId,
+                    useDDCPort,
+                    deviceAddress,
+                    registerAddress,
+                    data,
+                    speed
+                );
+
+                PhysicalGPU.WriteI2C(i2cInfoV3);
+
+                return;
+            }
+            catch (NVIDIAApiException e)
+            {
+                if (e.Status != Status.IncompatibleStructureVersion || portId != null)
+                {
+                    throw;
+                }
+
+                // ignore
+            }
+
+            // ReSharper disable once InconsistentNaming
+            var i2cInfoV2 = new I2CInfoV2(
+                OutputId,
+                useDDCPort,
+                deviceAddress,
+                registerAddress,
+                data,
+                speed
+            );
+
+            PhysicalGPU.WriteI2C(i2cInfoV2);
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPerformanceControl.cs

@@ -0,0 +1,124 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information regarding the GPU performance control and limitations
+    /// </summary>
+    public class GPUPerformanceControl
+    {
+        internal GPUPerformanceControl(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the current active performance limitation
+        /// </summary>
+        public PerformanceLimit CurrentActiveLimit
+        {
+            get => GPUApi.PerformancePoliciesGetStatus(PhysicalGPU.Handle).PerformanceLimit;
+        }
+
+        /// <summary>
+        ///     Gets the current performance decrease reason
+        /// </summary>
+        public PerformanceDecreaseReason CurrentPerformanceDecreaseReason
+        {
+            get => GPUApi.GetPerformanceDecreaseInfo(PhysicalGPU.Handle);
+        }
+
+
+        /// <summary>
+        ///     Gets a boolean value indicating if no load limit is supported with this GPU
+        /// </summary>
+        public bool IsNoLoadLimitSupported
+        {
+            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsNoLoadLimitSupported;
+        }
+
+
+        /// <summary>
+        ///     Gets a boolean value indicating if power limit is supported with this GPU
+        /// </summary>
+        public bool IsPowerLimitSupported
+        {
+            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsPowerLimitSupported;
+        }
+
+
+        /// <summary>
+        ///     Gets a boolean value indicating if temperature limit is supported with this GPU
+        /// </summary>
+        public bool IsTemperatureLimitSupported
+        {
+            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsTemperatureLimitSupported;
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if voltage limit is supported with this GPU
+        /// </summary>
+        public bool IsVoltageLimitSupported
+        {
+            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsVoltageLimitSupported;
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets information regarding possible power limit policies and their acceptable range
+        /// </summary>
+        public IEnumerable<GPUPowerLimitInfo> PowerLimitInformation
+        {
+            get
+            {
+                return GPUApi.ClientPowerPoliciesGetInfo(PhysicalGPU.Handle).PowerPolicyInfoEntries
+                    .Select(entry => new GPUPowerLimitInfo(entry));
+            }
+        }
+
+        /// <summary>
+        ///     Gets the current active power limit policies
+        /// </summary>
+        public IEnumerable<GPUPowerLimitPolicy> PowerLimitPolicies
+        {
+            get
+            {
+                // TODO: GPUApi.ClientPowerPoliciesSetStatus();
+                return GPUApi.ClientPowerPoliciesGetStatus(PhysicalGPU.Handle).PowerPolicyStatusEntries
+                    .Select(entry => new GPUPowerLimitPolicy(entry));
+            }
+        }
+
+        /// <summary>
+        ///     Gets information regarding possible thermal limit policies and their acceptable range
+        /// </summary>
+        public IEnumerable<GPUThermalLimitInfo> ThermalLimitInformation
+        {
+            get
+            {
+                return GPUApi.GetThermalPoliciesInfo(PhysicalGPU.Handle).ThermalPoliciesInfoEntries
+                    .Select(entry => new GPUThermalLimitInfo(entry));
+            }
+        }
+
+        /// <summary>
+        ///     Gets the current active thermal limit policies
+        /// </summary>
+        public IEnumerable<GPUThermalLimitPolicy> ThermalLimitPolicies
+        {
+            get
+            {
+                // TODO: GPUApi.SetThermalPoliciesStatus();
+                return GPUApi.GetThermalPoliciesStatus(PhysicalGPU.Handle).ThermalPoliciesStatusEntries
+                    .Select(entry => new GPUThermalLimitPolicy(entry));
+            }
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPerformanceState.cs

@@ -0,0 +1,70 @@
+using System.Linq;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a performance state
+    /// </summary>
+    public class GPUPerformanceState
+    {
+        // ReSharper disable once TooManyDependencies
+        internal GPUPerformanceState(
+            int index,
+            IPerformanceState20 performanceState,
+            IPerformanceStates20ClockEntry[] statesClockEntries,
+            IPerformanceStates20VoltageEntry[] baseVoltageEntries,
+            PCIeInformation pcieInformation)
+        {
+            StateIndex = index;
+            StateId = performanceState.StateId;
+            IsReadOnly = !performanceState.IsEditable;
+            Clocks = statesClockEntries.Select(entry => new GPUPerformanceStateClock(entry)).ToArray();
+            Voltages = baseVoltageEntries.Select(entry => new GPUPerformanceStateVoltage(entry)).ToArray();
+            PCIeInformation = pcieInformation;
+        }
+
+        /// <summary>
+        ///     Gets a list of clocks associated with this performance state
+        /// </summary>
+
+        public GPUPerformanceStateClock[] Clocks { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this performance state is readonly
+        /// </summary>
+        public bool IsReadOnly { get; }
+
+        /// <summary>
+        ///     Gets the PCI-e information regarding this performance state.
+        /// </summary>
+        public PCIeInformation PCIeInformation { get; }
+
+        /// <summary>
+        ///     Gets the performance state identification
+        /// </summary>
+        public PerformanceStateId StateId { get; }
+
+        /// <summary>
+        ///     Gets the state index
+        /// </summary>
+        public int StateIndex { get; }
+
+        /// <summary>
+        ///     Gets a list of voltages associated with this performance state
+        /// </summary>
+        public GPUPerformanceStateVoltage[] Voltages { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            if (IsReadOnly)
+            {
+                return $"{StateId} (ReadOnly)";
+            }
+
+            return StateId.ToString();
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPerformanceStateClock.cs

@@ -0,0 +1,99 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a performance state clock settings
+    /// </summary>
+    public class GPUPerformanceStateClock
+    {
+        internal GPUPerformanceStateClock(IPerformanceStates20ClockEntry states20ClockEntry)
+        {
+            ClockDomain = states20ClockEntry.DomainId;
+            IsReadOnly = !states20ClockEntry.IsEditable;
+            ClockDeltaInkHz = states20ClockEntry.FrequencyDeltaInkHz.DeltaValue;
+            ClockDeltaRangeInkHz = new GPUPerformanceStateValueRange(
+                states20ClockEntry.FrequencyDeltaInkHz.DeltaRange.Minimum,
+                states20ClockEntry.FrequencyDeltaInkHz.DeltaRange.Maximum
+            );
+
+            if (states20ClockEntry.ClockType == PerformanceStates20ClockType.Range)
+            {
+                CurrentClockInkHz = new GPUPerformanceStateValueRange(
+                    states20ClockEntry.FrequencyRange.MinimumFrequencyInkHz,
+                    states20ClockEntry.FrequencyRange.MaximumFrequencyInkHz
+                );
+                BaseClockInkHz = new GPUPerformanceStateValueRange(
+                    CurrentClockInkHz.Minimum - ClockDeltaInkHz,
+                    CurrentClockInkHz.Maximum - ClockDeltaInkHz
+                );
+                DependentVoltageDomain = states20ClockEntry.FrequencyRange.VoltageDomainId;
+                DependentVoltageRangeInMicroVolt = new GPUPerformanceStateValueRange(
+                    states20ClockEntry.FrequencyRange.MinimumVoltageInMicroVolt,
+                    states20ClockEntry.FrequencyRange.MaximumVoltageInMicroVolt
+                );
+            }
+            else
+            {
+                CurrentClockInkHz = new GPUPerformanceStateValueRange(
+                    states20ClockEntry.SingleFrequency.FrequencyInkHz
+                );
+                BaseClockInkHz = new GPUPerformanceStateValueRange(
+                    CurrentClockInkHz.Minimum - ClockDeltaInkHz
+                );
+                DependentVoltageDomain = PerformanceVoltageDomain.Undefined;
+                DependentVoltageRangeInMicroVolt = null;
+            }
+        }
+
+        /// <summary>
+        ///     Gets the base clock frequency in kHz
+        /// </summary>
+        public GPUPerformanceStateValueRange BaseClockInkHz { get; }
+
+        /// <summary>
+        ///     Gets the clock frequency delta in kHz
+        /// </summary>
+        public int ClockDeltaInkHz { get; }
+
+        /// <summary>
+        ///     Gets the clock frequency delta range in kHz
+        /// </summary>
+        public GPUPerformanceStateValueRange ClockDeltaRangeInkHz { get; }
+
+        /// <summary>
+        ///     Gets the clock domain
+        /// </summary>
+        public PublicClockDomain ClockDomain { get; }
+
+        /// <summary>
+        ///     Gets the current clock frequency in kHz
+        /// </summary>
+        public GPUPerformanceStateValueRange CurrentClockInkHz { get; }
+
+        /// <summary>
+        ///     Gets the dependent voltage domain
+        /// </summary>
+        public PerformanceVoltageDomain DependentVoltageDomain { get; }
+
+        /// <summary>
+        ///     Gets the dependent voltage range in uV
+        /// </summary>
+        public GPUPerformanceStateValueRange DependentVoltageRangeInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this clock setting is readonly
+        /// </summary>
+        public bool IsReadOnly { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var title = IsReadOnly ? $"{ClockDomain} (ReadOnly)" : ClockDomain.ToString();
+
+            return
+                $"{title}: {BaseClockInkHz} + ({ClockDeltaInkHz}) = {CurrentClockInkHz}";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPerformanceStateValueRange.cs

@@ -0,0 +1,115 @@
+using System;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents an integer value range
+    /// </summary>
+    public class GPUPerformanceStateValueRange : IEquatable<GPUPerformanceStateValueRange>
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="GPUPerformanceStateValueRange" />.
+        /// </summary>
+        /// <param name="min">The lower bound of the range.</param>
+        /// <param name="max">The upper bound of the range.</param>
+        public GPUPerformanceStateValueRange(long min, long max)
+        {
+            Minimum = min;
+            Maximum = max;
+        }
+
+        /// <summary>
+        ///     Creates a new single value instance of <see cref="GPUPerformanceStateValueRange" />.
+        /// </summary>
+        /// <param name="value">The only value in the range</param>
+        public GPUPerformanceStateValueRange(long value)
+        {
+            Minimum = value;
+            Maximum = value;
+        }
+
+        /// <summary>
+        ///     Gets the upper bound of the inclusive range
+        /// </summary>
+        public long Maximum { get; }
+
+        /// <summary>
+        ///     Gets the lower bound of the inclusive range
+        /// </summary>
+        public long Minimum { get; }
+
+        /// <inheritdoc />
+        public bool Equals(GPUPerformanceStateValueRange other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Maximum == other.Maximum && Minimum == other.Minimum;
+        }
+
+        /// <summary>
+        ///     Checks two instances of <see cref="GPUPerformanceStateValueRange" /> for equality.
+        /// </summary>
+        /// <param name="left">The left side of the comparison.</param>
+        /// <param name="right">The right side of the comparison.</param>
+        /// <returns>true if instances are equal, otherwise false</returns>
+        public static bool operator ==(GPUPerformanceStateValueRange left, GPUPerformanceStateValueRange right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Checks two instances of <see cref="GPUPerformanceStateValueRange" /> for inequality.
+        /// </summary>
+        /// <param name="left">The left side of the comparison.</param>
+        /// <param name="right">The right side of the comparison.</param>
+        /// <returns>true if instances are in-equal, otherwise false</returns>
+        public static bool operator !=(GPUPerformanceStateValueRange left, GPUPerformanceStateValueRange right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as GPUPerformanceStateValueRange);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return ((int) Maximum * 397) ^ (int) Minimum;
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            if (Minimum == Maximum)
+            {
+                return $"({Minimum})";
+            }
+
+            return $"[({Minimum}) - ({Maximum})]";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPerformanceStateVoltage.cs

@@ -0,0 +1,65 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a performance state voltage settings
+    /// </summary>
+    public class GPUPerformanceStateVoltage
+    {
+        internal GPUPerformanceStateVoltage(IPerformanceStates20VoltageEntry states20BaseVoltageEntry)
+        {
+            VoltageDomain = states20BaseVoltageEntry.DomainId;
+            IsReadOnly = !states20BaseVoltageEntry.IsEditable;
+
+            CurrentVoltageInMicroVolt = states20BaseVoltageEntry.ValueInMicroVolt;
+            VoltageDeltaInMicroVolt = states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaValue;
+            BaseVoltageInMicroVolt = (int) (CurrentVoltageInMicroVolt - VoltageDeltaInMicroVolt);
+
+            VoltageDeltaRangeInMicroVolt = new GPUPerformanceStateValueRange(
+                states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaRange.Minimum,
+                states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaRange.Maximum
+            );
+        }
+
+        /// <summary>
+        ///     Gets the base voltage in uV
+        /// </summary>
+        public int BaseVoltageInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets the current voltage in uV
+        /// </summary>
+        public uint CurrentVoltageInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if this voltage is readonly
+        /// </summary>
+        public bool IsReadOnly { get; }
+
+        /// <summary>
+        ///     Gets the voltage delta in uV
+        /// </summary>
+        public int VoltageDeltaInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets the voltage delta range in uV
+        /// </summary>
+        public GPUPerformanceStateValueRange VoltageDeltaRangeInMicroVolt { get; }
+
+        /// <summary>
+        ///     Gets the voltage domain
+        /// </summary>
+        public PerformanceVoltageDomain VoltageDomain { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var title = IsReadOnly ? $"{VoltageDomain} (ReadOnly)" : VoltageDomain.ToString();
+
+            return
+                $"{title}: ({BaseVoltageInMicroVolt}) + ({VoltageDeltaInMicroVolt}) = ({CurrentVoltageInMicroVolt})";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPerformanceStatesInfo.cs

@@ -0,0 +1,107 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds the retrieved performance states information
+    /// </summary>
+    public class GPUPerformanceStatesInformation
+    {
+        internal GPUPerformanceStatesInformation(
+            IPerformanceStates20Info states20Info,
+            PerformanceStateId currentPerformanceStateId,
+            PrivatePCIeInfoV2? pciInformation)
+        {
+            IsReadOnly = !states20Info.IsEditable;
+
+            GlobalVoltages = states20Info.GeneralVoltages
+                .Select(entry => new GPUPerformanceStateVoltage(entry))
+                .ToArray();
+
+            var clocks = states20Info.Clocks;
+            var baseVoltages = states20Info.Voltages;
+
+            PerformanceStates = states20Info.PerformanceStates.Select((state20, i) =>
+            {
+                PCIeInformation statePCIeInfo = null;
+
+                if (pciInformation != null && pciInformation.Value.PCIePerformanceStateInfos.Length > i)
+                {
+                    statePCIeInfo = new PCIeInformation(pciInformation.Value.PCIePerformanceStateInfos[i]);
+                }
+
+                return new GPUPerformanceState(
+                    i,
+                    state20,
+                    clocks[state20.StateId],
+                    baseVoltages[state20.StateId],
+                    statePCIeInfo
+                );
+            }).ToArray();
+
+            CurrentPerformanceState =
+                PerformanceStates.FirstOrDefault(performanceState =>
+                    performanceState.StateId == currentPerformanceStateId);
+        }
+
+        /// <summary>
+        ///     Gets the currently active performance state
+        /// </summary>
+        public GPUPerformanceState CurrentPerformanceState { get; }
+
+        /// <summary>
+        ///     Gets a list of global voltage settings
+        /// </summary>
+        public GPUPerformanceStateVoltage[] GlobalVoltages { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if performance states are readonly
+        /// </summary>
+        public bool IsReadOnly { get; }
+
+        /// <summary>
+        ///     Gets a list of all available performance states
+        /// </summary>
+        public GPUPerformanceState[] PerformanceStates { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            if (PerformanceStates.Length == 0)
+            {
+                return "No Performance State Available";
+            }
+
+            return string.Join(
+                ", ",
+                PerformanceStates
+                    .Select(
+                        state =>
+                        {
+                            var attributes = new List<string>();
+
+                            if (state.IsReadOnly)
+                            {
+                                attributes.Add("ReadOnly");
+                            }
+
+                            if (CurrentPerformanceState.StateId == state.StateId)
+                            {
+                                attributes.Add("Active");
+                            }
+
+                            if (attributes.Any())
+                            {
+                                return $"{state.StateId} ({string.Join(" - ", attributes)})";
+                            }
+
+                            return state.StateId.ToString();
+                        })
+            );
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPowerLimitInfo.cs

@@ -0,0 +1,70 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a possible power limit policy and its acceptable range
+    /// </summary>
+    public class GPUPowerLimitInfo
+    {
+        internal GPUPowerLimitInfo(PrivatePowerPoliciesInfoV1.PowerPolicyInfoEntry powerPolicyInfoEntry)
+        {
+            PerformanceStateId = powerPolicyInfoEntry.PerformanceStateId;
+            MinimumPowerInPCM = powerPolicyInfoEntry.MinimumPowerInPCM;
+            DefaultPowerInPCM = powerPolicyInfoEntry.DefaultPowerInPCM;
+            MaximumPowerInPCM = powerPolicyInfoEntry.MaximumPowerInPCM;
+        }
+
+        /// <summary>
+        ///     Gets the default policy target power in per cent mille (PCM)
+        /// </summary>
+        public uint DefaultPowerInPCM { get; }
+
+        /// <summary>
+        ///     Gets the default policy target power in percentage
+        /// </summary>
+        public float DefaultPowerInPercent
+        {
+            get => DefaultPowerInPCM / 1000f;
+        }
+
+        /// <summary>
+        ///     Gets the maximum possible policy target power in per cent mille (PCM)
+        /// </summary>
+        public uint MaximumPowerInPCM { get; }
+
+        /// <summary>
+        ///     Gets the maximum possible policy target power in percentage
+        /// </summary>
+        public float MaximumPowerInPercent
+        {
+            get => MaximumPowerInPCM / 1000f;
+        }
+
+        /// <summary>
+        ///     Gets the minimum possible policy target power in per cent mille (PCM)
+        /// </summary>
+        public uint MinimumPowerInPCM { get; }
+
+        /// <summary>
+        ///     Gets the minimum possible policy target power in percentage
+        /// </summary>
+        public float MinimumPowerInPercent
+        {
+            get => MinimumPowerInPCM / 1000f;
+        }
+
+        /// <summary>
+        ///     Gets the corresponding performance state identification
+        /// </summary>
+        public PerformanceStateId PerformanceStateId { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"[{PerformanceStateId}] Default: {DefaultPowerInPercent}% - Range: ({MinimumPowerInPercent}% - {MaximumPowerInPercent}%)";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPowerLimitPolicy.cs

@@ -0,0 +1,41 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a currently active power limit policy
+    /// </summary>
+    public class GPUPowerLimitPolicy
+    {
+        internal GPUPowerLimitPolicy(PrivatePowerPoliciesStatusV1.PowerPolicyStatusEntry powerPolicyStatusEntry)
+        {
+            PerformanceStateId = powerPolicyStatusEntry.PerformanceStateId;
+            PowerTargetInPCM = powerPolicyStatusEntry.PowerTargetInPCM;
+        }
+
+        /// <summary>
+        ///     Gets the corresponding performance state identification
+        /// </summary>
+        public PerformanceStateId PerformanceStateId { get; }
+
+        /// <summary>
+        ///     Gets the current policy target power in per cent mille (PCM)
+        /// </summary>
+        public uint PowerTargetInPCM { get; }
+
+        /// <summary>
+        ///     Gets the current policy target power in percentage
+        /// </summary>
+        public float PowerTargetInPercent
+        {
+            get => PowerTargetInPCM / 1000f;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{PerformanceStateId} Target: {PowerTargetInPercent}%";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPowerTopologyInformation.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding current power topology and their current power usage
+    /// </summary>
+    public class GPUPowerTopologyInformation
+    {
+        internal GPUPowerTopologyInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets the current power topology entries
+        /// </summary>
+        public IEnumerable<GPUPowerTopologyStatus> PowerTopologyEntries
+        {
+            get
+            {
+                return GPUApi.ClientPowerTopologyGetStatus(PhysicalGPU.Handle).PowerPolicyStatusEntries
+                    .Select(entry => new GPUPowerTopologyStatus(entry));
+            }
+        }
+    }
+}

NvAPIWrapper/GPU/GPUPowerTopologyStatus.cs

@@ -0,0 +1,42 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about a power domain usage
+    /// </summary>
+    public class GPUPowerTopologyStatus
+    {
+        internal GPUPowerTopologyStatus(
+            PrivatePowerTopologiesStatusV1.PowerTopologiesStatusEntry powerTopologiesStatusEntry)
+        {
+            Domain = powerTopologiesStatusEntry.Domain;
+            PowerUsageInPCM = powerTopologiesStatusEntry.PowerUsageInPCM;
+        }
+
+        /// <summary>
+        ///     Gets the power usage domain
+        /// </summary>
+        public PowerTopologyDomain Domain { get; }
+
+        /// <summary>
+        ///     Gets the current power usage in per cent mille (PCM)
+        /// </summary>
+        public uint PowerUsageInPCM { get; }
+
+        /// <summary>
+        ///     Gets the current power usage in percentage
+        /// </summary>
+        public float PowerUsageInPercent
+        {
+            get => PowerUsageInPCM / 1000f;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{Domain}] {PowerUsageInPercent}%";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUThermalInformation.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding the available thermal sensors and current thermal level of a GPU
+    /// </summary>
+    public class GPUThermalInformation
+    {
+        internal GPUThermalInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the current thermal level of the GPU
+        /// </summary>
+        public int CurrentThermalLevel
+        {
+            get => (int) GPUApi.GetCurrentThermalLevel(PhysicalGPU.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets the list of available thermal sensors
+        /// </summary>
+        public IEnumerable<GPUThermalSensor> ThermalSensors
+        {
+            get
+            {
+                return GPUApi.GetThermalSettings(PhysicalGPU.Handle).Sensors
+                    .Select((sensor, i) => new GPUThermalSensor(i, sensor));
+            }
+        }
+    }
+}

NvAPIWrapper/GPU/GPUThermalLimitInfo.cs

@@ -0,0 +1,47 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a possible thermal limit policy and its acceptable range
+    /// </summary>
+    public class GPUThermalLimitInfo
+    {
+        internal GPUThermalLimitInfo(PrivateThermalPoliciesInfoV2.ThermalPoliciesInfoEntry policiesInfoEntry)
+        {
+            Controller = policiesInfoEntry.Controller;
+            MinimumTemperature = policiesInfoEntry.MinimumTemperature;
+            DefaultTemperature = policiesInfoEntry.DefaultTemperature;
+            MaximumTemperature = policiesInfoEntry.MaximumTemperature;
+        }
+
+        /// <summary>
+        ///     Gets the policy's thermal controller
+        /// </summary>
+        public ThermalController Controller { get; }
+
+        /// <summary>
+        ///     Gets the default policy target temperature in degree Celsius
+        /// </summary>
+        public int DefaultTemperature { get; }
+
+
+        /// <summary>
+        ///     Gets the maximum possible policy target temperature in degree Celsius
+        /// </summary>
+        public int MaximumTemperature { get; }
+
+        /// <summary>
+        ///     Gets the minimum possible policy target temperature in degree Celsius
+        /// </summary>
+        public int MinimumTemperature { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"[{Controller}] Default: {DefaultTemperature}°C - Range: ({MinimumTemperature}°C - {MaximumTemperature}°C)";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUThermalLimitPolicy.cs

@@ -0,0 +1,40 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information regarding a currently active temperature limit policy
+    /// </summary>
+    public class GPUThermalLimitPolicy
+    {
+        internal GPUThermalLimitPolicy(PrivateThermalPoliciesStatusV2.ThermalPoliciesStatusEntry thermalPoliciesEntry)
+        {
+            Controller = thermalPoliciesEntry.Controller;
+            PerformanceStateId = thermalPoliciesEntry.PerformanceStateId;
+            TargetTemperature = thermalPoliciesEntry.TargetTemperature;
+        }
+
+        /// <summary>
+        ///     Gets the policy's thermal controller
+        /// </summary>
+        public ThermalController Controller { get; }
+
+        /// <summary>
+        ///     Gets the corresponding performance state identification
+        /// </summary>
+        public PerformanceStateId PerformanceStateId { get; }
+
+        /// <summary>
+        ///     Gets the current policy target temperature in degree Celsius
+        /// </summary>
+        public int TargetTemperature { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"{PerformanceStateId} [{Controller}] Target: {TargetTemperature}°C";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUThermalSensor.cs

@@ -0,0 +1,48 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a thermal sensor
+    /// </summary>
+    public class GPUThermalSensor : IThermalSensor
+    {
+        internal GPUThermalSensor(int sensorId, IThermalSensor thermalSensor)
+        {
+            SensorId = sensorId;
+            Controller = thermalSensor.Controller;
+            DefaultMinimumTemperature = thermalSensor.DefaultMinimumTemperature;
+            DefaultMaximumTemperature = thermalSensor.DefaultMaximumTemperature;
+            CurrentTemperature = thermalSensor.CurrentTemperature;
+            Target = thermalSensor.Target;
+        }
+
+        /// <summary>
+        ///     Gets the sensor identification number or index
+        /// </summary>
+        public int SensorId { get; set; }
+
+        /// <inheritdoc />
+        public ThermalController Controller { get; }
+
+        /// <inheritdoc />
+        public int CurrentTemperature { get; }
+
+        /// <inheritdoc />
+        public int DefaultMaximumTemperature { get; }
+
+        /// <inheritdoc />
+        public int DefaultMinimumTemperature { get; }
+
+        /// <inheritdoc />
+        public ThermalSettingsTarget Target { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"[{Target} @ {Controller}] Current: {CurrentTemperature}°C - Default Range: [({DefaultMinimumTemperature}°C) , ({DefaultMaximumTemperature}°C)]";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUUsageDomainStatus.cs

@@ -0,0 +1,33 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information about a utilization domain
+    /// </summary>
+    public class GPUUsageDomainStatus
+    {
+        internal GPUUsageDomainStatus(UtilizationDomain domain, IUtilizationDomainInfo utilizationDomainInfo)
+        {
+            Domain = domain;
+            Percentage = (int) utilizationDomainInfo.Percentage;
+        }
+
+        /// <summary>
+        ///     Gets the utilization domain that this instance describes
+        /// </summary>
+        public UtilizationDomain Domain { get; }
+
+        /// <summary>
+        ///     Gets the percentage of time where the domain is considered busy in the last 1 second interval.
+        /// </summary>
+        public int Percentage { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"[{Domain}] {Percentage}%";
+        }
+    }
+}

NvAPIWrapper/GPU/GPUUsageInformation.cs

@@ -0,0 +1,99 @@
+using System.Collections.Generic;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Holds information about the GPU utilization domains
+    /// </summary>
+    public class GPUUsageInformation
+    {
+        internal GPUUsageInformation(PhysicalGPU physicalGPU)
+        {
+            PhysicalGPU = physicalGPU;
+        }
+
+        /// <summary>
+        ///     Gets the Bus interface (BUS) utilization
+        /// </summary>
+        public GPUUsageDomainStatus BusInterface
+        {
+            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.BusInterface);
+        }
+
+        /// <summary>
+        ///     Gets the frame buffer (FB) utilization
+        /// </summary>
+        public GPUUsageDomainStatus FrameBuffer
+        {
+            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.FrameBuffer);
+        }
+
+        /// <summary>
+        ///     Gets the graphic engine (GPU) utilization
+        /// </summary>
+        public GPUUsageDomainStatus GPU
+        {
+            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.GPU);
+        }
+
+        /// <summary>
+        ///     Gets a boolean value indicating if the dynamic performance states is enabled
+        /// </summary>
+        public bool IsDynamicPerformanceStatesEnabled
+        {
+            get => GPUApi.GetDynamicPerformanceStatesInfoEx(PhysicalGPU.Handle).IsDynamicPerformanceStatesEnabled;
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU that this instance describes
+        /// </summary>
+        public PhysicalGPU PhysicalGPU { get; }
+
+        /// <summary>
+        ///     Gets all valid utilization domains and information
+        /// </summary>
+        public IEnumerable<GPUUsageDomainStatus> UtilizationDomainsStatus
+        {
+            get
+            {
+                try
+                {
+                    var dynamicPerformanceStates = GPUApi.GetDynamicPerformanceStatesInfoEx(PhysicalGPU.Handle);
+
+                    if (dynamicPerformanceStates.IsDynamicPerformanceStatesEnabled)
+                    {
+                        return dynamicPerformanceStates.Domains
+                            .Select(pair => new GPUUsageDomainStatus(pair.Key, pair.Value));
+                    }
+                }
+                catch
+                {
+                    // ignored
+                }
+
+                return GPUApi.GetUsages(PhysicalGPU.Handle).Domains
+                    .Select(pair => new GPUUsageDomainStatus(pair.Key, pair.Value));
+            }
+        }
+
+
+        /// <summary>
+        ///     Gets the Video engine (VID) utilization
+        /// </summary>
+        public GPUUsageDomainStatus VideoEngine
+        {
+            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.VideoEngine);
+        }
+
+        /// <summary>
+        ///     Enables dynamic performance states
+        /// </summary>
+        public void EnableDynamicPerformanceStates()
+        {
+            GPUApi.EnableDynamicPStates(PhysicalGPU.Handle);
+        }
+    }
+}

NvAPIWrapper/GPU/LogicalGPU.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Linq;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a logical NVIDIA GPU
+    /// </summary>
+    public class LogicalGPU : IEquatable<LogicalGPU>
+    {
+        /// <summary>
+        ///     Creates a new LogicalGPU
+        /// </summary>
+        /// <param name="handle">Logical GPU handle</param>
+        public LogicalGPU(LogicalGPUHandle handle)
+        {
+            Handle = handle;
+        }
+
+        /// <summary>
+        ///     Gets a list of all corresponding physical GPUs
+        /// </summary>
+        public PhysicalGPU[] CorrespondingPhysicalGPUs
+        {
+            get
+            {
+                return GPUApi.GetPhysicalGPUsFromLogicalGPU(Handle).Select(handle => new PhysicalGPU(handle)).ToArray();
+            }
+        }
+
+        /// <summary>
+        ///     Gets the logical GPU handle
+        /// </summary>
+        public LogicalGPUHandle Handle { get; }
+
+        /// <inheritdoc />
+        public bool Equals(LogicalGPU other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Handle.Equals(other.Handle);
+        }
+
+        /// <summary>
+        ///     Gets all logical GPUs
+        /// </summary>
+        /// <returns>An array of logical GPUs</returns>
+        public static LogicalGPU[] GetLogicalGPUs()
+        {
+            return GPUApi.EnumLogicalGPUs().Select(handle => new LogicalGPU(handle)).ToArray();
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(LogicalGPU left, LogicalGPU right)
+        {
+            return right?.Equals(left) ?? ReferenceEquals(left, null);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(LogicalGPU left, LogicalGPU right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            return Equals((LogicalGPU) obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Handle.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return
+                $"Logical GPU [{CorrespondingPhysicalGPUs.Length}] {{{string.Join(", ", CorrespondingPhysicalGPUs.Select(gpu => gpu.FullName).ToArray())}}}";
+        }
+    }
+}

NvAPIWrapper/GPU/PCIIdentifiers.cs

@@ -0,0 +1,114 @@
+using System;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the PCI connection
+    /// </summary>
+    public class PCIIdentifiers : IEquatable<PCIIdentifiers>
+    {
+        // ReSharper disable once TooManyDependencies
+        internal PCIIdentifiers(uint deviceId, uint subSystemId, uint revisionId, int externalDeviceId = 0)
+        {
+            DeviceId = deviceId;
+            SubSystemId = subSystemId;
+            RevisionId = revisionId;
+
+            if (externalDeviceId > 0)
+            {
+                ExternalDeviceId = (ushort) externalDeviceId;
+            }
+            else
+            {
+                ExternalDeviceId = (ushort) (deviceId >> 16);
+            }
+
+            VendorId = (ushort) ((DeviceId << 16) >> 16);
+        }
+
+        /// <summary>
+        ///     Gets the internal PCI device identifier
+        /// </summary>
+        public uint DeviceId { get; }
+
+        /// <summary>
+        ///     Gets the external PCI device identifier
+        /// </summary>
+        public ushort ExternalDeviceId { get; }
+
+        /// <summary>
+        ///     Gets the internal PCI device-specific revision identifier
+        /// </summary>
+        public uint RevisionId { get; }
+
+        /// <summary>
+        ///     Gets the internal PCI subsystem identifier
+        /// </summary>
+        public uint SubSystemId { get; }
+
+        /// <summary>
+        ///     Gets the vendor identification calculated from internal device identification
+        /// </summary>
+        public ushort VendorId { get; }
+
+        /// <inheritdoc />
+        public bool Equals(PCIIdentifiers other)
+        {
+            return DeviceId == other.DeviceId &&
+                   SubSystemId == other.SubSystemId &&
+                   RevisionId == other.RevisionId;
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(PCIIdentifiers left, PCIIdentifiers right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(PCIIdentifiers left, PCIIdentifiers right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is PCIIdentifiers identifiers && Equals(identifiers);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = (int) DeviceId;
+                hashCode = (hashCode * 397) ^ (int) SubSystemId;
+                hashCode = (hashCode * 397) ^ (int) RevisionId;
+
+                return hashCode;
+            }
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"PCI\\VEN_{VendorId:X}&DEV_{ExternalDeviceId:X}&SUBSYS_{SubSystemId:X}&REV_{RevisionId:X}";
+        }
+    }
+}

NvAPIWrapper/GPU/PCIeInformation.cs

@@ -0,0 +1,67 @@
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the PCI-e connection
+    /// </summary>
+    public class PCIeInformation
+    {
+        internal PCIeInformation(PrivatePCIeInfoV2.PCIePerformanceStateInfo stateInfo)
+        {
+            TransferRateInMTps = stateInfo.TransferRateInMTps;
+            Generation = stateInfo.Generation;
+            Lanes = stateInfo.Lanes;
+            Version = stateInfo.Version;
+        }
+
+        /// <summary>
+        ///     Gets the PCI-e generation
+        /// </summary>
+        public PCIeGeneration Generation { get; }
+
+        /// <summary>
+        ///     Gets the PCI-e down stream lanes
+        /// </summary>
+        public uint Lanes { get; }
+
+        /// <summary>
+        ///     Gets the PCIe transfer rate in Mega Transfers per Second
+        /// </summary>
+        public uint TransferRateInMTps { get; }
+
+        /// <summary>
+        ///     Gets the PCI-e version
+        /// </summary>
+        public PCIeGeneration Version { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var v = "Unknown";
+
+            switch (Version)
+            {
+                case PCIeGeneration.PCIe1:
+                    v = "PCIe 1.0";
+
+                    break;
+                case PCIeGeneration.PCIe1Minor1:
+                    v = "PCIe 1.1";
+
+                    break;
+                case PCIeGeneration.PCIe2:
+                    v = "PCIe 2.0";
+
+                    break;
+                case PCIeGeneration.PCIe3:
+                    v = "PCIe 3.0";
+
+                    break;
+            }
+
+            return $"{v} x{Lanes} - {TransferRateInMTps} MTps";
+        }
+    }
+}

NvAPIWrapper/GPU/PhysicalGPU.cs

@@ -0,0 +1,559 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using NvAPIWrapper.Display;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Represents a physical NVIDIA GPU
+    /// </summary>
+    public class PhysicalGPU : IEquatable<PhysicalGPU>
+    {
+        /// <summary>
+        ///     Creates a new PhysicalGPU
+        /// </summary>
+        /// <param name="handle">Physical GPU handle</param>
+        public PhysicalGPU(PhysicalGPUHandle handle)
+        {
+            Handle = handle;
+            UsageInformation = new GPUUsageInformation(this);
+            ThermalInformation = new GPUThermalInformation(this);
+            BusInformation = new GPUBusInformation(this);
+            ArchitectInformation = new GPUArchitectInformation(this);
+            MemoryInformation = new GPUMemoryInformation(this);
+            CoolerInformation = new GPUCoolerInformation(this);
+            ECCMemoryInformation = new ECCMemoryInformation(this);
+            PerformanceControl = new GPUPerformanceControl(this);
+            PowerTopologyInformation = new GPUPowerTopologyInformation(this);
+        }
+
+        /// <summary>
+        ///     Gets all active outputs of this GPU
+        /// </summary>
+        public GPUOutput[] ActiveOutputs
+        {
+            get
+            {
+                var outputs = new List<GPUOutput>();
+                var allOutputs = GPUApi.GetActiveOutputs(Handle);
+
+                foreach (OutputId outputId in Enum.GetValues(typeof(OutputId)))
+                {
+                    if (outputId != OutputId.Invalid && allOutputs.HasFlag(outputId))
+                    {
+                        outputs.Add(new GPUOutput(outputId, this));
+                    }
+                }
+
+                return outputs.ToArray();
+            }
+        }
+
+        /// <summary>
+        ///     Gets GPU architect information
+        /// </summary>
+        public GPUArchitectInformation ArchitectInformation { get; }
+
+        /// <summary>
+        ///     Gets GPU base clock frequencies
+        /// </summary>
+        public IClockFrequencies BaseClockFrequencies
+        {
+            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.BaseClock));
+        }
+
+        /// <summary>
+        ///     Gets GPU video BIOS information
+        /// </summary>
+        public VideoBIOS Bios
+        {
+            get => new VideoBIOS(
+                GPUApi.GetVBIOSRevision(Handle),
+                (int) GPUApi.GetVBIOSOEMRevision(Handle),
+                GPUApi.GetVBIOSVersionString(Handle)
+            );
+        }
+
+        /// <summary>
+        ///     Gets the board information
+        /// </summary>
+        public BoardInfo Board
+        {
+            get
+            {
+                try
+                {
+                    return GPUApi.GetBoardInfo(Handle);
+                }
+                catch (NVIDIAApiException ex)
+                {
+                    if (ex.Status == Status.NotSupported)
+                    {
+                        return default;
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Gets GPU boost clock frequencies
+        /// </summary>
+        public IClockFrequencies BoostClockFrequencies
+        {
+            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.BoostClock));
+        }
+
+        /// <summary>
+        ///     Gets GPU bus information
+        /// </summary>
+        public GPUBusInformation BusInformation { get; }
+
+        /// <summary>
+        ///     Gets GPU coolers information
+        /// </summary>
+        public GPUCoolerInformation CoolerInformation { get; }
+
+        /// <summary>
+        ///     Gets corresponding logical GPU
+        /// </summary>
+        public LogicalGPU CorrespondingLogicalGPU
+        {
+            get => new LogicalGPU(GPUApi.GetLogicalGPUFromPhysicalGPU(Handle));
+        }
+
+        /// <summary>
+        ///     Gets GPU current clock frequencies
+        /// </summary>
+        public IClockFrequencies CurrentClockFrequencies
+        {
+            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.CurrentClock));
+        }
+
+        /// <summary>
+        ///     Gets the driver model number for this GPU
+        /// </summary>
+        public uint DriverModel
+        {
+            get => GPUApi.GetDriverModel(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU ECC memory information
+        /// </summary>
+        public ECCMemoryInformation ECCMemoryInformation { get; }
+
+        /// <summary>
+        ///     Gets the chipset foundry
+        /// </summary>
+        public GPUFoundry Foundry
+        {
+            get => GPUApi.GetFoundry(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU full name
+        /// </summary>
+        public string FullName
+        {
+            get => GPUApi.GetFullName(Handle);
+        }
+
+        /// <summary>
+        ///     Gets the GPU identification number
+        /// </summary>
+        public uint GPUId
+        {
+            get => GPUApi.GetGPUIDFromPhysicalGPU(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU type
+        /// </summary>
+        public GPUType GPUType
+        {
+            get => GPUApi.GetGPUType(Handle);
+        }
+
+        /// <summary>
+        ///     Gets the physical GPU handle
+        /// </summary>
+        public PhysicalGPUHandle Handle { get; }
+
+        /// <summary>
+        ///     Gets a boolean value indicating the Quadro line of products
+        /// </summary>
+        public bool IsQuadro
+        {
+            get => GPUApi.GetQuadroStatus(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU memory and RAM information as well as frame-buffer information
+        /// </summary>
+        public GPUMemoryInformation MemoryInformation { get; }
+
+        /// <summary>
+        ///     Gets GPU performance control status and configurations
+        /// </summary>
+        public GPUPerformanceControl PerformanceControl { get; }
+
+
+        /// <summary>
+        ///     Gets the GPU performance states information and configurations
+        /// </summary>
+        public GPUPerformanceStatesInformation PerformanceStatesInfo
+        {
+            get
+            {
+                var performanceStates20Info = GPUApi.GetPerformanceStates20(Handle);
+                var currentPerformanceState = GPUApi.GetCurrentPerformanceState(Handle);
+                PrivatePCIeInfoV2? pcieInformation = null;
+
+                if (BusInformation.BusType == GPUBusType.PCIExpress)
+                {
+                    try
+                    {
+                        pcieInformation = GPUApi.GetPCIEInfo(Handle);
+                    }
+                    catch
+                    {
+                        // ignore
+                    }
+                }
+
+                return new GPUPerformanceStatesInformation(performanceStates20Info, currentPerformanceState,
+                    pcieInformation);
+            }
+        }
+
+        /// <summary>
+        ///     Gets GPU coolers information
+        /// </summary>
+        public GPUPowerTopologyInformation PowerTopologyInformation { get; }
+
+        /// <summary>
+        ///     Gets GPU system type
+        /// </summary>
+        public SystemType SystemType
+        {
+            get => GPUApi.GetSystemType(Handle);
+        }
+
+        /// <summary>
+        ///     Gets GPU thermal sensors information
+        /// </summary>
+        public GPUThermalInformation ThermalInformation { get; }
+
+        /// <summary>
+        ///     Gets the GPU utilization domains and usages
+        /// </summary>
+        public GPUUsageInformation UsageInformation { get; }
+
+        /// <inheritdoc />
+        public bool Equals(PhysicalGPU other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return Handle.Equals(other.Handle);
+        }
+
+        /// <summary>
+        ///     Gets the corresponding <see cref="PhysicalGPU" /> instance from a GPU identification number.
+        /// </summary>
+        /// <param name="gpuId">The GPU identification number.</param>
+        /// <returns>An instance of <see cref="PhysicalGPU" /> or <see langword="null" /> if operation failed.</returns>
+        public static PhysicalGPU FromGPUId(uint gpuId)
+        {
+            var handle = GPUApi.GetPhysicalGPUFromGPUID(gpuId);
+
+            if (handle.IsNull)
+            {
+                return null;
+            }
+
+            return new PhysicalGPU(handle);
+        }
+
+        /// <summary>
+        ///     Gets all physical GPUs
+        /// </summary>
+        /// <returns>An array of physical GPUs</returns>
+        public static PhysicalGPU[] GetPhysicalGPUs()
+        {
+            return GPUApi.EnumPhysicalGPUs().Select(handle => new PhysicalGPU(handle)).ToArray();
+        }
+
+        /// <summary>
+        ///     Gets all physical GPUs in TCC state
+        /// </summary>
+        /// <returns>An array of physical GPUs</returns>
+        public static PhysicalGPU[] GetTCCPhysicalGPUs()
+        {
+            return GPUApi.EnumTCCPhysicalGPUs().Select(handle => new PhysicalGPU(handle)).ToArray();
+        }
+
+        /// <summary>
+        ///     Checks for equality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are equal, otherwise false</returns>
+        public static bool operator ==(PhysicalGPU left, PhysicalGPU right)
+        {
+            return Equals(left, right) || left?.Equals(right) == true;
+        }
+
+        /// <summary>
+        ///     Checks for inequality between two objects of same type
+        /// </summary>
+        /// <param name="left">The first object</param>
+        /// <param name="right">The second object</param>
+        /// <returns>true, if both objects are not equal, otherwise false</returns>
+        public static bool operator !=(PhysicalGPU left, PhysicalGPU right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return Equals(obj as PhysicalGPU);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Handle.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return FullName;
+        }
+
+        /// <summary>
+        ///     Get a list of all active applications for this GPU
+        /// </summary>
+        /// <returns>An array of processes</returns>
+        public Process[] GetActiveApplications()
+        {
+            return GPUApi.QueryActiveApps(Handle).Select(app => Process.GetProcessById(app.ProcessId)).ToArray();
+        }
+
+        /// <summary>
+        ///     Get a list of all connected display devices on this GPU
+        /// </summary>
+        /// <param name="flags">ConnectedIdsFlag flag</param>
+        /// <returns>An array of display devices</returns>
+        public DisplayDevice[] GetConnectedDisplayDevices(ConnectedIdsFlag flags)
+        {
+            return GPUApi.GetConnectedDisplayIds(Handle, flags).Select(display => new DisplayDevice(display)).ToArray();
+        }
+
+        /// <summary>
+        ///     Get the display device connected to a specific GPU output
+        /// </summary>
+        /// <param name="output">The GPU output to get connected display device for</param>
+        /// <returns>DisplayDevice connected to the specified GPU output</returns>
+        public DisplayDevice GetDisplayDeviceByOutput(GPUOutput output)
+        {
+            return new DisplayDevice(GPUApi.GetDisplayIdFromGPUAndOutputId(Handle, output.OutputId));
+        }
+
+        /// <summary>
+        ///     Get a list of all display devices on any possible output
+        /// </summary>
+        /// <returns>An array of display devices</returns>
+        public DisplayDevice[] GetDisplayDevices()
+        {
+            return GPUApi.GetAllDisplayIds(Handle).Select(display => new DisplayDevice(display)).ToArray();
+        }
+
+        /// <summary>
+        ///     Reads EDID data of an output
+        /// </summary>
+        /// <param name="output">The GPU output to read EDID information for</param>
+        /// <returns>A byte array containing EDID data</returns>
+        public byte[] ReadEDIDData(GPUOutput output)
+        {
+            try
+            {
+                var data = new byte[0];
+                var identification = 0;
+                var totalSize = EDIDV3.MaxDataSize;
+
+                for (var offset = 0; offset < totalSize; offset += EDIDV3.MaxDataSize)
+                {
+                    var edid = GPUApi.GetEDID(Handle, output.OutputId, offset, identification);
+                    identification = edid.Identification;
+                    totalSize = edid.TotalSize;
+
+                    var edidData = edid.Data;
+                    Array.Resize(ref data, data.Length + edidData.Length);
+                    Array.Copy(edidData, 0, data, data.Length - edidData.Length, edidData.Length);
+                }
+
+                return data;
+            }
+            catch (NVIDIAApiException ex)
+            {
+                if (ex.Status == Status.IncompatibleStructureVersion)
+                {
+                    return GPUApi.GetEDID(Handle, output.OutputId).Data;
+                }
+
+                throw;
+            }
+        }
+
+        /// <summary>
+        ///     Reads data from the I2C bus
+        /// </summary>
+        /// <param name="i2cInfo">Information required to read from the I2C bus.</param>
+        /// <returns>The returned payload.</returns>
+        // ReSharper disable once InconsistentNaming
+        public byte[] ReadI2C(II2CInfo i2cInfo)
+        {
+            GPUApi.I2CRead(Handle, ref i2cInfo);
+
+            return i2cInfo.Data;
+        }
+
+        /// <summary>
+        ///     Validates a set of GPU outputs to check if they can be active simultaneously
+        /// </summary>
+        /// <param name="outputs">GPU outputs to check</param>
+        /// <returns>true if all specified outputs can be active simultaneously, otherwise false</returns>
+        public bool ValidateOutputCombination(GPUOutput[] outputs)
+        {
+            var gpuOutpudIds =
+                outputs.Aggregate(OutputId.Invalid, (current, gpuOutput) => current | gpuOutput.OutputId);
+
+            return GPUApi.ValidateOutputCombination(Handle, gpuOutpudIds);
+        }
+
+        /// <summary>
+        ///     Writes EDID data of an output
+        /// </summary>
+        /// <param name="output">The GPU output to write EDID information for</param>
+        /// <param name="edidData">A byte array containing EDID data</param>
+        public void WriteEDIDData(GPUOutput output, byte[] edidData)
+        {
+            WriteEDIDData((uint) output.OutputId, edidData);
+        }
+
+        /// <summary>
+        ///     Writes EDID data of an display
+        /// </summary>
+        /// <param name="display">The display device to write EDID information for</param>
+        /// <param name="edidData">A byte array containing EDID data</param>
+        public void WriteEDIDData(DisplayDevice display, byte[] edidData)
+        {
+            WriteEDIDData(display.DisplayId, edidData);
+        }
+
+        /// <summary>
+        ///     Writes data to the I2C bus
+        /// </summary>
+        /// <param name="i2cInfo">Information required to write to the I2C bus including data payload.</param>
+        // ReSharper disable once InconsistentNaming
+        public void WriteI2C(II2CInfo i2cInfo)
+        {
+            GPUApi.I2CWrite(Handle, i2cInfo);
+        }
+
+        private void WriteEDIDData(uint displayOutputId, byte[] edidData)
+        {
+            try
+            {
+                if (edidData.Length == 0)
+                {
+                    var instance = typeof(EDIDV3).Instantiate<EDIDV3>();
+                    GPUApi.SetEDID(Handle, displayOutputId, instance);
+                }
+
+                for (var offset = 0; offset < edidData.Length; offset += EDIDV3.MaxDataSize)
+                {
+                    var array = new byte[Math.Min(EDIDV3.MaxDataSize, edidData.Length - offset)];
+                    Array.Copy(edidData, offset, array, 0, array.Length);
+                    var instance = EDIDV3.CreateWithData(0, (uint) offset, array, edidData.Length);
+                    GPUApi.SetEDID(Handle, displayOutputId, instance);
+                }
+
+                return;
+            }
+            catch (NVIDIAApiException ex)
+            {
+                if (ex.Status != Status.IncompatibleStructureVersion)
+                {
+                    throw;
+                }
+            }
+            catch (NVIDIANotSupportedException)
+            {
+                // ignore
+            }
+
+            try
+            {
+                if (edidData.Length == 0)
+                {
+                    var instance = typeof(EDIDV2).Instantiate<EDIDV2>();
+                    GPUApi.SetEDID(Handle, displayOutputId, instance);
+                }
+
+                for (var offset = 0; offset < edidData.Length; offset += EDIDV2.MaxDataSize)
+                {
+                    var array = new byte[Math.Min(EDIDV2.MaxDataSize, edidData.Length - offset)];
+                    Array.Copy(edidData, offset, array, 0, array.Length);
+                    GPUApi.SetEDID(Handle, displayOutputId, EDIDV2.CreateWithData(array, edidData.Length));
+                }
+
+                return;
+            }
+            catch (NVIDIAApiException ex)
+            {
+                if (ex.Status != Status.IncompatibleStructureVersion)
+                {
+                    throw;
+                }
+            }
+            catch (NVIDIANotSupportedException)
+            {
+                // ignore
+            }
+
+            GPUApi.SetEDID(Handle, displayOutputId, EDIDV1.CreateWithData(edidData));
+        }
+    }
+}

NvAPIWrapper/GPU/VideoBIOS.cs

@@ -0,0 +1,52 @@
+using System;
+
+namespace NvAPIWrapper.GPU
+{
+    /// <summary>
+    ///     Contains information about the GPU Video BIOS
+    /// </summary>
+    public class VideoBIOS
+    {
+        internal VideoBIOS(uint revision, int oemRevision, string versionString)
+        {
+            Revision = revision;
+            OEMRevision = oemRevision;
+            VersionString = versionString.ToUpper();
+        }
+
+        /// <summary>
+        ///     Gets the the OEM revision of the video BIOS
+        /// </summary>
+        public int OEMRevision { get; }
+
+        /// <summary>
+        ///     Gets the revision of the video BIOS
+        /// </summary>
+        public uint Revision { get; }
+
+        /// <summary>
+        ///     Gets the full video BIOS version string
+        /// </summary>
+        public string VersionString { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return AsVersion().ToString();
+        }
+
+        /// <summary>
+        ///     Returns the video BIOS version as a .Net Version object
+        /// </summary>
+        /// <returns>A Version object representing the video BIOS version</returns>
+        public Version AsVersion()
+        {
+            return new Version(
+                (int) ((Revision >> 28) + ((Revision << 4) >> 28) * 16), // 8 bit little endian
+                (int) (((Revision << 8) >> 28) + ((Revision << 12) >> 28) * 16), // 8 bit little endian
+                (int) ((Revision << 16) >> 16), // 16 bit big endian
+                OEMRevision // 8 bit integer
+            );
+        }
+    }
+}

NvAPIWrapper/NVIDIA.cs

@@ -0,0 +1,81 @@
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Interfaces.General;
+
+namespace NvAPIWrapper
+{
+    /// <summary>
+    ///     .Net friendly version of system and general functions of NVAPI library
+    /// </summary>
+    public static class NVIDIA
+    {
+        /// <summary>
+        ///     Gets information about the system's chipset.
+        /// </summary>
+        public static IChipsetInfo ChipsetInfo
+        {
+            get => GeneralApi.GetChipsetInfo();
+        }
+
+        /// <summary>
+        ///     Gets NVIDIA driver branch version as string
+        /// </summary>
+        public static string DriverBranchVersion
+        {
+            get
+            {
+                GeneralApi.GetDriverAndBranchVersion(out var branchVersion);
+
+                return branchVersion;
+            }
+        }
+
+        /// <summary>
+        ///     Gets NVIDIA driver version
+        /// </summary>
+        public static uint DriverVersion
+        {
+            get => GeneralApi.GetDriverAndBranchVersion(out _);
+        }
+
+        /// <summary>
+        ///     Gets NVAPI interface version as string
+        /// </summary>
+        public static string InterfaceVersionString
+        {
+            get => GeneralApi.GetInterfaceVersionString();
+        }
+
+        /// <summary>
+        ///     Gets the current lid and dock information.
+        /// </summary>
+        public static LidDockParameters LidAndDockParameters
+        {
+            get => GeneralApi.GetLidAndDockInfo();
+        }
+
+        /// <summary>
+        ///     Initializes the NvAPI library (if not already initialized) but always increments the ref-counter.
+        /// </summary>
+        public static void Initialize()
+        {
+            GeneralApi.Initialize();
+        }
+
+        /// <summary>
+        ///     PRIVATE - Requests to restart the display driver
+        /// </summary>
+        public static void RestartDisplayDriver()
+        {
+            GeneralApi.RestartDisplayDriver();
+        }
+
+        /// <summary>
+        ///     Decrements the ref-counter and when it reaches ZERO, unloads NVAPI library.
+        /// </summary>
+        public static void Unload()
+        {
+            GeneralApi.Unload();
+        }
+    }
+}

NvAPIWrapper/Native/Attributes/AcceptsAttribute.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace NvAPIWrapper.Native.Attributes
+{
+    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Delegate)]
+    internal class AcceptsAttribute : Attribute
+    {
+        public AcceptsAttribute(params Type[] types)
+        {
+            Types = types;
+        }
+
+        public Type[] Types { get; set; }
+    }
+}

NvAPIWrapper/Native/Attributes/FunctionIdAttribute.cs

@@ -0,0 +1,16 @@
+using System;
+using NvAPIWrapper.Native.Helpers;
+
+namespace NvAPIWrapper.Native.Attributes
+{
+    [AttributeUsage(AttributeTargets.Delegate)]
+    internal class FunctionIdAttribute : Attribute
+    {
+        public FunctionIdAttribute(FunctionId functionId)
+        {
+            FunctionId = functionId;
+        }
+
+        public FunctionId FunctionId { get; set; }
+    }
+}

NvAPIWrapper/Native/Attributes/StructureVersionAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace NvAPIWrapper.Native.Attributes
+{
+    [AttributeUsage(AttributeTargets.Struct)]
+    internal class StructureVersionAttribute : Attribute
+    {
+        public StructureVersionAttribute()
+        {
+        }
+
+        public StructureVersionAttribute(int versionNumber)
+        {
+            VersionNumber = versionNumber;
+        }
+
+        public int VersionNumber { get; set; }
+    }
+}

NvAPIWrapper/Native/Constants/Display.cs

@@ -0,0 +1,8 @@
+namespace NvAPIWrapper.Native.Constants
+{
+    internal static class Display
+    {
+        public const int AdvancedDisplayHeads = 4;
+        public const int MaxDisplayHeads = 2;
+    }
+}

NvAPIWrapper/Native/Constants/General.cs

@@ -0,0 +1,8 @@
+namespace NvAPIWrapper.Native.Constants
+{
+    internal static class General
+    {
+        public const int BinaryDataMax = 4096;
+        public const int UnicodeStringLength = 2048;
+    }
+}

NvAPIWrapper/Native/Delegates/Display.cs

@@ -0,0 +1,327 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.Display;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+
+// ReSharper disable InconsistentNaming
+
+namespace NvAPIWrapper.Native.Delegates
+{
+    internal static class Display
+    {
+        [FunctionId(FunctionId.NvAPI_CreateDisplayFromUnAttachedDisplay)]
+        public delegate Status NvAPI_CreateDisplayFromUnAttachedDisplay(
+            [In] UnAttachedDisplayHandle display,
+            [Out] out DisplayHandle newDisplay
+        );
+
+        [FunctionId(FunctionId.NvAPI_Disp_ColorControl)]
+        public delegate Status NvAPI_Disp_ColorControl(
+            [In] uint displayId,
+            [In]
+            [Out]
+            [Accepts(
+                typeof(ColorDataV5),
+                typeof(ColorDataV4),
+                typeof(ColorDataV3),
+                typeof(ColorDataV2),
+                typeof(ColorDataV1)
+            )]
+            ValueTypeReference colorData
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_DeleteCustomDisplay)]
+        public delegate Status NvAPI_DISP_DeleteCustomDisplay(
+            [In] [Accepts(typeof(uint))] ValueTypeArray displayIds,
+            [In] uint count,
+            [In] [Accepts(typeof(CustomDisplay))] ValueTypeReference customDisplay
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_EnumCustomDisplay)]
+        public delegate Status NvAPI_DISP_EnumCustomDisplay(
+            [In] uint displayId,
+            [In] uint index,
+            [In] [Accepts(typeof(CustomDisplay))] ValueTypeReference customDisplay
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle)]
+        public delegate Status NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle(
+            [In] [MarshalAs(UnmanagedType.LPStr)] string displayName,
+            [Out] out UnAttachedDisplayHandle display
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetDisplayConfig)]
+        public delegate Status NvAPI_DISP_GetDisplayConfig(
+            [In] [Out] ref uint pathInfoCount,
+            [In] [Accepts(typeof(PathInfoV2), typeof(PathInfoV1))]
+            ValueTypeArray pathInfos
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetDisplayIdByDisplayName)]
+        public delegate Status NvAPI_DISP_GetDisplayIdByDisplayName([In] string displayName, [Out] out uint displayId);
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetGDIPrimaryDisplayId)]
+        public delegate Status NvAPI_DISP_GetGDIPrimaryDisplayId([Out] out uint displayId);
+
+        [FunctionId(FunctionId.NvAPI_Disp_GetHdrCapabilities)]
+        public delegate Status NvAPI_Disp_GetHdrCapabilities(
+            [In] uint displayId,
+            [In] [Out] [Accepts(typeof(HDRCapabilitiesV1))]
+            ValueTypeReference hdrCapabilities
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetMonitorCapabilities)]
+        public delegate Status NvAPI_DISP_GetMonitorCapabilities(
+            [In] uint displayId,
+            [In] [Accepts(typeof(MonitorCapabilities))]
+            ValueTypeReference capabilities
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetMonitorColorCapabilities)]
+        public delegate Status NvAPI_DISP_GetMonitorColorCapabilities(
+            [In] uint displayId,
+            [In] [Accepts(typeof(MonitorColorData))]
+            ValueTypeArray capabilities,
+            [In] [Out] ref uint count
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_GetTiming)]
+        public delegate Status NvAPI_DISP_GetTiming(
+            [In] uint displayId,
+            [In] [Accepts(typeof(TimingInput))] ValueTypeReference timingInput,
+            [In] [Accepts(typeof(Timing))] ValueTypeReference timing
+        );
+
+        [FunctionId(FunctionId.NvAPI_Disp_HdrColorControl)]
+        public delegate Status NvAPI_Disp_HdrColorControl(
+            [In] uint displayId,
+            [In] [Out] [Accepts(typeof(HDRColorDataV2), typeof(HDRColorDataV1))]
+            ValueTypeReference hdrColorData
+        );
+
+        [FunctionId(FunctionId.NvAPI_Disp_InfoFrameControl)]
+        public delegate Status NvAPI_Disp_InfoFrameControl(
+            [In] uint displayId,
+            [In] [Accepts(typeof(InfoFrameData))] ValueTypeReference infoFrameData
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_RevertCustomDisplayTrial)]
+        public delegate Status NvAPI_DISP_RevertCustomDisplayTrial(
+            [In] [Accepts(typeof(uint))] ValueTypeArray displayIds,
+            [In] uint count
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_SaveCustomDisplay)]
+        public delegate Status NvAPI_DISP_SaveCustomDisplay(
+            [In] [Accepts(typeof(uint))] ValueTypeArray displayIds,
+            [In] uint count,
+            [In] uint isThisOutputIdOnly,
+            [In] uint isThisMonitorIdOnly
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_SetDisplayConfig)]
+        public delegate Status NvAPI_DISP_SetDisplayConfig(
+            [In] uint pathInfoCount,
+            [In] [Accepts(typeof(PathInfoV2), typeof(PathInfoV1))]
+            ValueTypeArray pathInfos,
+            [In] DisplayConfigFlags flags
+        );
+
+        [FunctionId(FunctionId.NvAPI_DISP_TryCustomDisplay)]
+        public delegate Status NvAPI_DISP_TryCustomDisplay(
+            [In] [Accepts(typeof(uint))] ValueTypeArray displayIds,
+            [In] uint count,
+            [In] [Accepts(typeof(CustomDisplay))] ValueTypeArray customDisplays
+        );
+
+        [FunctionId(FunctionId.NvAPI_EnumNvidiaDisplayHandle)]
+        public delegate Status NvAPI_EnumNvidiaDisplayHandle(
+            [In] uint enumId,
+            [Out] out DisplayHandle display
+        );
+
+        [FunctionId(FunctionId.NvAPI_EnumNvidiaUnAttachedDisplayHandle)]
+        public delegate Status NvAPI_EnumNvidiaUnAttachedDisplayHandle(
+            [In] uint enumId,
+            [Out] out UnAttachedDisplayHandle display
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetAssociatedDisplayOutputId)]
+        public delegate Status NvAPI_GetAssociatedDisplayOutputId(
+            [In] DisplayHandle display,
+            [Out] out OutputId outputId
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetAssociatedNvidiaDisplayHandle)]
+        public delegate Status NvAPI_GetAssociatedNvidiaDisplayHandle(
+            [In] [MarshalAs(UnmanagedType.LPStr)] string displayName,
+            [Out] out DisplayHandle display
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetAssociatedNvidiaDisplayName)]
+        public delegate Status NvAPI_GetAssociatedNvidiaDisplayName(
+            [In] DisplayHandle display,
+            [Out] out ShortString displayName
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDisplayDriverBuildTitle)]
+        public delegate Status NvAPI_GetDisplayDriverBuildTitle(
+            [In] DisplayHandle displayHandle,
+            [Out] out ShortString name
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDisplayDriverMemoryInfo)]
+        public delegate Status NvAPI_GetDisplayDriverMemoryInfo(
+            [In] DisplayHandle displayHandle,
+            [In]
+            [Accepts(
+                typeof(DisplayDriverMemoryInfoV3),
+                typeof(DisplayDriverMemoryInfoV2),
+                typeof(DisplayDriverMemoryInfoV1)
+            )]
+            ValueTypeReference memoryInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDVCInfo)]
+        public delegate Status NvAPI_GetDVCInfo(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] [Accepts(typeof(PrivateDisplayDVCInfo))]
+            ValueTypeReference dvcInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDVCInfoEx)]
+        public delegate Status NvAPI_GetDVCInfoEx(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] [Accepts(typeof(PrivateDisplayDVCInfoEx))]
+            ValueTypeReference dvcInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetHDMISupportInfo)]
+        public delegate Status NvAPI_GetHDMISupportInfo(
+            [In] DisplayHandle displayHandle,
+            [In] uint displayIdOrOutputId,
+            [In] [Accepts(typeof(HDMISupportInfoV2), typeof(HDMISupportInfoV1))]
+            ValueTypeReference supportInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetHUEInfo)]
+        public delegate Status NvAPI_GetHUEInfo(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] [Accepts(typeof(PrivateDisplayHUEInfo))]
+            ValueTypeReference hueInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetSupportedViews)]
+        public delegate Status NvAPI_GetSupportedViews(
+            [In] DisplayHandle display,
+            [In] [Accepts(typeof(TargetViewMode))] ValueTypeArray viewModes,
+            [Out] [In] ref uint viewCount
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetUnAttachedAssociatedDisplayName)]
+        public delegate Status NvAPI_GetUnAttachedAssociatedDisplayName(
+            [In] UnAttachedDisplayHandle display,
+            [Out] out ShortString displayName
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutCompositionParameter)]
+        public delegate Status NvAPI_GPU_GetScanOutCompositionParameter(
+            [In] uint displayId,
+            [In] ScanOutCompositionParameter parameter,
+            [Out] out ScanOutCompositionParameterValue parameterValue,
+            [Out] out float container
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutConfiguration)]
+        public delegate Status NvAPI_GPU_GetScanOutConfiguration(
+            [In] uint displayId,
+            [In] [Accepts(typeof(Rectangle))] ValueTypeReference desktopRectangle,
+            [In] [Accepts(typeof(Rectangle))] ValueTypeReference scanOutRectangle
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutConfigurationEx)]
+        public delegate Status NvAPI_GPU_GetScanOutConfigurationEx(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutInformationV1))]
+            ValueTypeReference scanOutInformation
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutIntensityState)]
+        public delegate Status NvAPI_GPU_GetScanOutIntensityState(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutIntensityStateV1))]
+            ValueTypeReference scanOutIntensityState
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetScanoutWarpingState)]
+        public delegate Status NvAPI_GPU_GetScanOutWarpingState(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutWarpingStateV1))]
+            ValueTypeReference scanOutWarpingState
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetScanoutCompositionParameter)]
+        public delegate Status NvAPI_GPU_SetScanOutCompositionParameter(
+            [In] uint displayId,
+            [In] ScanOutCompositionParameter parameter,
+            [In] ScanOutCompositionParameterValue parameterValue,
+            [In] ref float container
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetScanoutIntensity)]
+        public delegate Status NvAPI_GPU_SetScanOutIntensity(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutIntensityV2), typeof(ScanOutIntensityV1))]
+            ValueTypeReference scanOutIntensityData,
+            [Out] out int isSticky
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetScanoutWarping)]
+        public delegate Status NvAPI_GPU_SetScanOutWarping(
+            [In] uint displayId,
+            [In] [Accepts(typeof(ScanOutWarpingV1))]
+            ValueTypeReference scanOutWarping,
+            [In] [Out] ref int maximumNumberOfVertices,
+            [Out] out int isSticky
+        );
+
+        [FunctionId(FunctionId.NvAPI_SetDVCLevel)]
+        public delegate Status NvAPI_SetDVCLevel(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] int dvcLevel
+        );
+
+        [FunctionId(FunctionId.NvAPI_SetDVCLevelEx)]
+        public delegate Status NvAPI_SetDVCLevelEx(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] [Accepts(typeof(PrivateDisplayDVCInfoEx))]
+            ValueTypeReference dvcInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_SetHUEAngle)]
+        public delegate Status NvAPI_SetHUEAngle(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId displayId,
+            [In] int hueAngle
+        );
+
+        [FunctionId(FunctionId.NvAPI_SetRefreshRateOverride)]
+        public delegate Status NvAPI_SetRefreshRateOverride(
+            [In] DisplayHandle displayHandle,
+            [In] OutputId outputMask,
+            [In] float refreshRate,
+            [In] uint isDeferred
+        );
+    }
+}

NvAPIWrapper/Native/Delegates/GPU.cs

@@ -0,0 +1,733 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.Display.Structures;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+
+// ReSharper disable InconsistentNaming
+
+namespace NvAPIWrapper.Native.Delegates
+{
+    internal static class GPU
+    {
+        [FunctionId(FunctionId.NvAPI_EnumLogicalGPUs)]
+        public delegate Status NvAPI_EnumLogicalGPUs(
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = LogicalGPUHandle.MaxLogicalGPUs)]
+            LogicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_EnumPhysicalGPUs)]
+        public delegate Status NvAPI_EnumPhysicalGPUs(
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = PhysicalGPUHandle.MaxPhysicalGPUs)]
+            PhysicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_EnumTCCPhysicalGPUs)]
+        public delegate Status NvAPI_EnumTCCPhysicalGPUs(
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = PhysicalGPUHandle.MaxPhysicalGPUs)]
+            PhysicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_GPU_QueryThermalSensors)]
+        public delegate Status NvAPI_GPU_QueryThermalSensors(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateThermalSensorsV2))] [In]
+            ValueTypeReference thermal
+        );
+
+        [FunctionId(FunctionId.NvAPI_GetDriverModel)]
+        public delegate Status NvAPI_GetDriverModel(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint model);
+
+        [FunctionId(FunctionId.NvAPI_GetGPUIDfromPhysicalGPU)]
+        public delegate Status NvAPI_GetGPUIDFromPhysicalGPU(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint gpuId);
+
+        [FunctionId(FunctionId.NvAPI_GetLogicalGPUFromDisplay)]
+        public delegate Status NvAPI_GetLogicalGPUFromDisplay(
+            [In] DisplayHandle displayHandle,
+            [Out] out LogicalGPUHandle gpuHandle);
+
+        [FunctionId(FunctionId.NvAPI_GetLogicalGPUFromPhysicalGPU)]
+        public delegate Status NvAPI_GetLogicalGPUFromPhysicalGPU(
+            [In] PhysicalGPUHandle physicalGPUHandle,
+            [Out] out LogicalGPUHandle logicalGPUHandle);
+
+        [FunctionId(FunctionId.NvAPI_GetPhysicalGPUFromGPUID)]
+        public delegate Status NvAPI_GetPhysicalGPUFromGPUID(
+            [In] uint gpuId,
+            [Out] out PhysicalGPUHandle physicalGpu);
+
+        [FunctionId(FunctionId.NvAPI_GetPhysicalGPUFromUnAttachedDisplay)]
+        public delegate Status NvAPI_GetPhysicalGPUFromUnAttachedDisplay(
+            [In] UnAttachedDisplayHandle displayHandle,
+            [Out] out PhysicalGPUHandle gpuHandle);
+
+        [FunctionId(FunctionId.NvAPI_GetPhysicalGPUsFromDisplay)]
+        public delegate Status NvAPI_GetPhysicalGPUsFromDisplay(
+            [In] DisplayHandle displayHandle,
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = PhysicalGPUHandle.MaxPhysicalGPUs)]
+            PhysicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_GetPhysicalGPUsFromLogicalGPU)]
+        public delegate Status NvAPI_GetPhysicalGPUsFromLogicalGPU(
+            [In] LogicalGPUHandle logicalGPUHandle,
+            [In] [Out] [MarshalAs(UnmanagedType.LPArray, SizeConst = PhysicalGPUHandle.MaxPhysicalGPUs)]
+            PhysicalGPUHandle[]
+                gpuHandles,
+            [Out] out uint gpuCount);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientFanCoolersGetControl)]
+        public delegate Status NvAPI_GPU_ClientFanCoolersGetControl(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateFanCoolersControlV1))] [In]
+            ValueTypeReference control);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientFanCoolersGetInfo)]
+        public delegate Status NvAPI_GPU_ClientFanCoolersGetInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateFanCoolersInfoV1))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientFanCoolersGetStatus)]
+        public delegate Status NvAPI_GPU_ClientFanCoolersGetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateFanCoolersStatusV1))] [In]
+            ValueTypeReference status);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientFanCoolersSetControl)]
+        public delegate Status NvAPI_GPU_ClientFanCoolersSetControl(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateFanCoolersControlV1))] [In]
+            ValueTypeReference control);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumDevicesGetControl)]
+        public delegate Status NvAPI_GPU_ClientIlluminationDevicesGetControl(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationDeviceControlParametersV1))] [In]
+            ValueTypeReference illuminationDeviceControlInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumDevicesGetInfo)]
+        public delegate Status NvAPI_GPU_ClientIlluminationDevicesGetInfo(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationDeviceInfoParametersV1))] [In]
+            ValueTypeReference illuminationDevicesInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumDevicesSetControl)]
+        public delegate Status NvAPI_GPU_ClientIlluminationDevicesSetControl(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationDeviceControlParametersV1))] [In]
+            ValueTypeReference illuminationDeviceControlInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumZonesGetControl)]
+        public delegate Status NvAPI_GPU_ClientIlluminationZonesGetControl(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationZoneControlParametersV1))] [In]
+            ValueTypeReference illuminationZoneControlInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumZonesGetInfo)]
+        public delegate Status NvAPI_GPU_ClientIlluminationZonesGetInfo(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationZoneInfoParametersV1))] [In]
+            ValueTypeReference illuminationZoneInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientIllumZonesSetControl)]
+        public delegate Status NvAPI_GPU_ClientIlluminationZonesSetControl(
+            [In] PhysicalGPUHandle gpu,
+            [Accepts(typeof(IlluminationZoneControlParametersV1))] [In]
+            ValueTypeReference illuminationZoneControlInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientPowerPoliciesGetInfo)]
+        public delegate Status NvAPI_GPU_ClientPowerPoliciesGetInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePowerPoliciesInfoV1))] [In]
+            ValueTypeReference powerInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientPowerPoliciesGetStatus)]
+        public delegate Status NvAPI_GPU_ClientPowerPoliciesGetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePowerPoliciesStatusV1))] [In]
+            ValueTypeReference status);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientPowerPoliciesSetStatus)]
+        public delegate Status NvAPI_GPU_ClientPowerPoliciesSetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePowerPoliciesStatusV1))] [In]
+            ValueTypeReference status);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ClientPowerTopologyGetStatus)]
+        public delegate Status NvAPI_GPU_ClientPowerTopologyGetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePowerTopologiesStatusV1))] [In]
+            ValueTypeReference status);
+
+        [FunctionId(FunctionId.NvAPI_GPU_EnableDynamicPstates)]
+        public delegate Status NvAPI_GPU_EnableDynamicPStates([In] PhysicalGPUHandle physicalGpu);
+
+        [FunctionId(FunctionId.NvAPI_GPU_EnableOverclockedPstates)]
+        public delegate Status NvAPI_GPU_EnableOverclockedPStates([In] PhysicalGPUHandle physicalGpu);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetActiveOutputs)]
+        public delegate Status NvAPI_GPU_GetActiveOutputs(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out OutputId outputMask);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetAGPAperture)]
+        public delegate Status NvAPI_GPU_GetAGPAperture(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint size);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetAllClockFrequencies)]
+        public delegate Status NvAPI_GPU_GetAllClockFrequencies(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(ClockFrequenciesV3), typeof(ClockFrequenciesV2), typeof(ClockFrequenciesV1))]
+            ValueTypeReference nvClocks);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetAllDisplayIds)]
+        public delegate Status NvAPI_GPU_GetAllDisplayIds(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(DisplayIdsV2))] [In] [Out]
+            ValueTypeArray pDisplayIds,
+            [In] [Out] ref uint displayIdCount);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetArchInfo)]
+        public delegate Status NvAPI_GPU_GetArchInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateArchitectInfoV2))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetBoardInfo)]
+        public delegate Status NvAPI_GPU_GetBoardInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] [In] ref BoardInfo info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetBusId)]
+        public delegate Status NvAPI_GPU_GetBusId(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint gpuBusId);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetBusSlotId)]
+        public delegate Status NvAPI_GPU_GetBusSlotId(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint gpuBusSlotId);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetBusType)]
+        public delegate Status NvAPI_GPU_GetBusType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUBusType gpuBusType);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetClockBoostLock)]
+        public delegate Status NvAPI_GPU_GetClockBoostLock(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostLockV2))]
+            ValueTypeReference clockLocks);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetClockBoostMask)]
+        public delegate Status NvAPI_GPU_GetClockBoostMask(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostMasksV1))]
+            ValueTypeReference clockMasks);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetClockBoostRanges)]
+        public delegate Status NvAPI_GPU_GetClockBoostRanges(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostRangesV1))]
+            ValueTypeReference clockRanges);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetClockBoostTable)]
+        public delegate Status NvAPI_GPU_GetClockBoostTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostTableV1))]
+            ValueTypeReference boostTable);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetConnectedDisplayIds)]
+        public delegate Status NvAPI_GPU_GetConnectedDisplayIds(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(DisplayIdsV2))] [In] [Out]
+            ValueTypeArray pDisplayIds,
+            [In] [Out] ref uint displayIdCount,
+            [In] ConnectedIdsFlag flags);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCoolerPolicyTable)]
+        public delegate Status NvAPI_GPU_GetCoolerPolicyTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint index,
+            [In] [Accepts(typeof(PrivateCoolerPolicyTableV1))]
+            ValueTypeReference coolerPolicyTable,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCoolerSettings)]
+        public delegate Status NvAPI_GPU_GetCoolerSettings(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] CoolerTarget coolerIndex,
+            [In] [Accepts(typeof(PrivateCoolerSettingsV1))]
+            ValueTypeReference coolerSettings);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCoreVoltageBoostPercent)]
+        public delegate Status NvAPI_GPU_GetCoreVoltageBoostPercent(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateVoltageBoostPercentV1))]
+            ValueTypeReference voltageBoostPercent);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentAGPRate)]
+        public delegate Status NvAPI_GPU_GetCurrentAGPRate(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint rate);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentFanSpeedLevel)]
+        public delegate Status NvAPI_GPU_GetCurrentFanSpeedLevel(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint fanLevel);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentPCIEDownstreamWidth)]
+        public delegate Status NvAPI_GPU_GetCurrentPCIEDownstreamWidth(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint width);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentPstate)]
+        public delegate Status NvAPI_GPU_GetCurrentPState(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out PerformanceStateId performanceStateId);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentThermalLevel)]
+        public delegate Status NvAPI_GPU_GetCurrentThermalLevel(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint thermalLevel);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetCurrentVoltage)]
+        public delegate Status NvAPI_GPU_GetCurrentVoltage(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateVoltageStatusV1))]
+            ValueTypeReference voltageStatus);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetDynamicPstatesInfoEx)]
+        public delegate Status NvAPI_GPU_GetDynamicPStatesInfoEx(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(DynamicPerformanceStatesInfoV1))]
+            ValueTypeReference performanceStatesInfoEx);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetECCConfigurationInfo)]
+        public delegate Status NvAPI_GPU_GetECCConfigurationInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(ECCConfigurationInfoV1))]
+            ValueTypeReference eccConfigurationInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetECCErrorInfo)]
+        public delegate Status NvAPI_GPU_GetECCErrorInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(ECCErrorInfoV1))] ValueTypeReference eccErrorInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetECCStatusInfo)]
+        public delegate Status NvAPI_GPU_GetECCStatusInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(ECCStatusInfoV1))]
+            ValueTypeReference eccStatusInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetEDID)]
+        public delegate Status NvAPI_GPU_GetEDID(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] OutputId outputId,
+            [Accepts(typeof(EDIDV3), typeof(EDIDV2), typeof(EDIDV1))] [In]
+            ValueTypeReference edid);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetFBWidthAndLocation)]
+        public delegate Status NvAPI_GPU_GetFBWidthAndLocation(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint width,
+            [Out] out uint location);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetFoundry)]
+        public delegate Status NvAPI_GPU_GetFoundry(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUFoundry pFoundry);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetFullName)]
+        public delegate Status NvAPI_GPU_GetFullName(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out ShortString name);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetGpuCoreCount)]
+        public delegate Status NvAPI_GPU_GetGpuCoreCount(
+            [In] PhysicalGPUHandle gpuHandle,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetGPUType)]
+        public delegate Status NvAPI_GPU_GetGPUType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUType gpuType);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetIllumination)]
+        public delegate Status NvAPI_GPU_GetIllumination(
+            [Accepts(typeof(GetIlluminationParameterV1))] [In]
+            ValueTypeReference illuminationInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetIRQ)]
+        public delegate Status NvAPI_GPU_GetIRQ(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint gpuIRQ);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetLogicalFBWidthAndLocation)]
+        public delegate Status NvAPI_GPU_GetLogicalFBWidthAndLocation(
+            [In] LogicalGPUHandle logicalGpu,
+            [Out] out uint width,
+            [Out] out uint location);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetMemoryInfo)]
+        public delegate Status NvAPI_GPU_GetMemoryInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In]
+            [Accepts(typeof(DisplayDriverMemoryInfoV3), typeof(DisplayDriverMemoryInfoV2),
+                typeof(DisplayDriverMemoryInfoV1))]
+            ValueTypeReference memoryInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetOutputType)]
+        public delegate Status NvAPI_GPU_GetOutputType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint outputId,
+            [Out] out OutputType outputType);
+
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPartitionCount)]
+        public delegate Status NvAPI_GPU_GetPartitionCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPCIEInfo)]
+        public delegate Status NvAPI_GPU_GetPCIEInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivatePCIeInfoV2))] [In]
+            ValueTypeReference pcieInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPCIIdentifiers)]
+        public delegate Status NvAPI_GPU_GetPCIIdentifiers(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint deviceId,
+            [Out] out uint subSystemId,
+            [Out] out uint revisionId,
+            [Out] out uint extDeviceId);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPerfDecreaseInfo)]
+        public delegate Status NvAPI_GPU_GetPerfDecreaseInfo(
+            [In] PhysicalGPUHandle gpu,
+            [Out] out PerformanceDecreaseReason performanceDecreaseReason);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPhysicalFrameBufferSize)]
+        public delegate Status NvAPI_GPU_GetPhysicalFrameBufferSize(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint size);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPstates20)]
+        public delegate Status NvAPI_GPU_GetPStates20(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(
+                typeof(PerformanceStates20InfoV3),
+                typeof(PerformanceStates20InfoV2),
+                typeof(PerformanceStates20InfoV1)
+            )]
+            [In]
+            ValueTypeReference performanceStatesInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetPstatesInfoEx)]
+        public delegate Status NvAPI_GPU_GetPStatesInfoEx(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(
+                typeof(PerformanceStatesInfoV3),
+                typeof(PerformanceStatesInfoV2),
+                typeof(PerformanceStatesInfoV1)
+            )]
+            [In]
+            ValueTypeReference performanceStatesInfo,
+            [In] GetPerformanceStatesInfoFlags flags);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetQuadroStatus)]
+        public delegate Status NvAPI_GPU_GetQuadroStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint isQuadro);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetRamBankCount)]
+        public delegate Status NvAPI_GPU_GetRamBankCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetRamBusWidth)]
+        public delegate Status NvAPI_GPU_GetRamBusWidth(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint busWidth);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetRamMaker)]
+        public delegate Status NvAPI_GPU_GetRamMaker(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUMemoryMaker maker);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetRamType)]
+        public delegate Status NvAPI_GPU_GetRamType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out GPUMemoryType type);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetROPCount)]
+        public delegate Status NvAPI_GPU_GetROPCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetShaderPipeCount)]
+        public delegate Status NvAPI_GPU_GetShaderPipeCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetShaderSubPipeCount)]
+        public delegate Status NvAPI_GPU_GetShaderSubPipeCount(
+            [In] PhysicalGPUHandle gpuHandle,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetShortName)]
+        public delegate Status NvAPI_GPU_GetShortName(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out ShortString name);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetSystemType)]
+        public delegate Status NvAPI_GPU_GetSystemType(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out SystemType systemType);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetTachReading)]
+        public delegate Status NvAPI_GPU_GetTachReading(
+            [In] PhysicalGPUHandle gpuHandle,
+            [Out] out uint value);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetThermalPoliciesInfo)]
+        public delegate Status NvAPI_GPU_GetThermalPoliciesInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateThermalPoliciesInfoV2))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetThermalPoliciesStatus)]
+        public delegate Status NvAPI_GPU_GetThermalPoliciesStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateThermalPoliciesStatusV2))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetThermalSettings)]
+        public delegate Status NvAPI_GPU_GetThermalSettings(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] ThermalSettingsTarget sensorIndex,
+            [In] [Accepts(typeof(ThermalSettingsV2), typeof(ThermalSettingsV1))]
+            ValueTypeReference thermalSettings);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetTotalSMCount)]
+        public delegate Status NvAPI_GPU_GetTotalSMCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetTotalSPCount)]
+        public delegate Status NvAPI_GPU_GetTotalSPCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetTotalTPCCount)]
+        public delegate Status NvAPI_GPU_GetTotalTPCCount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetUsages)]
+        public delegate Status NvAPI_GPU_GetUsages(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateUsagesInfoV1))]
+            ValueTypeReference usageInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVbiosOEMRevision)]
+        public delegate Status NvAPI_GPU_GetVbiosOEMRevision(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint biosOEMRevision);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVbiosRevision)]
+        public delegate Status NvAPI_GPU_GetVbiosRevision(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint biosRevision);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVbiosVersionString)]
+        public delegate Status NvAPI_GPU_GetVbiosVersionString(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out ShortString biosVersion);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVFPCurve)]
+        public delegate Status NvAPI_GPU_GetVFPCurve(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateVFPCurveV1))]
+            ValueTypeReference vfpCurve);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVirtualFrameBufferSize)]
+        public delegate Status NvAPI_GPU_GetVirtualFrameBufferSize(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint size);
+
+        [FunctionId(FunctionId.NvAPI_GPU_GetVPECount)]
+        public delegate Status NvAPI_GPU_GetVPECount(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Out] out uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_PerfPoliciesGetInfo)]
+        public delegate Status NvAPI_GPU_PerfPoliciesGetInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivatePerformanceInfoV1))]
+            ValueTypeReference performanceInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_PerfPoliciesGetStatus)]
+        public delegate Status NvAPI_GPU_PerfPoliciesGetStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivatePerformanceStatusV1))]
+            ValueTypeReference performanceStatus);
+
+        [FunctionId(FunctionId.NvAPI_GPU_QueryActiveApps)]
+        public delegate Status NvAPI_GPU_QueryActiveApps(
+            [In] PhysicalGPUHandle gpu,
+            [In] [Accepts(typeof(PrivateActiveApplicationV2))]
+            ValueTypeArray applications,
+            [In] [Out] ref uint numberOfApplications
+        );
+
+
+        [FunctionId(FunctionId.NvAPI_GPU_QueryIlluminationSupport)]
+        public delegate Status NvAPI_GPU_QueryIlluminationSupport(
+            [Accepts(typeof(QueryIlluminationSupportParameterV1))] [In]
+            ValueTypeReference illuminationSupportInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ResetECCErrorInfo)]
+        public delegate Status NvAPI_GPU_ResetECCErrorInfo(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] byte resetCurrent,
+            [In] byte resetAggregated
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_RestoreCoolerPolicyTable)]
+        public delegate Status NvAPI_GPU_RestoreCoolerPolicyTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint[] indexes,
+            [In] uint indexesCount,
+            [In] CoolerPolicy policy);
+
+        [FunctionId(FunctionId.NvAPI_GPU_RestoreCoolerSettings)]
+        public delegate Status NvAPI_GPU_RestoreCoolerSettings(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint[] indexes,
+            [In] uint indexesCount);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetClockBoostLock)]
+        public delegate Status NvAPI_GPU_SetClockBoostLock(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostLockV2))]
+            ValueTypeReference clockLocks);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetClockBoostTable)]
+        public delegate Status NvAPI_GPU_SetClockBoostTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateClockBoostTableV1))]
+            ValueTypeReference boostTable);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetCoolerLevels)]
+        public delegate Status NvAPI_GPU_SetCoolerLevels(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint index,
+            [In] [Accepts(typeof(PrivateCoolerLevelsV1))]
+            ValueTypeReference coolerLevels,
+            [In] uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetCoolerPolicyTable)]
+        public delegate Status NvAPI_GPU_SetCoolerPolicyTable(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint index,
+            [In] [Accepts(typeof(PrivateCoolerPolicyTableV1))]
+            ValueTypeReference coolerLevels,
+            [In] uint count);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetCoreVoltageBoostPercent)]
+        public delegate Status NvAPI_GPU_SetCoreVoltageBoostPercent(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(PrivateVoltageBoostPercentV1))]
+            ValueTypeReference voltageBoostPercent);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetECCConfiguration)]
+        public delegate Status NvAPI_GPU_SetECCConfiguration(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] byte isEnable,
+            [In] byte isEnableImmediately
+        );
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetEDID)]
+        public delegate Status NvAPI_GPU_SetEDID(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] uint outputId,
+            [Accepts(typeof(EDIDV3), typeof(EDIDV2), typeof(EDIDV1))] [In]
+            ValueTypeReference edid);
+
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetIllumination)]
+        public delegate Status NvAPI_GPU_SetIllumination(
+            [Accepts(typeof(SetIlluminationParameterV1))] [In]
+            ValueTypeReference illuminationInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetPstates20)]
+        public delegate Status NvAPI_GPU_SetPStates20(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PerformanceStates20InfoV3), typeof(PerformanceStates20InfoV2),
+                typeof(PerformanceStates20InfoV1))]
+            [In]
+            ValueTypeReference performanceStatesInfo);
+
+        [FunctionId(FunctionId.NvAPI_GPU_SetThermalPoliciesStatus)]
+        public delegate Status NvAPI_GPU_SetThermalPoliciesStatus(
+            [In] PhysicalGPUHandle physicalGpu,
+            [Accepts(typeof(PrivateThermalPoliciesStatusV2))] [In]
+            ValueTypeReference info);
+
+        [FunctionId(FunctionId.NvAPI_GPU_ValidateOutputCombination)]
+        public delegate Status NvAPI_GPU_ValidateOutputCombination(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] OutputId outputMask);
+
+        [FunctionId(FunctionId.NvAPI_I2CRead)]
+        public delegate Status NvAPI_I2CRead(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(I2CInfoV3), typeof(I2CInfoV2))] ValueTypeReference i2cInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_I2CWrite)]
+        public delegate Status NvAPI_I2CWrite(
+            [In] PhysicalGPUHandle physicalGpu,
+            [In] [Accepts(typeof(I2CInfoV3), typeof(I2CInfoV2))] ValueTypeReference i2cInfo
+        );
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetDisplayIdFromGpuAndOutputId)]
+        public delegate Status NvAPI_SYS_GetDisplayIdFromGpuAndOutputId(
+            [In] PhysicalGPUHandle gpu,
+            [In] OutputId outputId,
+            [Out] out uint displayId);
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetGpuAndOutputIdFromDisplayId)]
+        public delegate Status NvAPI_SYS_GetGpuAndOutputIdFromDisplayId(
+            [In] uint displayId,
+            [Out] out PhysicalGPUHandle gpu,
+            [Out] out OutputId outputId);
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetPhysicalGpuFromDisplayId)]
+        public delegate Status NvAPI_SYS_GetPhysicalGpuFromDisplayId(
+            [In] uint displayId,
+            [Out] out PhysicalGPUHandle gpu);
+    }
+}

NvAPIWrapper/Native/Delegates/General.cs

@@ -0,0 +1,43 @@
+using System.Runtime.InteropServices;
+using NvAPIWrapper.Native.Attributes;
+using NvAPIWrapper.Native.General;
+using NvAPIWrapper.Native.General.Structures;
+using NvAPIWrapper.Native.Helpers;
+using NvAPIWrapper.Native.Helpers.Structures;
+
+// ReSharper disable InconsistentNaming
+
+namespace NvAPIWrapper.Native.Delegates
+{
+    internal static class General
+    {
+        [FunctionId(FunctionId.NvAPI_GetErrorMessage)]
+        public delegate Status NvAPI_GetErrorMessage([In] Status status, out ShortString message);
+
+        [FunctionId(FunctionId.NvAPI_GetInterfaceVersionString)]
+        public delegate Status NvAPI_GetInterfaceVersionString(out ShortString version);
+
+        [FunctionId(FunctionId.NvAPI_Initialize)]
+        public delegate Status NvAPI_Initialize();
+
+
+        [FunctionId(FunctionId.NvAPI_RestartDisplayDriver)]
+        public delegate Status NvAPI_RestartDisplayDriver();
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetChipSetInfo)]
+        public delegate Status NvAPI_SYS_GetChipSetInfo(
+            [In] [Accepts(typeof(ChipsetInfoV4), typeof(ChipsetInfoV3), typeof(ChipsetInfoV2), typeof(ChipsetInfoV1))]
+            ValueTypeReference chipsetInfo);
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetDriverAndBranchVersion)]
+        public delegate Status NvAPI_SYS_GetDriverAndBranchVersion(
+            out uint driverVersion,
+            out ShortString buildBranchString);
+
+        [FunctionId(FunctionId.NvAPI_SYS_GetLidAndDockInfo)]
+        public delegate Status NvAPI_SYS_GetLidAndDockInfo([In] [Out] ref LidDockParameters lidAndDock);
+
+        [FunctionId(FunctionId.NvAPI_Unload)]
+        public delegate Status NvAPI_Unload();
+    }
+}

NvAPIWrapper/Native/Display/ColorDataColorimetry.cs

@@ -0,0 +1,74 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for color data color space
+    /// </summary>
+    public enum ColorDataColorimetry : uint
+    {
+        /// <summary>
+        ///     RGB color space
+        /// </summary>
+        RGB = 0,
+
+        /// <summary>
+        ///     YCC601 color space
+        /// </summary>
+        YCC601,
+
+        /// <summary>
+        ///     YCC709 color space
+        /// </summary>
+        YCC709,
+
+        /// <summary>
+        ///     XVYCC601 color space
+        /// </summary>
+        XVYCC601,
+
+        /// <summary>
+        ///     XVYCC709 color space
+        /// </summary>
+        XVYCC709,
+
+        /// <summary>
+        ///     SYCC601 color space
+        /// </summary>
+        SYCC601,
+
+        /// <summary>
+        ///     ADOBEYCC601 color space
+        /// </summary>
+        ADOBEYCC601,
+
+        /// <summary>
+        ///     ADOBERGB color space
+        /// </summary>
+        ADOBERGB,
+
+        /// <summary>
+        ///     BT2020RGB color space
+        /// </summary>
+        BT2020RGB,
+
+        /// <summary>
+        ///     BT2020YCC color space
+        /// </summary>
+        BT2020YCC,
+
+        /// <summary>
+        ///     BT2020cYCC color space
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        BT2020cYCC,
+
+        /// <summary>
+        ///     Default color space
+        /// </summary>
+        Default = 0xFE,
+
+        /// <summary>
+        ///     Automatically select color space
+        /// </summary>
+        Auto = 0xFF
+    }
+}

NvAPIWrapper/Native/Display/ColorDataCommand.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the color data command
+    /// </summary>
+    public enum ColorDataCommand : uint
+    {
+        /// <summary>
+        ///     Get the current color data
+        /// </summary>
+        Get = 1,
+
+        /// <summary>
+        ///     Set the current color data
+        /// </summary>
+        Set,
+
+        /// <summary>
+        ///     Check if the passed color data is supported
+        /// </summary>
+        IsSupportedColor,
+
+        /// <summary>
+        ///     Get the default color data
+        /// </summary>
+        GetDefault
+    }
+}

NvAPIWrapper/Native/Display/ColorDataDepth.cs

@@ -0,0 +1,38 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the color data depth
+    /// </summary>
+    public enum ColorDataDepth : uint
+    {
+        /// <summary>
+        ///     Default color depth meaning that the current setting should be kept
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        ///     6bit per color depth
+        /// </summary>
+        BPC6 = 1,
+
+        /// <summary>
+        ///     8bit per color depth
+        /// </summary>
+        BPC8 = 2,
+
+        /// <summary>
+        ///     10bit per color depth
+        /// </summary>
+        BPC10 = 3,
+
+        /// <summary>
+        ///     12bit per color depth
+        /// </summary>
+        BPC12 = 4,
+
+        /// <summary>
+        ///     16bit per color depth
+        /// </summary>
+        BPC16 = 5
+    }
+}

NvAPIWrapper/Native/Display/ColorDataDesktopDepth.cs

@@ -0,0 +1,38 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the color data desktop color depth
+    /// </summary>
+    public enum ColorDataDesktopDepth : uint
+    {
+        /// <summary>
+        ///     Default color depth meaning that the current setting should be kept
+        /// </summary>
+        Default = 0x0,
+
+        /// <summary>
+        ///     8bit per integer color component
+        /// </summary>
+        BPC8 = 0x1,
+
+        /// <summary>
+        ///     10bit integer per color component
+        /// </summary>
+        BPC10 = 0x2,
+
+        /// <summary>
+        ///     16bit float per color component
+        /// </summary>
+        BPC16Float = 0x3,
+
+        /// <summary>
+        ///     16bit float per color component wide color gamut
+        /// </summary>
+        BPC16FloatWcg = 0x4,
+
+        /// <summary>
+        ///     16bit float per color component HDR
+        /// </summary>
+        BPC16FloatHDR = 0x5
+    }
+}

NvAPIWrapper/Native/Display/ColorDataDynamicRange.cs

@@ -0,0 +1,23 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for color data dynamic range
+    /// </summary>
+    public enum ColorDataDynamicRange : uint
+    {
+        /// <summary>
+        ///     VESA standard progress signal
+        /// </summary>
+        VESA = 0,
+
+        /// <summary>
+        ///     CEA interlaced signal
+        /// </summary>
+        CEA,
+
+        /// <summary>
+        ///     Automatically select the best value
+        /// </summary>
+        Auto
+    }
+}

NvAPIWrapper/Native/Display/ColorDataFormat.cs

@@ -0,0 +1,38 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible color data color format values
+    /// </summary>
+    public enum ColorDataFormat : uint
+    {
+        /// <summary>
+        ///     RGB color format
+        /// </summary>
+        RGB = 0,
+
+        /// <summary>
+        ///     YUV422 color format
+        /// </summary>
+        YUV422,
+
+        /// <summary>
+        ///     YUV444 color format
+        /// </summary>
+        YUV444,
+
+        /// <summary>
+        ///     YUV420 color format
+        /// </summary>
+        YUV420,
+
+        /// <summary>
+        ///     Default color format
+        /// </summary>
+        Default = 0xFE,
+
+        /// <summary>
+        ///     Automatically select the best color format
+        /// </summary>
+        Auto = 0xFF
+    }
+}

NvAPIWrapper/Native/Display/ColorDataHDRCommand.cs

@@ -0,0 +1,18 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the HDR color data command
+    /// </summary>
+    public enum ColorDataHDRCommand : uint
+    {
+        /// <summary>
+        ///     Get the current HDR color data
+        /// </summary>
+        Get = 0,
+
+        /// <summary>
+        ///     Set the current HDR color data
+        /// </summary>
+        Set = 1
+    }
+}

NvAPIWrapper/Native/Display/ColorDataHDRMode.cs

@@ -0,0 +1,61 @@
+using System;
+
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible color data HDR modes
+    /// </summary>
+    public enum ColorDataHDRMode : uint
+    {
+        /// <summary>
+        ///     Turn off HDR.
+        /// </summary>
+        Off = 0,
+
+        /// <summary>
+        ///     Source: CCCS [a.k.a FP16 scRGB, linear, sRGB primaries, [-65504,0, 65504] range, RGB(1,1,1) = 80nits]
+        ///     Output: UHDA HDR [a.k.a HDR10, RGB/YCC 10/12bpc ST2084(PQ) EOTF RGB(1,1,1) = 10000 nits, Rec2020 color primaries,
+        ///     ST2086 static HDR metadata].
+        ///     This is the only supported production HDR mode.
+        /// </summary>
+        UHDA = 2,
+
+        /// <summary>
+        ///     Source: CCCS (a.k.a FP16 scRGB)
+        ///     Output: EDR (Extended Dynamic Range) - HDR content is tone-mapped and gamut mapped to output on regular SDR display
+        ///     set to max luminance ( ~300 nits ).
+        /// </summary>
+        [Obsolete("Do not use! Internal test mode only, to be removed.", false)]
+        EDR = 3,
+
+        /// <summary>
+        ///     Source: any
+        ///     Output: SDR (Standard Dynamic Range), we continuously send SDR EOTF InfoFrame signaling, HDMI compliance testing.
+        /// </summary>
+        [Obsolete("Do not use! Internal test mode only, to be removed.", false)]
+        SDR = 4,
+
+        /// <summary>
+        ///     Source: HDR10 RGB 10bpc
+        ///     Output: HDR10 RGB 10 colorDepth - signal UHDA HDR mode (PQ + Rec2020) to the sink but send source pixel values
+        ///     unmodified (no PQ or Rec2020 conversions) - assumes source is already in HDR10 format.
+        /// </summary>
+        [Obsolete("Experimental mode only, not for production!", false)]
+        UHDAPassthrough = 5,
+
+        /// <summary>
+        ///     Source: CCCS (a.k.a FP16 scRGB)
+        ///     Output: notebook HDR
+        /// </summary>
+        [Obsolete("Do not use! Internal test mode only, to be removed.", false)]
+        UHDANB = 6,
+
+        /// <summary>
+        ///     Source: RGB8 Dolby Vision encoded (12 colorDepth YCbCr422 packed into RGB8)
+        ///     Output: Dolby Vision encoded : Application is to encoded frames in DV format and embed DV dynamic metadata as
+        ///     described in Dolby Vision specification.
+        /// </summary>
+        [Obsolete("Experimental mode only, not for production!", false)]
+        DolbyVision = 7
+    }
+}

NvAPIWrapper/Native/Display/ColorDataSelectionPolicy.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Possible values for the color data selection policy
+    /// </summary>
+    public enum ColorDataSelectionPolicy : uint
+    {
+        /// <summary>
+        ///     Application or the Nvidia Control Panel user configuration are used to decide the best color format
+        /// </summary>
+        User = 0,
+
+        /// <summary>
+        ///     Driver or the Operating System decides the best color format
+        /// </summary>
+        BestQuality = 1,
+
+        /// <summary>
+        ///     Default value, <see cref="BestQuality" />
+        /// </summary>
+        Default = BestQuality,
+
+        /// <summary>
+        ///     Unknown policy
+        /// </summary>
+        Unknown = 0xFF
+    }
+}

NvAPIWrapper/Native/Display/ColorFormat.cs

@@ -0,0 +1,33 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Possible color formats
+    /// </summary>
+    public enum ColorFormat
+    {
+        /// <summary>
+        ///     Unknown, driver will choose one automatically.
+        /// </summary>
+        Unknown = 0,
+
+        /// <summary>
+        ///     8bpp mode
+        /// </summary>
+        P8 = 41,
+
+        /// <summary>
+        ///     16bpp mode
+        /// </summary>
+        R5G6B5 = 23,
+
+        /// <summary>
+        ///     32bpp mode
+        /// </summary>
+        A8R8G8B8 = 21,
+
+        /// <summary>
+        ///     64bpp (floating point)
+        /// </summary>
+        A16B16G16R16F = 113
+    }
+}

NvAPIWrapper/Native/Display/DisplayConfigFlags.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Flags for applying settings, used by NvAPI_DISP_SetDisplayConfig()
+    /// </summary>
+    [Flags]
+    public enum DisplayConfigFlags
+    {
+        /// <summary>
+        ///     None
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     Do not apply
+        /// </summary>
+        ValidateOnly = 0x00000001,
+
+        /// <summary>
+        ///     Save to the persistence storage
+        /// </summary>
+        SaveToPersistence = 0x00000002,
+
+        /// <summary>
+        ///     Driver reload is permitted if necessary
+        /// </summary>
+        DriverReloadAllowed = 0x00000004,
+
+        /// <summary>
+        ///     Refresh OS mode list.
+        /// </summary>
+        ForceModeEnumeration = 0x00000008,
+
+        /// <summary>
+        ///     Tell OS to avoid optimizing CommitVidPn call during a modeset
+        /// </summary>
+        ForceCommitVideoPresentNetwork = 0x00000010
+    }
+}

NvAPIWrapper/Native/Display/DisplayPortColorDepth.cs

@@ -0,0 +1,34 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    /// Possible display port color depths
+    /// </summary>
+    public enum DisplayPortColorDepth : uint
+    {
+        /// <summary>
+        /// Default color depth
+        /// </summary>
+        Default = 0,
+        /// <summary>
+        /// 6 bit per color color depth
+        /// </summary>
+        BPC6,
+        /// <summary>
+        /// 8 bit per color color depth
+        /// </summary>
+        BPC8,
+        /// <summary>
+        /// 10 bit per color color depth
+        /// </summary>
+        BPC10,
+        /// <summary>
+        /// 12 bit per color color depth
+        /// </summary>
+        BPC12,
+
+        /// <summary>
+        /// 16 bit per color color depth
+        /// </summary>
+        BPC16,
+    }
+}

NvAPIWrapper/Native/Display/DisplayPortColorFormat.cs

@@ -0,0 +1,23 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Possible display port color formats
+    /// </summary>
+    public enum DisplayPortColorFormat : uint
+    {
+        /// <summary>
+        ///     RGB color format
+        /// </summary>
+        RGB = 0,
+
+        /// <summary>
+        ///     YCbCr422 color format
+        /// </summary>
+        YCbCr422 = 1,
+
+        /// <summary>
+        ///     YCbCr444 color format
+        /// </summary>
+        YCbCr444 = 2
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameAudioChannelAllocation.cs

@@ -0,0 +1,300 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible audio channel allocations (speaker placements)
+    /// </summary>
+    public enum InfoFrameAudioChannelAllocation : uint
+    {
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Empty [3] Empty [4] Empty [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        FrFl = 0,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Empty [3] Empty [4] Empty [5] Low Frequency Effects [6] Front Right [7] Front Left
+        /// </summary>
+        LfeFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Empty [3] Empty [4] Front Center [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        FcFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Empty [3] Empty [4] Front Center [5] Low Frequency Effects [6] Front Right [7] Front Left
+        /// </summary>
+        FcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Empty [3] Rear Center [4] Empty [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        RcFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Empty [3] Rear Center [4] Empty [5] Low Frequency Effects [6] Front Right [7] Front Left
+        /// </summary>
+        RcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Empty [3] Rear Center [4] Front Center [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        RcFcFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Empty [3] Rear Center [4] Front Center [5] Low Frequency Effects [6] Front Right [7] Front
+        ///     Left
+        /// </summary>
+        RcFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Rear Right [3] Rear Left [4] Empty [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        RrRlFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Rear Right [3] Rear Left [4] Empty [5] Low Frequency Effects [6] Front Right [7] Front Left
+        /// </summary>
+        RrRlLfeFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        RrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Empty [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects [6] Front Right [7]
+        ///     Front Left
+        /// </summary>
+        RrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Rear Center [2] Rear Right [3] Rear Left [4] Empty [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        RcRrRlFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Rear Center [2] Rear Right [3] Rear Left [4] Empty [5] Low Frequency Effects [6] Front Right [7]
+        ///     Front Left
+        /// </summary>
+        RcRrRlLfeFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Rear Center [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        RcRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Rear Center [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects [6] Front Right
+        ///     [7] Front Left
+        /// </summary>
+        RcRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Rear Right Of Center [1] Rear Left Of Center [2] Rear Right [3] Rear Left [4] Empty [5] Empty [6] Front Right
+        ///     [7] Front Left
+        /// </summary>
+        RrcRlcRrRlFrFl,
+
+        /// <summary>
+        ///     [0] Rear Right Of Center [1] Rear Left Of Center [2] Rear Right [3] Rear Left [4] Empty [5] Low Frequency Effects
+        ///     [6] Front Right [7] Front Left
+        /// </summary>
+        RrcRlcRrRlLfeFrFl,
+
+        /// <summary>
+        ///     [0] Rear Right Of Center [1] Rear Left Of Center [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front
+        ///     Right [7] Front Left
+        /// </summary>
+        RrcRlcRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] Rear Right Of Center [1] Rear Left Of Center [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency
+        ///     Effects [6] Front Right [7] Front Left
+        /// </summary>
+        RrcRlcRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Empty [3] Empty [4] Empty [5] Empty [6] Front Right [7]
+        ///     Front Left
+        /// </summary>
+        FrcFlcFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Empty [3] Empty [4] Empty [5] Low Frequency Effects [6]
+        ///     Front Right [7] Front Left
+        /// </summary>
+        FrcFlcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Empty [3] Empty [4] Front Center [5] Empty [6] Front Right
+        ///     [7] Front Left
+        /// </summary>
+        FrcFlcFcFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Empty [3] Empty [4] Front Center [5] Low Frequency Effects
+        ///     [6] Front Right [7] Front Left
+        /// </summary>
+        FrcFlcFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Empty [3] Rear Center [4] Empty [5] Empty [6] Front Right
+        ///     [7] Front Left
+        /// </summary>
+        FrcFlcRcFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Empty [3] Rear Center [4] Empty [5] Low Frequency Effects
+        ///     [6] Front Right [7] Front Left
+        /// </summary>
+        FrcFlcRcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Empty [3] Rear Center [4] Front Center [5] Empty [6] Front
+        ///     Right [7] Front Left
+        /// </summary>
+        FrcFlcRcFcFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Empty [3] Rear Center [4] Front Center [5] Low Frequency
+        ///     Effects [6] Front Right [7] Front Left
+        /// </summary>
+        FrcFlcRcFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Rear Right [3] Rear Left [4] Empty [5] Empty [6] Front Right
+        ///     [7] Front Left
+        /// </summary>
+        FrcFlcRrRlFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Rear Right [3] Rear Left [4] Empty [5] Low Frequency Effects
+        ///     [6] Front Right [7] Front Left
+        /// </summary>
+        FrcFlcRrRlLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6]
+        ///     Front Right [7] Front Left
+        /// </summary>
+        FrcFlcRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Of Center [1] Front Left Of Center [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency
+        ///     Effects [6] Front Right [7] Front Left
+        /// </summary>
+        FrcFlcRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Front Center High [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right [7] Front
+        ///     Left
+        /// </summary>
+        FchRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] Empty [1] Front Center High [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects [6] Front
+        ///     Right [7] Front Left
+        /// </summary>
+        FchRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] TopCenter [1] Empty [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right [7] Front Left
+        /// </summary>
+        TcRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] TopCenter [1] Empty [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects [6] Front Right [7]
+        ///     Front Left
+        /// </summary>
+        TcRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right High [1] Front Left High [2] Rear Right [3] Rear Left [4] Empty [5] Empty [6] Front Right [7] Front
+        ///     Left
+        /// </summary>
+        FrhFlhRrRlFrFl,
+
+        /// <summary>
+        ///     [0] Front Right High [1] Front Left High [2] Rear Right [3] Rear Left [4] Empty [5] Low Frequency Effects [6] Front
+        ///     Right [7] Front Left
+        /// </summary>
+        FrhFlhRrRlLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Wide [1] Front Left Wide [2] Rear Right [3] Rear Left [4] Empty [5] Empty [6] Front Right [7] Front
+        ///     Left
+        /// </summary>
+        FrwFlwRrRlFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Wide [1] Front Left Wide [2] Rear Right [3] Rear Left [4] Empty [5] Low Frequency Effects [6] Front
+        ///     Right [7] Front Left
+        /// </summary>
+        FrwFlwRrRlLfeFrFl,
+
+        /// <summary>
+        ///     [0] TopCenter [1] Rear Center [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right [7] Front
+        ///     Left
+        /// </summary>
+        TcRcRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] TopCenter [1] Rear Center [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects [6] Front
+        ///     Right [7] Front Left
+        /// </summary>
+        TcRcRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Center High [1] Rear Center [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right [7]
+        ///     Front Left
+        /// </summary>
+        FchRcRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] Front Center High [1] Rear Center [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects [6]
+        ///     Front Right [7] Front Left
+        /// </summary>
+        FchRcRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] TopCenter [1] Front Center High [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right [7]
+        ///     Front Left
+        /// </summary>
+        TcFcRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] TopCenter [1] Front Center High [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects [6]
+        ///     Front Right [7] Front Left
+        /// </summary>
+        TcFchRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right High [1] Front Left High [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right
+        ///     [7] Front Left
+        /// </summary>
+        FrhFlhRrRlFcFrFl,
+
+        /// <summary>
+        ///     [0] Front Right High [1] Front Left High [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects
+        ///     [6] Front Right [7] Front Left
+        /// </summary>
+        FrhFlhRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     [0] Front Right Wide [1] Front Left Wide [2] Rear Right [3] Rear Left [4] Front Center [5] Empty [6] Front Right
+        ///     [7] Front Left
+        /// </summary>
+        FrwFlwRrRlFcFeFl,
+
+        /// <summary>
+        ///     [0] Front Right Wide [1] Front Left Wide [2] Rear Right [3] Rear Left [4] Front Center [5] Low Frequency Effects
+        ///     [6] Front Right [7] Front Left
+        /// </summary>
+        FrwFlwRrRlFcLfeFrFl,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 511
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameAudioChannelCount.cs

@@ -0,0 +1,53 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible audio channels
+    /// </summary>
+    public enum InfoFrameAudioChannelCount : uint
+    {
+        /// <summary>
+        ///     Data is available in the header of source data
+        /// </summary>
+        InHeader = 0,
+
+        /// <summary>
+        ///     Two channels
+        /// </summary>
+        Two,
+
+        /// <summary>
+        ///     Three channels
+        /// </summary>
+        Three,
+
+        /// <summary>
+        ///     Four channels
+        /// </summary>
+        Four,
+
+        /// <summary>
+        ///     Five channels
+        /// </summary>
+        Five,
+
+        /// <summary>
+        ///     Six channels
+        /// </summary>
+        Six,
+
+        /// <summary>
+        ///     Seven channels
+        /// </summary>
+        Seven,
+
+        /// <summary>
+        ///     Eight channels
+        /// </summary>
+        Eight,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 15
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameAudioCodec.cs

@@ -0,0 +1,93 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible audio codecs
+    /// </summary>
+    public enum InfoFrameAudioCodec : uint
+    {
+        /// <summary>
+        ///     Data is available in the header of source data
+        /// </summary>
+        InHeader = 0,
+
+        /// <summary>
+        ///     Pulse-code modulation
+        /// </summary>
+        PCM,
+
+        /// <summary>
+        ///     Dolby AC-3
+        /// </summary>
+        AC3,
+
+        /// <summary>
+        ///     MPEG1
+        /// </summary>
+        MPEG1,
+
+        /// <summary>
+        ///     MP3 (MPEG-2 Audio Layer III)
+        /// </summary>
+        MP3,
+
+        /// <summary>
+        ///     MPEG2
+        /// </summary>
+        MPEG2,
+
+        /// <summary>
+        ///     Advanced Audio Coding
+        /// </summary>
+        AACLC,
+
+        /// <summary>
+        ///     DTS
+        /// </summary>
+        DTS,
+
+        /// <summary>
+        ///     Adaptive Transform Acoustic Coding
+        /// </summary>
+        ATRAC,
+
+        /// <summary>
+        ///     Direct Stream Digital
+        /// </summary>
+        DSD,
+
+        /// <summary>
+        ///     Dolby Digital Plus
+        /// </summary>
+        EAC3,
+
+        /// <summary>
+        ///     DTS High Definition
+        /// </summary>
+        DTSHD,
+
+        /// <summary>
+        ///     Meridian Lossless Packing
+        /// </summary>
+        MLP,
+
+        /// <summary>
+        ///     DST
+        /// </summary>
+        DST,
+
+        /// <summary>
+        ///     Windows Media Audio Pro
+        /// </summary>
+        WMAPRO,
+
+        /// <summary>
+        ///     Extended audio codec value should be used to get information regarding audio codec
+        /// </summary>
+        UseExtendedCodecType,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 31
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameAudioExtendedCodec.cs

@@ -0,0 +1,33 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible extended audio codecs
+    /// </summary>
+    public enum InfoFrameAudioExtendedCodec : uint
+    {
+        /// <summary>
+        ///     Use the primary audio codec type, data not available
+        /// </summary>
+        UseCodecType = 0,
+
+        /// <summary>
+        ///     High-Efficiency Advanced Audio Coding
+        /// </summary>
+        HEAAC,
+
+        /// <summary>
+        ///     High-Efficiency Advanced Audio Coding 2
+        /// </summary>
+        HEAACVersion2,
+
+        /// <summary>
+        ///     MPEG Surround
+        /// </summary>
+        MPEGSurround,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 63
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameAudioLFEPlaybackLevel.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible audio low frequency effects channel playback level
+    /// </summary>
+    public enum InfoFrameAudioLFEPlaybackLevel : uint
+    {
+        /// <summary>
+        ///     Data not available
+        /// </summary>
+        NoData = 0,
+
+        /// <summary>
+        ///     No change to the source audio
+        /// </summary>
+        Plus0Decibel,
+
+        /// <summary>
+        ///     Adds 10 decibel
+        /// </summary>
+        Plus10Decibel,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameAudioLevelShift.cs

@@ -0,0 +1,93 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible audio channel level shift values
+    /// </summary>
+    public enum InfoFrameAudioLevelShift : uint
+    {
+        /// <summary>
+        ///     No change to the source audio
+        /// </summary>
+        Shift0Decibel = 0,
+
+        /// <summary>
+        ///     Shifts 1 decibel
+        /// </summary>
+        Shift1Decibel,
+
+        /// <summary>
+        ///     Shifts 2 decibel
+        /// </summary>
+        Shift2Decibel,
+
+        /// <summary>
+        ///     Shifts 3 decibel
+        /// </summary>
+        Shift3Decibel,
+
+        /// <summary>
+        ///     Shifts 4 decibel
+        /// </summary>
+        Shift4Decibel,
+
+        /// <summary>
+        ///     Shifts 5 decibel
+        /// </summary>
+        Shift5Decibel,
+
+        /// <summary>
+        ///     Shifts 6 decibel
+        /// </summary>
+        Shift6Decibel,
+
+        /// <summary>
+        ///     Shifts 7 decibel
+        /// </summary>
+        Shift7Decibel,
+
+        /// <summary>
+        ///     Shifts 8 decibel
+        /// </summary>
+        Shift8Decibel,
+
+        /// <summary>
+        ///     Shifts 9 decibel
+        /// </summary>
+        Shift9Decibel,
+
+        /// <summary>
+        ///     Shifts 10 decibel
+        /// </summary>
+        Shift10Decibel,
+
+        /// <summary>
+        ///     Shifts 11 decibel
+        /// </summary>
+        Shift11Decibel,
+
+        /// <summary>
+        ///     Shifts 12 decibel
+        /// </summary>
+        Shift12Decibel,
+
+        /// <summary>
+        ///     Shifts 13 decibel
+        /// </summary>
+        Shift13Decibel,
+
+        /// <summary>
+        ///     Shifts 14 decibel
+        /// </summary>
+        Shift14Decibel,
+
+        /// <summary>
+        ///     Shifts 15 decibel
+        /// </summary>
+        Shift15Decibel,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 31
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameAudioSampleRate.cs

@@ -0,0 +1,53 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible audio sample rates (sampling frequency)
+    /// </summary>
+    public enum InfoFrameAudioSampleRate : uint
+    {
+        /// <summary>
+        ///     Data is available in the header of source data
+        /// </summary>
+        InHeader = 0,
+
+        /// <summary>
+        ///     31kHz sampling frequency
+        /// </summary>
+        F32000Hz,
+
+        /// <summary>
+        ///     44.1kHz sampling frequency
+        /// </summary>
+        F44100Hz,
+
+        /// <summary>
+        ///     48kHz sampling frequency
+        /// </summary>
+        F48000Hz,
+
+        /// <summary>
+        ///     88.2kHz sampling frequency
+        /// </summary>
+        F88200Hz,
+
+        /// <summary>
+        ///     96kHz sampling frequency
+        /// </summary>
+        F96000Hz,
+
+        /// <summary>
+        ///     176.4kHz sampling frequency
+        /// </summary>
+        F176400Hz,
+
+        /// <summary>
+        ///     192kHz sampling frequency
+        /// </summary>
+        F192000Hz,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 15
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameAudioSampleSize.cs

@@ -0,0 +1,33 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible audio sample size (bit depth)
+    /// </summary>
+    public enum InfoFrameAudioSampleSize : uint
+    {
+        /// <summary>
+        ///     Data is available in the header of source data
+        /// </summary>
+        InHeader = 0,
+
+        /// <summary>
+        ///     16bit audio sample size
+        /// </summary>
+        B16,
+
+        /// <summary>
+        ///     20bit audio sample size
+        /// </summary>
+        B20,
+
+        /// <summary>
+        ///     24bit audio sample size
+        /// </summary>
+        B24,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameBoolean.cs

@@ -0,0 +1,23 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for info-frame properties that accept or return a boolean value
+    /// </summary>
+    public enum InfoFrameBoolean : uint
+    {
+        /// <summary>
+        ///     False
+        /// </summary>
+        False = 0,
+
+        /// <summary>
+        ///     True
+        /// </summary>
+        True,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 3
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameCommand.cs

@@ -0,0 +1,50 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Possible commands for info-frame operations
+    /// </summary>
+    public enum InfoFrameCommand : uint
+    {
+        /// <summary>
+        ///     Returns the fields in the info-frame with values set by the manufacturer (NVIDIA or OEM)
+        /// </summary>
+        GetDefault = 0,
+
+        /// <summary>
+        ///     Sets the fields in the info-frame to auto, and info-frame to the default info-frame for use in a set.
+        /// </summary>
+        Reset,
+
+        /// <summary>
+        ///     Get the current info-frame state.
+        /// </summary>
+        Get,
+
+        /// <summary>
+        ///     Set the current info-frame state (flushed to the monitor), the values are one time and do not persist.
+        /// </summary>
+        Set,
+
+        /// <summary>
+        ///     Get the override info-frame state, non-override fields will be set to value = AUTO, overridden fields will have the
+        ///     current override values.
+        /// </summary>
+        GetOverride,
+
+        /// <summary>
+        ///     Set the override info-frame state, non-override fields will be set to value = AUTO, other values indicate override;
+        ///     persist across mode-set and reboot.
+        /// </summary>
+        SetOverride,
+
+        /// <summary>
+        ///     Get properties associated with info-frame (each of the info-frame type will have properties).
+        /// </summary>
+        GetProperty,
+
+        /// <summary>
+        ///     Set properties associated with info-frame.
+        /// </summary>
+        SetProperty
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameDataType.cs

@@ -0,0 +1,18 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible info-frame data type
+    /// </summary>
+    public enum InfoFrameDataType : uint
+    {
+        /// <summary>
+        ///     Auxiliary Video data
+        /// </summary>
+        AuxiliaryVideoInformation = 2,
+
+        /// <summary>
+        ///     Audio data
+        /// </summary>
+        AudioInformation = 4,
+    }
+}

NvAPIWrapper/Native/Display/InfoFramePropertyMode.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible info-frame property modes
+    /// </summary>
+    public enum InfoFramePropertyMode : uint
+    {
+        /// <summary>
+        ///     Driver determines whether to send info-frames.
+        /// </summary>
+        Auto = 0,
+
+        /// <summary>
+        ///     Driver always sends info-frame.
+        /// </summary>
+        Enable,
+
+        /// <summary>
+        ///     Driver never sends info-frame.
+        /// </summary>
+        Disable,
+
+        /// <summary>
+        ///     Driver only sends info-frame when client requests it via info-frame escape call.
+        /// </summary>
+        AllowOverride
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoAspectRatioActivePortion.cs

@@ -0,0 +1,58 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for AVI aspect ratio portions
+    /// </summary>
+    public enum InfoFrameVideoAspectRatioActivePortion : uint
+    {
+        /// <summary>
+        ///     Disabled or not available
+        /// </summary>
+        Disabled = 0,
+
+        /// <summary>
+        ///     Letter box 16x9
+        /// </summary>
+        LetterboxGreaterThan16X9 = 4,
+
+        /// <summary>
+        ///     Equal to the source frame size
+        /// </summary>
+        EqualCodedFrame = 8,
+
+        /// <summary>
+        ///     Centered 4x3 ratio
+        /// </summary>
+        Center4X3 = 9,
+
+        /// <summary>
+        ///     Centered 16x9 ratio
+        /// </summary>
+        Center16X9 = 10,
+
+        /// <summary>
+        ///     Centered 14x9 ratio
+        /// </summary>
+        Center14X9 = 11,
+
+        /// <summary>
+        ///     Bordered 4x3 on 14x9
+        /// </summary>
+        Bordered4X3On14X9 = 13,
+
+        /// <summary>
+        ///     Bordered 16x9 on 14x9
+        /// </summary>
+        Bordered16X9On14X9 = 14,
+
+        /// <summary>
+        ///     Bordered 16x9 on 4x3
+        /// </summary>
+        Bordered16X9On4X3 = 15,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 31
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoAspectRatioCodedFrame.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Gets the possible values for AVI source aspect ratio
+    /// </summary>
+    public enum InfoFrameVideoAspectRatioCodedFrame : uint
+    {
+        /// <summary>
+        ///     No data available
+        /// </summary>
+        NoData = 0,
+
+        /// <summary>
+        ///     The 4x3 aspect ratio
+        /// </summary>
+        Aspect4X3,
+
+        /// <summary>
+        ///     The 16x9 aspect ratio
+        /// </summary>
+        Aspect16X9,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoBarData.cs

@@ -0,0 +1,33 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible AVI bar data that are available and should be used
+    /// </summary>
+    public enum InfoFrameVideoBarData : uint
+    {
+        /// <summary>
+        ///     No bar data present
+        /// </summary>
+        NotPresent = 0,
+
+        /// <summary>
+        ///     Vertical bar
+        /// </summary>
+        Vertical,
+
+        /// <summary>
+        ///     Horizontal bar
+        /// </summary>
+        Horizontal,
+
+        /// <summary>
+        ///     Both sides have bars
+        /// </summary>
+        Both,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoColorFormat.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible AVI color formats
+    /// </summary>
+    public enum InfoFrameVideoColorFormat : uint
+    {
+        /// <summary>
+        ///     The RGB color format
+        /// </summary>
+        RGB = 0,
+
+        /// <summary>
+        ///     The YCbCr422 color format
+        /// </summary>
+        YCbCr422,
+
+        /// <summary>
+        ///     The YCbCr444 color format
+        /// </summary>
+        YCbCr444,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoColorimetry.cs

@@ -0,0 +1,33 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the AVI color space
+    /// </summary>
+    public enum InfoFrameVideoColorimetry : uint
+    {
+        /// <summary>
+        ///     No data available
+        /// </summary>
+        NoData = 0,
+
+        /// <summary>
+        ///     The SMPTE170M color space
+        /// </summary>
+        SMPTE170M,
+
+        /// <summary>
+        ///     The ITURBT709 color space
+        /// </summary>
+        ITURBT709,
+
+        /// <summary>
+        ///     Extended colorimetry value should be used to get information regarding AVI color space
+        /// </summary>
+        UseExtendedColorimetry,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoContentType.cs

@@ -0,0 +1,33 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible AVI content type
+    /// </summary>
+    public enum InfoFrameVideoContentType : uint
+    {
+        /// <summary>
+        ///     Graphics content
+        /// </summary>
+        Graphics = 0,
+
+        /// <summary>
+        ///     Photo content
+        /// </summary>
+        Photo,
+
+        /// <summary>
+        ///     Cinematic content
+        /// </summary>
+        Cinema,
+
+        /// <summary>
+        ///     Gaming content
+        /// </summary>
+        Game,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoExtendedColorimetry.cs

@@ -0,0 +1,41 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the AVI extended color space
+    /// </summary>
+    public enum InfoFrameVideoExtendedColorimetry : uint
+    {
+        /// <summary>
+        ///     The xvYCC601 color space
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        xvYCC601 = 0,
+
+        /// <summary>
+        ///     The xvYCC709 color space
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        xvYCC709,
+
+        /// <summary>
+        ///     The sYCC601 color space
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        sYCC601,
+
+        /// <summary>
+        ///     The AdobeYCC601 color space
+        /// </summary>
+        AdobeYCC601,
+
+        /// <summary>
+        ///     The AdobeRGB color space
+        /// </summary>
+        AdobeRGB,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 15
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoITC.cs

@@ -0,0 +1,23 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible AVI video content modes
+    /// </summary>
+    public enum InfoFrameVideoITC : uint
+    {
+        /// <summary>
+        ///     Normal video content (Consumer Electronics)
+        /// </summary>
+        VideoContent = 0,
+
+        /// <summary>
+        ///     Information Technology content
+        /// </summary>
+        ITContent,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 3
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoNonUniformPictureScaling.cs

@@ -0,0 +1,33 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the AVI non uniform picture scaling
+    /// </summary>
+    public enum InfoFrameVideoNonUniformPictureScaling : uint
+    {
+        /// <summary>
+        ///     No data available
+        /// </summary>
+        NoData = 0,
+
+        /// <summary>
+        ///     Horizontal scaling
+        /// </summary>
+        Horizontal,
+
+        /// <summary>
+        ///     Vertical scaling
+        /// </summary>
+        Vertical,
+
+        /// <summary>
+        ///     Scaling in both directions
+        /// </summary>
+        Both,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoPixelRepetition.cs

@@ -0,0 +1,63 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible AVI pixel repetition values
+    /// </summary>
+    public enum InfoFrameVideoPixelRepetition : uint
+    {
+        /// <summary>
+        ///     No pixel repetition
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     Two pixel repetition
+        /// </summary>
+        X2,
+
+        /// <summary>
+        ///     Three pixel repetition
+        /// </summary>
+        X3,
+
+        /// <summary>
+        ///     Four pixel repetition
+        /// </summary>
+        X4,
+
+        /// <summary>
+        ///     Five pixel repetition
+        /// </summary>
+        X5,
+
+        /// <summary>
+        ///     Six pixel repetition
+        /// </summary>
+        X6,
+
+        /// <summary>
+        ///     Seven pixel repetition
+        /// </summary>
+        X7,
+
+        /// <summary>
+        ///     Eight pixel repetition
+        /// </summary>
+        X8,
+
+        /// <summary>
+        ///     Nine pixel repetition
+        /// </summary>
+        X9,
+
+        /// <summary>
+        ///     Ten pixel repetition
+        /// </summary>
+        X10,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 31
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoRGBQuantization.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the AVI RGB quantization
+    /// </summary>
+    public enum InfoFrameVideoRGBQuantization : uint
+    {
+        /// <summary>
+        ///     Default setting
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        ///     Limited RGB range [16-235] (86%)
+        /// </summary>
+        LimitedRange,
+
+        /// <summary>
+        ///     Full RGB range [0-255] (100%)
+        /// </summary>
+        FullRange,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoScanInfo.cs

@@ -0,0 +1,28 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for AVI scan information
+    /// </summary>
+    public enum InfoFrameVideoScanInfo : uint
+    {
+        /// <summary>
+        ///     No data available
+        /// </summary>
+        NoData = 0,
+
+        /// <summary>
+        ///     Overscan
+        /// </summary>
+        OverScan,
+
+        /// <summary>
+        ///     Underscan
+        /// </summary>
+        UnderScan,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/InfoFrameVideoYCCQuantization.cs

@@ -0,0 +1,23 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible AVI YCC quantization
+    /// </summary>
+    public enum InfoFrameVideoYCCQuantization : uint
+    {
+        /// <summary>
+        ///     Limited YCC range
+        /// </summary>
+        LimitedRange = 0,
+
+        /// <summary>
+        ///     Full YCC range
+        /// </summary>
+        FullRange,
+
+        /// <summary>
+        ///     Auto (Unspecified)
+        /// </summary>
+        Auto = 7
+    }
+}

NvAPIWrapper/Native/Display/MonitorCapabilitiesConnectorType.cs

@@ -0,0 +1,38 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Possible values for the monitor capabilities connector type
+    /// </summary>
+    public enum MonitorCapabilitiesConnectorType : uint
+    {
+        /// <summary>
+        ///     Unknown or invalid connector
+        /// </summary>
+        Unknown = 0,
+
+        /// <summary>
+        ///     VGA connector
+        /// </summary>
+        VGA,
+
+        /// <summary>
+        ///     Composite connector (TV)
+        /// </summary>
+        TV,
+
+        /// <summary>
+        ///     DVI connector
+        /// </summary>
+        DVI,
+
+        /// <summary>
+        ///     HDMI connector
+        /// </summary>
+        HDMI,
+
+        /// <summary>
+        ///     Display Port connector
+        /// </summary>
+        DisplayPort
+    }
+}

NvAPIWrapper/Native/Display/MonitorCapabilitiesType.cs

@@ -0,0 +1,18 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the monitor capabilities type
+    /// </summary>
+    public enum MonitorCapabilitiesType : uint
+    {
+        /// <summary>
+        ///     The Vendor Specific Data Block
+        /// </summary>
+        VSDB = 0x1000,
+
+        /// <summary>
+        ///     The Video Capability Data Block
+        /// </summary>
+        VCDB = 0x1001
+    }
+}

NvAPIWrapper/Native/Display/Rotate.cs

@@ -0,0 +1,33 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Possible rotate modes
+    /// </summary>
+    public enum Rotate : uint
+    {
+        /// <summary>
+        ///     No rotation
+        /// </summary>
+        Degree0 = 0,
+
+        /// <summary>
+        ///     90 degree rotation
+        /// </summary>
+        Degree90 = 1,
+
+        /// <summary>
+        ///     180 degree rotation
+        /// </summary>
+        Degree180 = 2,
+
+        /// <summary>
+        ///     270 degree rotation
+        /// </summary>
+        Degree270 = 3,
+
+        /// <summary>
+        ///     This value is ignored
+        /// </summary>
+        Ignored = 4
+    }
+}

NvAPIWrapper/Native/Display/Scaling.cs

@@ -0,0 +1,48 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Possible scaling modes
+    /// </summary>
+    public enum Scaling
+    {
+        /// <summary>
+        ///     No change
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        ///     Balanced  - Full Screen
+        /// </summary>
+        ToClosest = 1,
+
+        /// <summary>
+        ///     Force GPU - Full Screen
+        /// </summary>
+        ToNative = 2,
+
+        /// <summary>
+        ///     Force GPU - Centered\No Scaling
+        /// </summary>
+        GPUScanOutToNative = 3,
+
+        /// <summary>
+        ///     Force GPU - Aspect Ratio
+        /// </summary>
+        ToAspectScanOutToNative = 5,
+
+        /// <summary>
+        ///     Balanced  - Aspect Ratio
+        /// </summary>
+        ToAspectScanOutToClosest = 6,
+
+        /// <summary>
+        ///     Balanced  - Centered\No Scaling
+        /// </summary>
+        GPUScanOutToClosest = 7,
+
+        /// <summary>
+        ///     Customized scaling - For future use
+        /// </summary>
+        Customized = 255
+    }
+}

NvAPIWrapper/Native/Display/ScanOutCompositionParameter.cs

@@ -0,0 +1,13 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Holds a list of possible scan out composition configurable parameters
+    /// </summary>
+    public enum ScanOutCompositionParameter : uint
+    {
+        /// <summary>
+        ///     Warping re-sampling method parameter
+        /// </summary>
+        WarpingReSamplingMethod = 0
+    }
+}

NvAPIWrapper/Native/Display/ScanOutCompositionParameterValue.cs

@@ -0,0 +1,48 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Holds a list of possible scan out composition parameter values
+    /// </summary>
+    public enum ScanOutCompositionParameterValue : uint
+    {
+        /// <summary>
+        ///     Default parameter value
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        ///     BiLinear value for the warping re-sampling method parameter
+        /// </summary>
+        WarpingReSamplingMethodBiLinear = 0x100,
+
+        /// <summary>
+        ///     Bicubic Triangular value for the warping re-sampling method parameter
+        /// </summary>
+        WarpingReSamplingMethodBicubicTriangular = 0x101,
+
+        /// <summary>
+        ///     Bicubic Bell Shaped value for the warping re-sampling method parameter
+        /// </summary>
+        WarpingReSamplingMethodBicubicBellShaped = 0x102,
+
+        /// <summary>
+        ///     Bicubic B-Spline value for the warping re-sampling method parameter
+        /// </summary>
+        WarpingReSamplingMethodBicubicBSpline = 0x103,
+
+        /// <summary>
+        ///     Bicubic Adaptive Triangular value for the warping re-sampling method parameter
+        /// </summary>
+        WarpingReSamplingMethodBicubicAdaptiveTriangular = 0x104,
+
+        /// <summary>
+        ///     Bicubic Adaptive Bell Shaped value for the warping re-sampling method parameter
+        /// </summary>
+        WarpingReSamplingMethodBicubicAdaptiveBellShaped = 0x105,
+
+        /// <summary>
+        ///     Bicubic Adaptive B-Spline value for the warping re-sampling method parameter
+        /// </summary>
+        WarpingReSamplingMethodBicubicAdaptiveBSpline = 0x106
+    }
+}

NvAPIWrapper/Native/Display/SpanningOrientation.cs

@@ -0,0 +1,23 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Display spanning for Windows XP
+    /// </summary>
+    public enum SpanningOrientation
+    {
+        /// <summary>
+        ///     No spanning
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     Horizontal spanning
+        /// </summary>
+        Horizontal = 1,
+
+        /// <summary>
+        ///     Vertical spanning
+        /// </summary>
+        Vertical = 2
+    }
+}

NvAPIWrapper/Native/Display/StaticMetadataDescriptorId.cs

@@ -0,0 +1,13 @@
+namespace NvAPIWrapper.Native.Display
+{
+    /// <summary>
+    ///     Contains possible values for the type of the Static Metadata Descriptor block structure
+    /// </summary>
+    public enum StaticMetadataDescriptorId : uint
+    {
+        /// <summary>
+        ///     Type 1 Static Metadata Descriptor block structure
+        /// </summary>
+        StaticMetadataType1 = 0
+    }
+}