mirror/vk-bootstrap
1
0
Fork 0
mirror of https://github.com/charles-lunarg/vk-bootstrap.git synced 2024-11-30 02:14:35 +00:00
Code Issues Packages Projects Releases Wiki Activity
v0.3
vk-bootstrap/tests/common.h

168 lines
7.5 KiB
C
Raw Permalink Normal View History

Fixed up swapchain, added an example based on vulkan-tutorial Now there is a concise example of the library in use all the way to presenting. Needs to be rewritten to remove exceptions, but for first pass its good enough.
2020-02-03 23:23:47 +00:00
#pragma once
#include <stdio.h>
#include <memory>
#include <iostream>
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#if defined(_WIN32)
#include <fcntl.h>
#define NOMINMAX
#include <windows.h>
#endif // _WIN32
#if defined(__linux__) || defined(__APPLE__)
#include <dlfcn.h>
#endif
Fixed up swapchain, added an example based on vulkan-tutorial Now there is a concise example of the library in use all the way to presenting. Needs to be rewritten to remove exceptions, but for first pass its good enough.
2020-02-03 23:23:47 +00:00
#define GLFW_INCLUDE_VULKAN
#include "GLFW/glfw3.h"
#include "../src/VkBootstrap.h"
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
GLFWwindow* create_window_glfw(const char* window_name = "", bool resize = true) {
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
if (!resize) glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
moved triangle.cpp to its own folder, updated readme & license
2020-02-04 03:34:46 +00:00
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
return glfwCreateWindow(1024, 1024, window_name, NULL, NULL);
Fixed up swapchain, added an example based on vulkan-tutorial Now there is a concise example of the library in use all the way to presenting. Needs to be rewritten to remove exceptions, but for first pass its good enough.
2020-02-03 23:23:47 +00:00
}
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
void destroy_window_glfw(GLFWwindow* window) {
glfwDestroyWindow(window);
glfwTerminate();
Fixed up swapchain, added an example based on vulkan-tutorial Now there is a concise example of the library in use all the way to presenting. Needs to be rewritten to remove exceptions, but for first pass its good enough.
2020-02-03 23:23:47 +00:00
}
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
VkSurfaceKHR create_surface_glfw(VkInstance instance, GLFWwindow* window) {
test: Use VK_NULL_HANDLE to enable 32 bit builds
2021-03-01 22:32:26 +00:00
VkSurfaceKHR surface = VK_NULL_HANDLE;
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
VkResult err = glfwCreateWindowSurface(instance, window, NULL, &surface);
Implemented missing instance functions, deleted surface in tests.
2020-02-18 22:18:08 +00:00
if (err) {
Fixed up swapchain, added an example based on vulkan-tutorial Now there is a concise example of the library in use all the way to presenting. Needs to be rewritten to remove exceptions, but for first pass its good enough.
2020-02-03 23:23:47 +00:00
const char* error_msg;
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
int ret = glfwGetError(&error_msg);
Implemented missing instance functions, deleted surface in tests.
2020-02-18 22:18:08 +00:00
if (ret != 0) {
Fixed up swapchain, added an example based on vulkan-tutorial Now there is a concise example of the library in use all the way to presenting. Needs to be rewritten to remove exceptions, but for first pass its good enough.
2020-02-03 23:23:47 +00:00
std::cout << ret << " ";
if (error_msg != nullptr) std::cout << error_msg;
std::cout << "\n";
}
test: Use VK_NULL_HANDLE to enable 32 bit builds
2021-03-01 22:32:26 +00:00
surface = VK_NULL_HANDLE;
Fixed up swapchain, added an example based on vulkan-tutorial Now there is a concise example of the library in use all the way to presenting. Needs to be rewritten to remove exceptions, but for first pass its good enough.
2020-02-03 23:23:47 +00:00
}
return surface;
Implemented missing instance functions, deleted surface in tests.
2020-02-18 22:18:08 +00:00
}
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
struct VulkanLibrary {
#if defined(__linux__) || defined(__APPLE__)
void* library;
#elif defined(_WIN32)
HMODULE library;
#endif
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
VulkanLibrary() {
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#if defined(__linux__)
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL);
if (!library) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#elif defined(__APPLE__)
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
if (!library) library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#elif defined(_WIN32)
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
library = LoadLibrary(TEXT("vulkan-1.dll"));
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#else
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
assert(false && "Unsupported platform");
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#endif
if (!library) return;
#if defined(__linux__) || defined(__APPLE__)
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
vkGetInstanceProcAddr =
reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(library, "vkGetInstanceProcAddr"));
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#elif defined(_WIN32)
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
vkGetInstanceProcAddr =
reinterpret_cast<PFN_vkGetInstanceProcAddr>(GetProcAddress(library, "vkGetInstanceProcAddr"));
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#endif
}
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
void close() {
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#if defined(__linux__) || defined(__APPLE__)
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
dlclose(library);
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#elif defined(_WIN32)
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
FreeLibrary(library);
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
#endif
library = 0;
}
cmake: Don't require vulkan in order to build find_package is used to try to find the Vulkan-Headers, and if they aren't present, it downloads them with fetch content. This way users don't need vulkan 'installed' on their system, specifically for windows users. It also changes the tests to load all the necessary function pointers, that way we don't need to find the vulkan loader to build the tests.
2021-03-01 22:21:45 +00:00
void init(VkInstance instance) {
vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr");
}
void init(VkDevice device) {
vkCreateRenderPass = (PFN_vkCreateRenderPass)vkGetDeviceProcAddr(device, "vkCreateRenderPass");
vkCreateShaderModule = (PFN_vkCreateShaderModule)vkGetDeviceProcAddr(device, "vkCreateShaderModule");
vkCreatePipelineLayout =
(PFN_vkCreatePipelineLayout)vkGetDeviceProcAddr(device, "vkCreatePipelineLayout");
vkCreateGraphicsPipelines =
(PFN_vkCreateGraphicsPipelines)vkGetDeviceProcAddr(device, "vkCreateGraphicsPipelines");
vkDestroyShaderModule = (PFN_vkDestroyShaderModule)vkGetDeviceProcAddr(device, "vkDestroyShaderModule");
vkCreateFramebuffer = (PFN_vkCreateFramebuffer)vkGetDeviceProcAddr(device, "vkCreateFramebuffer");
vkCreateCommandPool = (PFN_vkCreateCommandPool)vkGetDeviceProcAddr(device, "vkCreateCommandPool");
vkAllocateCommandBuffers =
(PFN_vkAllocateCommandBuffers)vkGetDeviceProcAddr(device, "vkAllocateCommandBuffers");
vkBeginCommandBuffer = (PFN_vkBeginCommandBuffer)vkGetDeviceProcAddr(device, "vkBeginCommandBuffer");
vkEndCommandBuffer = (PFN_vkEndCommandBuffer)vkGetDeviceProcAddr(device, "vkEndCommandBuffer");
vkCmdSetViewport = (PFN_vkCmdSetViewport)vkGetDeviceProcAddr(device, "vkCmdSetViewport");
vkCmdSetScissor = (PFN_vkCmdSetScissor)vkGetDeviceProcAddr(device, "vkCmdSetScissor");
vkCmdBeginRenderPass = (PFN_vkCmdBeginRenderPass)vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass");
vkCmdEndRenderPass = (PFN_vkCmdEndRenderPass)vkGetDeviceProcAddr(device, "vkCmdEndRenderPass");
vkCmdBindPipeline = (PFN_vkCmdBindPipeline)vkGetDeviceProcAddr(device, "vkCmdBindPipeline");
vkCmdDraw = (PFN_vkCmdDraw)vkGetDeviceProcAddr(device, "vkCmdDraw");
vkCreateSemaphore = (PFN_vkCreateSemaphore)vkGetDeviceProcAddr(device, "vkCreateSemaphore");
vkCreateFence = (PFN_vkCreateFence)vkGetDeviceProcAddr(device, "vkCreateFence");
vkDeviceWaitIdle = (PFN_vkDeviceWaitIdle)vkGetDeviceProcAddr(device, "vkDeviceWaitIdle");
vkDestroyCommandPool = (PFN_vkDestroyCommandPool)vkGetDeviceProcAddr(device, "vkDestroyCommandPool");
vkDestroyFramebuffer = (PFN_vkDestroyFramebuffer)vkGetDeviceProcAddr(device, "vkDestroyFramebuffer");
vkWaitForFences = (PFN_vkWaitForFences)vkGetDeviceProcAddr(device, "vkWaitForFences");
vkAcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)vkGetDeviceProcAddr(device, "vkAcquireNextImageKHR");
vkResetFences = (PFN_vkResetFences)vkGetDeviceProcAddr(device, "vkResetFences");
vkQueueSubmit = (PFN_vkQueueSubmit)vkGetDeviceProcAddr(device, "vkQueueSubmit");
vkQueuePresentKHR = (PFN_vkQueuePresentKHR)vkGetDeviceProcAddr(device, "vkQueuePresentKHR");
vkDestroySemaphore = (PFN_vkDestroySemaphore)vkGetDeviceProcAddr(device, "vkDestroySemaphore");
vkDestroyFence = (PFN_vkDestroyFence)vkGetDeviceProcAddr(device, "vkDestroyFence");
vkDestroyPipeline = (PFN_vkDestroyPipeline)vkGetDeviceProcAddr(device, "vkDestroyPipeline");
vkDestroyPipelineLayout =
(PFN_vkDestroyPipelineLayout)vkGetDeviceProcAddr(device, "vkDestroyPipelineLayout");
vkDestroySurfaceKHR = (PFN_vkDestroySurfaceKHR)vkGetDeviceProcAddr(device, "vkDestroySurfaceKHR");
vkDestroyRenderPass = (PFN_vkDestroyRenderPass)vkGetDeviceProcAddr(device, "vkDestroyRenderPass");
}
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = VK_NULL_HANDLE;
PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = VK_NULL_HANDLE;
PFN_vkCreateRenderPass vkCreateRenderPass = VK_NULL_HANDLE;
PFN_vkCreateShaderModule vkCreateShaderModule = VK_NULL_HANDLE;
PFN_vkCreatePipelineLayout vkCreatePipelineLayout = VK_NULL_HANDLE;
PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = VK_NULL_HANDLE;
PFN_vkDestroyShaderModule vkDestroyShaderModule = VK_NULL_HANDLE;
PFN_vkCreateFramebuffer vkCreateFramebuffer = VK_NULL_HANDLE;
PFN_vkCreateCommandPool vkCreateCommandPool = VK_NULL_HANDLE;
PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = VK_NULL_HANDLE;
PFN_vkBeginCommandBuffer vkBeginCommandBuffer = VK_NULL_HANDLE;
PFN_vkEndCommandBuffer vkEndCommandBuffer = VK_NULL_HANDLE;
PFN_vkCmdSetViewport vkCmdSetViewport = VK_NULL_HANDLE;
PFN_vkCmdSetScissor vkCmdSetScissor = VK_NULL_HANDLE;
PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = VK_NULL_HANDLE;
PFN_vkCmdEndRenderPass vkCmdEndRenderPass = VK_NULL_HANDLE;
PFN_vkCmdBindPipeline vkCmdBindPipeline = VK_NULL_HANDLE;
PFN_vkCmdDraw vkCmdDraw = VK_NULL_HANDLE;
PFN_vkCreateSemaphore vkCreateSemaphore = VK_NULL_HANDLE;
PFN_vkCreateFence vkCreateFence = VK_NULL_HANDLE;
PFN_vkDeviceWaitIdle vkDeviceWaitIdle = VK_NULL_HANDLE;
PFN_vkDestroyCommandPool vkDestroyCommandPool = VK_NULL_HANDLE;
PFN_vkDestroyFramebuffer vkDestroyFramebuffer = VK_NULL_HANDLE;
PFN_vkWaitForFences vkWaitForFences = VK_NULL_HANDLE;
PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = VK_NULL_HANDLE;
PFN_vkResetFences vkResetFences = VK_NULL_HANDLE;
PFN_vkQueueSubmit vkQueueSubmit = VK_NULL_HANDLE;
PFN_vkQueuePresentKHR vkQueuePresentKHR = VK_NULL_HANDLE;
PFN_vkDestroySemaphore vkDestroySemaphore = VK_NULL_HANDLE;
PFN_vkDestroyFence vkDestroyFence = VK_NULL_HANDLE;
PFN_vkDestroyPipeline vkDestroyPipeline = VK_NULL_HANDLE;
PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = VK_NULL_HANDLE;
PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = VK_NULL_HANDLE;
PFN_vkDestroyRenderPass vkDestroyRenderPass = VK_NULL_HANDLE;
Dynamically load vulkan instead of statically link. Make vk-bootstrap capable of loading the vulkan runtime and not need to link against the library. This improves the usability of vk-bootstrap since now you don't need the vulkan library on your system to build. This commit also changes how SystemInfo works so as to allow the dynamic vulkan loading.
2020-06-17 23:13:39 +00:00
};
Reference in New Issue Copy Permalink