summaryrefslogtreecommitdiffstatsci
path: root/tests/common/vkengine.c
diff options
context:
space:
mode:
Diffstat (limited to 'tests/common/vkengine.c')
-rw-r--r--tests/common/vkengine.c319
1 files changed, 146 insertions, 173 deletions
diff --git a/tests/common/vkengine.c b/tests/common/vkengine.c
index 6e8157e..9aac16b 100644
--- a/tests/common/vkengine.c
+++ b/tests/common/vkengine.c
@@ -29,261 +29,234 @@
#include "vkh_device.h"
bool vkeCheckPhyPropBlitSource (VkEngine e) {
- VkFormatProperties formatProps;
- vkGetPhysicalDeviceFormatProperties(e->dev->phy, e->renderer->format, &formatProps);
-
+ VkFormatProperties formatProps;
+ vkGetPhysicalDeviceFormatProperties(e->dev->phy, e->renderer->format, &formatProps);
#ifdef VKVG_TILING_OPTIMAL
- assert((formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT) && "Format cannot be used as transfer source");
+ return formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT;
#else
- assert((formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT) && "Format cannot be used as transfer source");
+ return formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT;
#endif
}
VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts)
{
- if (counts & VK_SAMPLE_COUNT_64_BIT) { return VK_SAMPLE_COUNT_64_BIT; }
- if (counts & VK_SAMPLE_COUNT_32_BIT) { return VK_SAMPLE_COUNT_32_BIT; }
- if (counts & VK_SAMPLE_COUNT_16_BIT) { return VK_SAMPLE_COUNT_16_BIT; }
- if (counts & VK_SAMPLE_COUNT_8_BIT) { return VK_SAMPLE_COUNT_8_BIT; }
- if (counts & VK_SAMPLE_COUNT_4_BIT) { return VK_SAMPLE_COUNT_4_BIT; }
- if (counts & VK_SAMPLE_COUNT_2_BIT) { return VK_SAMPLE_COUNT_2_BIT; }
- return VK_SAMPLE_COUNT_1_BIT;
+ if (counts & VK_SAMPLE_COUNT_64_BIT) { return VK_SAMPLE_COUNT_64_BIT; }
+ if (counts & VK_SAMPLE_COUNT_32_BIT) { return VK_SAMPLE_COUNT_32_BIT; }
+ if (counts & VK_SAMPLE_COUNT_16_BIT) { return VK_SAMPLE_COUNT_16_BIT; }
+ if (counts & VK_SAMPLE_COUNT_8_BIT) { return VK_SAMPLE_COUNT_8_BIT; }
+ if (counts & VK_SAMPLE_COUNT_4_BIT) { return VK_SAMPLE_COUNT_4_BIT; }
+ if (counts & VK_SAMPLE_COUNT_2_BIT) { return VK_SAMPLE_COUNT_2_BIT; }
+ return VK_SAMPLE_COUNT_1_BIT;
}
void vkengine_dump_Infos (VkEngine e){
- printf("max samples = %d\n", getMaxUsableSampleCount(e->gpu_props.limits.framebufferColorSampleCounts));
- printf("max tex2d size = %d\n", e->gpu_props.limits.maxImageDimension2D);
- printf("max tex array layers = %d\n", e->gpu_props.limits.maxImageArrayLayers);
- printf("max mem alloc count = %d\n", e->gpu_props.limits.maxMemoryAllocationCount);
+ printf("max samples = %d\n", getMaxUsableSampleCount(e->gpu_props.limits.framebufferColorSampleCounts));
+ printf("max tex2d size = %d\n", e->gpu_props.limits.maxImageDimension2D);
+ printf("max tex array layers = %d\n", e->gpu_props.limits.maxImageArrayLayers);
+ printf("max mem alloc count = %d\n", e->gpu_props.limits.maxMemoryAllocationCount);
- for (uint32_t i = 0; i < e->memory_properties.memoryHeapCount; i++) {
- printf("Mem Heap %d\n", i);
- printf("\tflags= %d\n", e->memory_properties.memoryHeaps[i].flags);
- printf("\tsize = %lu Mo\n", e->memory_properties.memoryHeaps[i].size/ (uint32_t)(1024*1024));
- }
- for (uint32_t i = 0; i < e->memory_properties.memoryTypeCount; i++) {
- printf("Mem type %d\n", i);
- printf("\theap %d: ", e->memory_properties.memoryTypes[i].heapIndex);
- if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
- printf("VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|");
- if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
- printf("VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|");
- if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
- printf("VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|");
- if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT)
- printf("VK_MEMORY_PROPERTY_HOST_CACHED_BIT|");
- if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
- printf("VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT|");
- printf("\n");
- }
+ for (uint32_t i = 0; i < e->memory_properties.memoryHeapCount; i++) {
+ printf("Mem Heap %d\n", i);
+ printf("\tflags= %d\n", e->memory_properties.memoryHeaps[i].flags);
+ printf("\tsize = %lu Mo\n", (unsigned long)e->memory_properties.memoryHeaps[i].size/ (uint32_t)(1024*1024));
+ }
+ for (uint32_t i = 0; i < e->memory_properties.memoryTypeCount; i++) {
+ printf("Mem type %d\n", i);
+ printf("\theap %d: ", e->memory_properties.memoryTypes[i].heapIndex);
+ if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
+ printf("VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|");
+ if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+ printf("VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|");
+ if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
+ printf("VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|");
+ if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT)
+ printf("VK_MEMORY_PROPERTY_HOST_CACHED_BIT|");
+ if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
+ printf("VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT|");
+ printf("\n");
+ }
}
void vkengine_dump_available_layers () {
- uint32_t layerCount;
- vkEnumerateInstanceLayerProperties(&layerCount, NULL);
+ uint32_t layerCount;
+ vkEnumerateInstanceLayerProperties(&layerCount, NULL);
- VkLayerProperties availableLayers [layerCount];
- vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
+ VkLayerProperties* availableLayers = (VkLayerProperties*)malloc(layerCount*sizeof(VkLayerProperties));
+ vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
- printf("Available Layers:\n");
- printf("-----------------\n");
- for (uint i=0; i<layerCount; i++) {
- printf ("\t - %s\n", availableLayers[i].layerName);
- }
- printf("-----------------\n\n");
+ printf("Available Layers:\n");
+ printf("-----------------\n");
+ for (uint32_t i=0; i<layerCount; i++) {
+ printf ("\t - %s\n", availableLayers[i].layerName);
+ }
+ printf("-----------------\n\n");
+ free (availableLayers);
}
vk_engine_t* vkengine_create (VkPhysicalDeviceType preferedGPU, VkPresentModeKHR presentMode, uint32_t width, uint32_t height) {
- vk_engine_t* e = (vk_engine_t*)calloc(1,sizeof(vk_engine_t));
+ vk_engine_t* e = (vk_engine_t*)calloc(1,sizeof(vk_engine_t));
- glfwInit();
- assert (glfwVulkanSupported()==GLFW_TRUE);
+ glfwInit();
+ assert (glfwVulkanSupported()==GLFW_TRUE);
- uint32_t enabledExtsCount = 0, phyCount = 0;
- const char** gflwExts = glfwGetRequiredInstanceExtensions (&enabledExtsCount);
+ uint32_t enabledExtsCount = 0, phyCount = 0;
+ const char** gflwExts = glfwGetRequiredInstanceExtensions (&enabledExtsCount);
- const char* enabledExts [enabledExtsCount+1];
+ const char* enabledExts [10];
- for (uint i=0;i<enabledExtsCount;i++)
- enabledExts[i] = gflwExts[i];
+ for (uint32_t i=0;i<enabledExtsCount;i++)
+ enabledExts[i] = gflwExts[i];
#ifdef VKVG_USE_RENDERDOC
- const uint32_t enabledLayersCount = 2;
- const char* enabledLayers[] = {"VK_LAYER_KHRONOS_validation", "VK_LAYER_RENDERDOC_Capture"};
+ const uint32_t enabledLayersCount = 2;
+ const char* enabledLayers[] = {"VK_LAYER_KHRONOS_validation", "VK_LAYER_RENDERDOC_Capture"};
#elif defined (VKVG_USE_VALIDATION)
- const uint32_t enabledLayersCount = 1;
- const char* enabledLayers[] = {"VK_LAYER_KHRONOS_validation"};
+ const uint32_t enabledLayersCount = 1;
+ const char* enabledLayers[] = {"VK_LAYER_KHRONOS_validation"};
#else
- const uint32_t enabledLayersCount = 0;
- const char* enabledLayers[] = {NULL};
+ const uint32_t enabledLayersCount = 0;
+ const char* enabledLayers[] = {NULL};
#endif
#ifdef DEBUG
- enabledExts[enabledExtsCount] = "VK_EXT_debug_utils";
- enabledExtsCount++;
+ enabledExts[enabledExtsCount] = "VK_EXT_debug_utils";
+ enabledExtsCount++;
#endif
- e->app = vkh_app_create("vkvgTest", enabledLayersCount, enabledLayers, enabledExtsCount, enabledExts);
+ e->app = vkh_app_create("vkvgTest", enabledLayersCount, enabledLayers, enabledExtsCount, enabledExts);
#ifdef DEBUG
- vkh_app_enable_debug_messenger(e->app
- , VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
- | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
- | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
- , VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
- | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
- //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT
- //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
- , NULL);
+ vkh_app_enable_debug_messenger(e->app
+ , VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
+ | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
+ | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
+ , VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
+ | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
+ //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT
+ //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
+ , NULL);
#endif
- glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
- glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
- glfwWindowHint(GLFW_FLOATING, GLFW_FALSE);
- glfwWindowHint(GLFW_DECORATED, GLFW_TRUE);
-
- e->window = glfwCreateWindow ((int)width, (int)height, "Window Title", NULL, NULL);
+ glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+ glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
+ glfwWindowHint(GLFW_FLOATING, GLFW_FALSE);
+ glfwWindowHint(GLFW_DECORATED, GLFW_TRUE);
- VkSurfaceKHR surf;
- VkResult res = glfwCreateWindowSurface(e->app->inst, e->window, NULL, &surf);
+ e->window = glfwCreateWindow ((int)width, (int)height, "Window Title", NULL, NULL);
- VkhPhyInfo* phys = vkh_app_get_phyinfos (e->app, &phyCount, surf);
+ VkSurfaceKHR surf;
+ VK_CHECK_RESULT (glfwCreateWindowSurface(e->app->inst, e->window, NULL, &surf))
- VkhPhyInfo pi = NULL;
- for (int i=0; i<phyCount; i++){
- pi = phys[i];
- if (pi->properties.deviceType == preferedGPU)
- break;
- }
+ VkhPhyInfo* phys = vkh_app_get_phyinfos (e->app, &phyCount, surf);
- e->memory_properties = pi->memProps;
- e->gpu_props = pi->properties;
+ VkhPhyInfo pi = 0;
+ for (uint32_t i=0; i<phyCount; i++){
+ pi = phys[i];
+ if (pi->properties.deviceType == preferedGPU)
+ break;
+ }
- uint32_t qCount = 0;
- VkDeviceQueueCreateInfo pQueueInfos[3];
- float queue_priorities[] = {0.0};
+ e->memory_properties = pi->memProps;
+ e->gpu_props = pi->properties;
- VkDeviceQueueCreateInfo qiG = { .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
- .queueCount = 1,
- .queueFamilyIndex = pi->gQueue,
- .pQueuePriorities = queue_priorities };
- VkDeviceQueueCreateInfo qiC = { .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
- .queueCount = 1,
- .queueFamilyIndex = pi->cQueue,
- .pQueuePriorities = queue_priorities };
- VkDeviceQueueCreateInfo qiT = { .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
- .queueCount = 1,
- .queueFamilyIndex = pi->tQueue,
- .pQueuePriorities = queue_priorities };
+ uint32_t qCount = 0;
+ float qPriorities[] = {0.0};
- if (pi->gQueue == pi->cQueue){
- if(pi->gQueue == pi->tQueue){
- qCount=1;
- pQueueInfos[0] = qiG;
- }else{
- qCount=2;
- pQueueInfos[0] = qiG;
- pQueueInfos[1] = qiT;
- }
- }else{
- if((pi->gQueue == pi->tQueue) || (pi->cQueue==pi->tQueue)){
- qCount=2;
- pQueueInfos[0] = qiG;
- pQueueInfos[1] = qiC;
- }else{
- qCount=3;
- pQueueInfos[0] = qiG;
- pQueueInfos[1] = qiC;
- pQueueInfos[2] = qiT;
- }
- }
+ VkDeviceQueueCreateInfo pQueueInfos[] = { {0},{0},{0} };
+ if (vkh_phyinfo_create_presentable_queues (pi, 1, qPriorities, &pQueueInfos[qCount]))
+ qCount++;
+ /*if (vkh_phyinfo_create_compute_queues (pi, 1, qPriorities, &pQueueInfos[qCount]))
+ qCount++;
+ if (vkh_phyinfo_create_transfer_queues (pi, 1, qPriorities, &pQueueInfos[qCount]))
+ qCount++;*/
- char const * dex [] = {"VK_KHR_swapchain", "VK_KHR_push_descriptor"};
- enabledExtsCount = 2;
+ char const * dex [] = {"VK_KHR_swapchain", "VK_KHR_push_descriptor"};
+ enabledExtsCount = 2;
- VkPhysicalDeviceFeatures enabledFeatures = {
- .fillModeNonSolid = true,
- //.sampleRateShading = true
- };
+ VkPhysicalDeviceFeatures enabledFeatures = {
+ .fillModeNonSolid = true,
+ //.sampleRateShading = true
+ };
- VkDeviceCreateInfo device_info = { .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
- .queueCreateInfoCount = qCount,
- .pQueueCreateInfos = (VkDeviceQueueCreateInfo*)&pQueueInfos,
- .enabledExtensionCount = enabledExtsCount,
- .ppEnabledExtensionNames = dex,
- .pEnabledFeatures = &enabledFeatures
- };
+ VkDeviceCreateInfo device_info = { .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+ .queueCreateInfoCount = qCount,
+ .pQueueCreateInfos = (VkDeviceQueueCreateInfo*)&pQueueInfos,
+ .enabledExtensionCount = enabledExtsCount,
+ .ppEnabledExtensionNames = dex,
+ .pEnabledFeatures = &enabledFeatures};
- e->dev = vkh_device_create(e->app, pi, &device_info);
+ e->dev = vkh_device_create(e->app, pi, &device_info);
- e->renderer = vkh_presenter_create
- (e->dev, (uint32_t) pi->pQueue, surf, width, height, VK_FORMAT_B8G8R8A8_UNORM, presentMode);
+ e->renderer = vkh_presenter_create
+ (e->dev, (uint32_t) pi->pQueue, surf, width, height, VK_FORMAT_B8G8R8A8_UNORM, presentMode);
- vkh_app_free_phyinfos (phyCount, phys);
+ vkh_app_free_phyinfos (phyCount, phys);
- vkeCheckPhyPropBlitSource (e);
+ vkeCheckPhyPropBlitSource (e);
- return e;
+ return e;
}
void vkengine_destroy (VkEngine e) {
- vkDeviceWaitIdle(e->dev->dev);
+ vkDeviceWaitIdle(e->dev->dev);
- VkSurfaceKHR surf = e->renderer->surface;
+ VkSurfaceKHR surf = e->renderer->surface;
- vkh_presenter_destroy (e->renderer);
- vkDestroySurfaceKHR (e->app->inst, surf, NULL);
+ vkh_presenter_destroy (e->renderer);
+ vkDestroySurfaceKHR (e->app->inst, surf, NULL);
- vkh_device_destroy (e->dev);
+ vkh_device_destroy (e->dev);
- glfwDestroyWindow (e->window);
- glfwTerminate ();
+ glfwDestroyWindow (e->window);
+ glfwTerminate ();
- vkh_app_destroy (e->app);
+ vkh_app_destroy (e->app);
- free(e);
+ free(e);
}
void vkengine_close (VkEngine e) {
- glfwSetWindowShouldClose(e->window, GLFW_TRUE);
+ glfwSetWindowShouldClose(e->window, GLFW_TRUE);
}
void vkengine_blitter_run (VkEngine e, VkImage img, uint32_t width, uint32_t height) {
- VkhPresenter p = e->renderer;
- vkh_presenter_build_blit_cmd (p, img, width, height);
+ VkhPresenter p = e->renderer;
+ vkh_presenter_build_blit_cmd (p, img, width, height);
- while (!vkengine_should_close (e)) {
- glfwPollEvents();
- if (!vkh_presenter_draw (p))
- vkh_presenter_build_blit_cmd (p, img, width, height);
- }
+ while (!vkengine_should_close (e)) {
+ glfwPollEvents();
+ if (!vkh_presenter_draw (p))
+ vkh_presenter_build_blit_cmd (p, img, width, height);
+ }
}
-inline bool vkengine_should_close (VkEngine e) {
- return glfwWindowShouldClose (e->window);
+bool vkengine_should_close (VkEngine e) {
+ return glfwWindowShouldClose (e->window);
+}
+void vkengine_set_title (VkEngine e, const char* title) {
+ glfwSetWindowTitle(e->window, title);
}
-
VkDevice vkengine_get_device (VkEngine e){
- return e->dev->dev;
+ return e->dev->dev;
}
VkPhysicalDevice vkengine_get_physical_device (VkEngine e){
- return e->dev->phy;
+ return e->dev->phy;
}
VkQueue vkengine_get_queue (VkEngine e){
- return e->renderer->queue;
+ return e->renderer->queue;
}
uint32_t vkengine_get_queue_fam_idx (VkEngine e){
- return e->renderer->qFam;
+ return e->renderer->qFam;
}
void vkengine_set_key_callback (VkEngine e, GLFWkeyfun key_callback){
- glfwSetKeyCallback (e->window, key_callback);
+ glfwSetKeyCallback (e->window, key_callback);
}
void vkengine_set_mouse_but_callback (VkEngine e, GLFWmousebuttonfun onMouseBut){
- glfwSetMouseButtonCallback(e->window, onMouseBut);
+ glfwSetMouseButtonCallback(e->window, onMouseBut);
}
void vkengine_set_cursor_pos_callback (VkEngine e, GLFWcursorposfun onMouseMove){
- glfwSetCursorPosCallback(e->window, onMouseMove);
+ glfwSetCursorPosCallback(e->window, onMouseMove);
}
void vkengine_set_scroll_callback (VkEngine e, GLFWscrollfun onScroll){
- glfwSetScrollCallback(e->window, onScroll);
+ glfwSetScrollCallback(e->window, onScroll);
}
void vkengine_set_char_callback (VkEngine e, GLFWcharfun onChar){
- glfwSetCharCallback(e->window, onChar);
+ glfwSetCharCallback(e->window, onChar);
}
generated by cgit v1.3.1-4-g156e (git 2.54.0) at 2026-11-12 13:44:37 +0000