VkDebugReportCallbackEXT _debugReport;

static PFN_vkDebugReportCallbackEXT _callback;

public unsafe VkWindow() : base(640,480, GraphicsMode.Default, "Test", GameWindowFlags.Default)
        {
#if DEBUG
            _enableValidationLayers = true;
#else
            _enableValidationLayers = false;
#endif
            _currentDevice = VK.NullHandle;

            requiredProperties = new List<string>()
            {
                "VK_KHR_SWAPCHAIN_EXTENSION_NAME"
            };

            validationLayers = new VulkanList<IntPtr>()
            {
                new VulkanString("VK_LAYER_LUNARG_standard_validation")
            };

            _callback = DebugCallback;
        }

        unsafe uint DebugCallback(uint flags,
            VkDebugReportObjectTypeEXT objectType,
            ulong @object,
            UIntPtr location,
            int messageCode,
            byte* pLayerPrefix,
            byte* pMessage,
            void* pUserData)
        {
            Console.WriteLine($"Validation Layer: {GetString(pMessage)}");

            return 0;
        }

        unsafe void SetupDebug()
        {
            if (_enableValidationLayers)
            {
                VkDebugReportCallbackCreateInfoEXT createInfo = new VkDebugReportCallbackCreateInfoEXT()
                {
                    sType = VkStructureType.DebugReportCallbackCreateInfoEXT,
                    pUserData = (void*)null,
                    flags = VkDebugReportFlagsEXT.DebugEXT | VkDebugReportFlagsEXT.ErrorEXT | VkDebugReportFlagsEXT.WarningEXT,
                    pfnCallback = Marshal.GetFunctionPointerForDelegate(_callback)
                };

                Check(VK.CreateDebugReportCallbackEXT(_currentInstance, &createInfo, null, out _debugReport));
            }
        }

        unsafe bool CheckValidationLayerSupport()
        {
            uint valLayerCount = 0;

            Check(VK.EnumerateInstanceLayerProperties(&valLayerCount, IntPtr.Zero));

            if(valLayerCount == 0)
            {

            }

            VkLayerProperties[] layers = new VkLayerProperties[valLayerCount];

            fixed (VkLayerProperties* props = layers) {
                Check(VK.EnumerateInstanceLayerProperties(&valLayerCount, props));
            }

            foreach(var layer in validationLayers)
            {
                bool layerFound = false;

                string valLayerString = GetString(layer);
               foreach(var foundLayer in layers)
                {

                    string layerString = GetString(foundLayer.layerName);

                    if (valLayerString == layerString)
                    {
                        layerFound = true;

                        break;
                    }
                }

                if (!layerFound)
                    return false;
            }

            return true;
        }

         public unsafe void CreateInstance()
        {
            bool enableDebug = false;
            if(_enableValidationLayers && CheckValidationLayerSupport())
            {
                enableDebug = true;
            }

            var appinfo = new VkApplicationInfo()
            {
                sType = VkStructureType.ApplicationInfo,
                pApplicationName = (VulkanString)Title,
                applicationVersion = new VulkanVersion(1, 0, 0),
                pEngineName = (VulkanString)Title
            };

            VulkanList<IntPtr> InstanceExtensions = new VulkanList<IntPtr>
            {
                VulkanStrings.VK_KHR_SURFACE_EXTENSION_NAME
            };

            var extensions = GetRequiredExtensions(enableDebug);

            foreach (IntPtr RequiredExtension in extensions)
            {
                InstanceExtensions.Add(RequiredExtension);
            }

            VkInstanceCreateInfo createInfo = new VkInstanceCreateInfo()
            {
                sType = VkStructureType.InstanceCreateInfo,
                pApplicationInfo = &appinfo,
                enabledExtensionCount = InstanceExtensions.Count,
                ppEnabledExtensionNames = (byte**)InstanceExtensions.Data,
           };

            if (enableDebug)
            {
                createInfo.ppEnabledLayerNames = (byte**)validationLayers.Data;
                createInfo.enabledLayerCount =(uint)validationLayers.Count;
            }
            else
            {
                createInfo.enabledLayerCount = 0;
            }

            if (!Check(VK.CreateInstance(&createInfo, null, out _currentInstance)))
            {

            }

            if (enableDebug)
            {
                SetupDebug();
            }
        }