When trying to link vulkan and glfw on mac osx, i ran this code to test the wether or not everything was working.
my output ->
--- Progress: glfw initialized
--- Progress: glfw supports vulkan
Listing vulkan extension
Available Vulkan extensions:
- VK_KHR_device_group_creation
- VK_KHR_external_fence_capabilities
- VK_KHR_external_memory_capabilities
- VK_KHR_external_semaphore_capabilities
- VK_KHR_get_physical_device_properties2
- VK_KHR_get_surface_capabilities2
- VK_KHR_surface
- VK_EXT_debug_report
- VK_EXT_debug_utils
- VK_EXT_headless_surface
- VK_EXT_layer_settings
- VK_EXT_metal_surface
- VK_EXT_surface_maintenance1
- VK_EXT_swapchain_colorspace
- VK_MVK_macos_surface
- VK_MVK_moltenvk
Available Vulkan layers / Molten vk support:
- MoltenVK (MoltenVK driver layer)
glfw Extension -->VK_KHR_surface
glfw Extension -->VK_EXT_metal_surface
Available extensions:
VK_KHR_device_group_creation
VK_KHR_external_fence_capabilities
VK_KHR_external_memory_capabilities
VK_KHR_external_semaphore_capabilities
VK_KHR_get_physical_device_properties2
VK_KHR_get_surface_capabilities2
VK_KHR_surface
VK_EXT_debug_report
VK_EXT_debug_utils
VK_EXT_headless_surface
VK_EXT_layer_settings
VK_EXT_metal_surface
VK_EXT_surface_maintenance1
VK_EXT_swapchain_colorspace
VK_MVK_macos_surface
VK_MVK_moltenvk
--- Progress: Vulkan instance created
ERROR: vkGetInstanceProcAddr: Invalid instance [VUID-vkGetInstanceProcAddr-instance-parameter]
zsh: abort ./PhysicsEngine --testGV
bool TestVulkan_GLFWLinking()
{
if( !glfwInit() )
{
std::cout<<"Error: Couldn't initialize glfwn";
return false;
}
else
{
std::cout<<"--- Progress: glfw initializedn";
}
glfwSetErrorCallback( error_callback );
if( !glfwVulkanSupported() )
{
std::cout<<"Error: Glfw does not support vulkan";
return false;
}
else
{
std::cout<<"--- Progress: glfw supports vulkann";
}
std::cout<<"Listing vulkan extensionnn";
ListVulkanExtensions();
std::cout<<"nnn";
PFN_vkCreateInstance PfnCreateInstance = (PFN_vkCreateInstance)
glfwGetInstanceProcAddress(NULL, "vkCreateInstance");
std::cout<<"--- Progress: glfw instance procaddress null instancen";
VkInstance VulkanInstance = CreateVulkanInstance();
std::cout<<"--- Progress: Vulkan instance createdn";
PFN_vkCreateInstance pfnCreateDevice = (PFN_vkCreateInstance)
glfwGetInstanceProcAddress( VulkanInstance, "vkCreateDevice" );
GLFWwindow* GLFWWindow = CreateWindow();
if( !GLFWWindow )
{
std::cout<<"Error: Failed to create glfw window";
return false;
}
VkSurfaceKHR VulkanSurfaceSurface;
VkResult Error = glfwCreateWindowSurface( VulkanInstance, GLFWWindow, NULL, &VulkanSurfaceSurface );
if ( Error )
{
std::cout<<"Error: Failed to create vulkan window surface";
return false;
}
return true;
}
std::vector<const char*> getRequiredExtensions()
{
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
std::vector<const char*> requiredExtensions;
requiredExtensions.emplace_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
//requiredExtensions.emplace_back( VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME );
for (uint32_t i = 0; i < glfwExtensionCount; i++)
{
std::cout<<"glfw Extension -->" << glfwExtensions[i]<<"n";
requiredExtensions.emplace_back(glfwExtensions[i]);
}
//requiredExtensions.emplace_back(VK_KHR_surface);
//requiredExtensions.emplace_back(VK_EXT_metal_surface);
return requiredExtensions;
}
VkInstance CreateVulkanInstance()
{
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Vulkan App";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "No Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_0;
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
createInfo.pApplicationInfo=&appInfo;
createInfo.enabledLayerCount = 0;
createInfo.ppEnabledLayerNames= nullptr;
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
PopulateDebugMessengerCreateInfo(debugCreateInfo);
createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*) &debugCreateInfo;
auto requiredExtensions = getRequiredExtensions();
createInfo.enabledExtensionCount = (uint32_t) requiredExtensions.size();
createInfo.ppEnabledExtensionNames = requiredExtensions.data();
createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
std::vector<const char*> deviceExtensions = std::vector<const char*>();
const char* kPortabilitySubsetExtensionName = "VK_KHR_portability_subset";
deviceExtensions.emplace_back( kPortabilitySubsetExtensionName );
VkDeviceQueueCreateInfo QueueInfo;
VkDeviceCreateInfo DeviceInfo;
DeviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
DeviceInfo.queueCreateInfoCount = 1;
DeviceInfo.pQueueCreateInfos=&QueueInfo;
DeviceInfo.enabledExtensionCount=(uint32_t)deviceExtensions.size();
DeviceInfo.ppEnabledExtensionNames=deviceExtensions.data();
VkInstance instance;
VkResult vkResult = vkCreateInstance(&createInfo, nullptr, &instance);
if (vkResult != VK_SUCCESS) {
char* error;
switch (vkResult) {
case VK_ERROR_OUT_OF_HOST_MEMORY:
throw std::runtime_error("Out of memory");
break;
case VK_ERROR_OUT_OF_DEVICE_MEMORY:
throw std::runtime_error("Out of device memory");
break;
case VK_ERROR_INITIALIZATION_FAILED:
throw std::runtime_error("Initialization failed");
break;
case VK_ERROR_LAYER_NOT_PRESENT:
throw std::runtime_error("Layer not present");
break;
case VK_ERROR_EXTENSION_NOT_PRESENT:
throw std::runtime_error("Extension not present");
break;
case VK_ERROR_INCOMPATIBLE_DRIVER:
throw std::runtime_error("Incompatible driver");
break;
default:
throw std::runtime_error("Unknown error");
break;
}
}
uint32_t extensionCount = 0;
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> extensions(extensionCount);
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());
std::cout << "Available extensions:" << std::endl;
for (const auto& extension : extensions) {
std::cout << "t" << extension.extensionName << std::endl;
}
return instance;
}
GLFWwindow* CreateWindow()
{
glfwWindowHint( GLFW_CLIENT_API, GLFW_NO_API );
glfwWindowHint( GLFW_RESIZABLE, GLFW_TRUE );
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
GLFWwindow* window = glfwCreateWindow( 1280, 720, "Window", glfwGetPrimaryMonitor(), nullptr );
return window;
}
where my code crashes –>
GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,
const char* procname)
{
GLFWvkproc proc;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
return NULL;
// NOTE: Vulkan 1.0 and 1.1 vkGetInstanceProcAddr cannot return itself
if (strcmp(procname, "vkGetInstanceProcAddr") == 0)
return (GLFWvkproc) vkGetInstanceProcAddr;
proc = (GLFWvkproc) vkGetInstanceProcAddr(instance, procname);//Line of crash
if (!proc)
{
if (_glfw.vk.handle)
proc = (GLFWvkproc) _glfwPlatformGetModuleSymbol(_glfw.vk.handle, procname);
}
return proc;
}
I have tried manually adding different extensions, but from what i know all the required extensions are already there.
I tried first creating a PFN_vkCreateInstance pfnCreateDevice and PFN_vkCreateInstance PfnCreateInstance but these get the same errors
New contributor
Tibe Cornelis is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
2