GiantsTools/Giants.Launcher/Native/RendererInterop.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace Giants.Launcher
{
    class RendererInterop
    {
#pragma warning disable 649
        public struct GFXCapabilityInfo
        {
            public int maxAnisotropy;
            public uint flags;
            public int priority;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
            public string rendererName;
        };
#pragma warning restore 649

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate bool GFXGetCapabilities(ref GFXCapabilityInfo outCapabilities);

        /// <summary>
        /// Makes interop call to native renderer DLL to obtain capability information.
        /// </summary>
        /// <returns>True if the given renderer is supported by the system.</returns>
        public static bool GetRendererCapabilities(string dllPath, ref GFXCapabilityInfo capabilities)
        {
            bool rendererSupported = false;
            IntPtr pDll = NativeMethods.LoadLibrary(dllPath);
            if (pDll == IntPtr.Zero)
                throw new System.Exception(string.Format("LoadLibrary() for {0} failed", dllPath));

            IntPtr pAddressOfFunctionToCall = NativeMethods.GetProcAddress(pDll, "GFXGetCapabilities");
            if (pAddressOfFunctionToCall == IntPtr.Zero)
                return false;

            var prcGetCapabilities = (GFXGetCapabilities)Marshal.GetDelegateForFunctionPointer(pAddressOfFunctionToCall, typeof(GFXGetCapabilities));
            rendererSupported = prcGetCapabilities(ref capabilities);

            NativeMethods.FreeLibrary(pDll);

            return rendererSupported;
        }


        public static List<Capabilities> GetCompatibleRenderers(string gamePath)
        {
            DirectoryInfo dir = new DirectoryInfo(Path.GetDirectoryName(gamePath));

            List<Capabilities> Capabilities = new List<Capabilities>();

            // Search current directory for compatible renderers:
            foreach (FileInfo file in dir.GetFiles("gg_*.dll"))
            {
                try
                {
                    // Make interop call to native renderer DLLs to get capability info
                    RendererInterop.GFXCapabilityInfo interopCaps = new RendererInterop.GFXCapabilityInfo();
                    string path = Path.Combine(file.DirectoryName, file.Name);
                    if (RendererInterop.GetRendererCapabilities(path, ref interopCaps))
                    {

                        Capabilities caps = new Capabilities(path, ref interopCaps);
                        Capabilities.Add(caps);
                        //cmbRenderer.Items.Add(caps);
                    }


                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }

            return Capabilities;

            // Select highest priority renderer
            //cmbRenderer.SelectedItem = _RendererCaps.Max();
        }

        public class Capabilities : IComparable
        {
            [Flags]
            public enum RendererFlag
            {
                LowBitDepthAllowed = 0x1,

                // Multisampling support flags:
                MSAA2x = 0x2,
                MSAA4x = 0x4,
                MSAA8x = 0x8,
                MSAA16x = 0x10,

                // Other options:
                VSync = 0x20,
                TripleBuffer = 0x40,


            };

            public Capabilities(string filePath, ref RendererInterop.GFXCapabilityInfo gfxCaps)
            {
                this.FilePath = filePath;
                this.FileName = Path.GetFileName(filePath);
                this.MaxAnisotropy = gfxCaps.maxAnisotropy;
                this.Flags = (RendererFlag)gfxCaps.flags;
                this.Priority = gfxCaps.priority;
                this.Name = gfxCaps.rendererName;
            }

            public override string ToString()
            {
                return string.Format("{0} ({1})", this.Name, Path.GetFileName(this.FilePath));
            }

            public int CompareTo(object obj)
            {
                if (obj == null) return 1;

                Capabilities other = obj as Capabilities;
                if (other != null)
                    return this.Priority.CompareTo(other.Priority);
                else
                    throw new ArgumentException();
            }

            public string FilePath { get; private set; }
            public string FileName { get; private set; }
            public int MaxAnisotropy { get; private set; }
            public RendererFlag Flags { get; private set; }
            public int Priority { get; private set; }
            public string Name { get; private set; }
        }
    }
}