update with vkh changes (VkhPresenter, VkhPhyInfos)

diff --git a/include/vkvg.h b/include/vkvg.h
index d11f64916a343cbf105bec94797ca4a8482308a2..0d2444ffd9b6e914320d84dfaab033a6095770b2 100644 (file)
--- a/include/vkvg.h
+++ b/include/vkvg.h
@@ -117,7 +117,7 @@ typedef struct _vkvg_surface_t* VkvgSurface;
 typedef struct _vkvg_device_t*  VkvgDevice;
 typedef struct _vkvg_pattern_t* VkvgPattern;
 
-VkvgDevice     vkvg_device_create                      (VkPhysicalDevice phy, VkDevice vkdev, VkQueue queue, uint32_t qFam);
+VkvgDevice     vkvg_device_create                      (VkPhysicalDevice phy, VkDevice vkdev);
 void           vkvg_device_destroy                     (VkvgDevice dev);
 VkvgDevice  vkvg_device_reference           (VkvgDevice dev);
 uint32_t    vkvg_device_get_reference_count (VkvgDevice dev);

diff --git a/src/vkvg_context.c b/src/vkvg_context.c
index c2b943fa7464a7ea425b1e07b63331e197d0eda2..aaa6d3018c8660c68948b71c62e031df740acd08 100644 (file)
--- a/src/vkvg_context.c
+++ b/src/vkvg_context.c
@@ -61,12 +61,12 @@ VkvgContext vkvg_create(VkvgSurface surf)
 
     ctx->selectedFont.fontFile = (char*)calloc(FONT_FILE_NAME_MAX_SIZE,sizeof(char));
 
-    ctx->flushFence = vkh_fence_create(dev->vkDev);
+    ctx->flushFence = vkh_fence_create(dev);
 
     ctx->points = (vec2*)       malloc (VKVG_VBO_SIZE*sizeof(vec2));
     ctx->pathes = (uint32_t*)   malloc (VKVG_PATHES_SIZE*sizeof(uint32_t));
 
-    ctx->cmdPool = vkh_cmd_pool_create (dev->vkDev, dev->gQueue->familyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
+    ctx->cmdPool = vkh_cmd_pool_create (dev, dev->gQueue->familyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
 
     _create_vertices_buff   (ctx);
     _create_gradient_buff   (ctx);

diff --git a/src/vkvg_context_internal.c b/src/vkvg_context_internal.c
index 4d28b14e648d9a880d9abad6304e29283b8d189a..67546f179d32b1fa177a85df7383649896ad2ad9 100644 (file)
--- a/src/vkvg_context_internal.c
+++ b/src/vkvg_context_internal.c
@@ -166,7 +166,7 @@ void _vao_add_rectangle (VkvgContext ctx, float x, float y, float width, float h
     _add_tri_indices_for_rect(ctx, firstIdx);
 }
 void _create_cmd_buff (VkvgContext ctx){
-    ctx->cmd = vkh_cmd_buff_create(ctx->pSurf->dev->vkDev, ctx->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+    ctx->cmd = vkh_cmd_buff_create(ctx->pSurf->dev, ctx->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 }
 void _record_draw_cmd (VkvgContext ctx){
     if (ctx->indCount == ctx->curIndStart)

diff --git a/src/vkvg_device.c b/src/vkvg_device.c
index cea8b439dd37fc741134ff3db53b81b89531b64b..de2e42b7d854ea78b19a47a762cf1e7caf98baba 100644 (file)
--- a/src/vkvg_device.c
+++ b/src/vkvg_device.c
@@ -22,26 +22,29 @@
 
 #include "vkvg_device_internal.h"
 #include "vkh_queue.h"
+#include "vkh_phyinfo.h"
 
-VkvgDevice vkvg_device_create(VkPhysicalDevice phy, VkDevice vkdev, VkQueue queue, uint32_t qFam)
+VkvgDevice vkvg_device_create(VkPhysicalDevice phy, VkDevice vkdev)
 {
     VkvgDevice dev = (vkvg_device*)malloc(sizeof(vkvg_device));
 
-    dev->hdpi = 96;
-    dev->vdpi = 96;
+    dev->hdpi   = 96;
+    dev->vdpi   = 96;
+    dev->vkDev  = vkdev;
+    dev->phy    = phy;
 
-    dev->vkDev = vkdev;
-    dev->phy = phy;
+    VkhPhyInfo phyInfos = vkh_phyinfo_create (dev->phy, NULL);
 
-    vkGetPhysicalDeviceMemoryProperties (phy, &dev->phyMemProps);
+    dev->phyMemProps = phyInfos->memProps;
+    dev->gQueue = vkh_queue_create (dev, phyInfos->gQueue, 0, phyInfos->queues[phyInfos->gQueue].queueFlags);
 
-    dev->gQueue = vkh_queue_find (dev, VK_QUEUE_GRAPHICS_BIT);
+    vkh_phyinfo_destroy (phyInfos);
 
     dev->lastCtx= NULL;
 
-    dev->cmdPool= vkh_cmd_pool_create       (dev->vkDev, dev->gQueue->familyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
-    dev->cmd    = vkh_cmd_buff_create       (dev->vkDev, dev->cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
-    dev->fence  = vkh_fence_create_signaled (dev->vkDev);
+    dev->cmdPool= vkh_cmd_pool_create       (dev, dev->gQueue->familyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
+    dev->cmd    = vkh_cmd_buff_create       (dev, dev->cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+    dev->fence  = vkh_fence_create_signaled (dev);
 
     _create_pipeline_cache      (dev);
     _init_fonts_cache           (dev);

diff --git a/src/vkvg_fonts.c b/src/vkvg_fonts.c
index dffc91882b3cffb8a06d23f1c9b62394e7036e96..39b038b22647e9a2bc700a4641579b4a444782f8 100644 (file)
--- a/src/vkvg_fonts.c
+++ b/src/vkvg_fonts.c
@@ -43,7 +43,7 @@ void _init_fonts_cache (VkvgDevice dev){
     vkh_image_create_descriptor (cache->cacheTex, VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_IMAGE_ASPECT_COLOR_BIT,
                                  VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER);
 
-    cache->uploadFence = vkh_fence_create_signaled(dev->vkDev);
+    cache->uploadFence = vkh_fence_create_signaled(dev);
 
     uint32_t buffLength = FONT_PAGE_SIZE*FONT_PAGE_SIZE*sizeof(uint8_t);
     cache->buff = vkh_buffer_create(dev,VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
@@ -51,7 +51,7 @@ void _init_fonts_cache (VkvgDevice dev){
                       buffLength);
     vkh_buffer_map(cache->buff);
 
-    cache->cmd = vkh_cmd_buff_create(dev->vkDev,dev->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+    cache->cmd = vkh_cmd_buff_create(dev,dev->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 
     cache->hostBuff = (uint8_t*)malloc(FONT_PAGE_SIZE*FONT_PAGE_SIZE*sizeof(uint8_t));
     cache->pensY = (int*)calloc(cache->cacheTexLength, sizeof(int));

diff --git a/tests/test1.c b/tests/test1.c
index ef30b3de951c96731962e272f731a950842dde24..db030417c162a16db6a2a41c1c09bfaa7758f5b5 100644 (file)
--- a/tests/test1.c
+++ b/tests/test1.c
@@ -25,6 +25,7 @@
 #include "string.h" //for nanosvg
 #define NANOSVG_IMPLEMENTATION // Expands implementation
 #include "nanosvg.h"
+#include "vkh_device.h"
 
 VkvgDevice device;
 VkvgSurface surf = NULL;
@@ -810,11 +811,20 @@ void cairo_print_arc (VkvgContext cr) {
     vkvg_arc (cr, xc, yc, radius, angle2, angle2);
     vkvg_stroke (cr);
 }
+static float rotation = 0.f;
 void cairo_tests () {
+    rotation+=0.01f;
+
+    vkvg_matrix_t mat;
+    vkvg_matrix_init_translate (&mat, 512,400);
+    vkvg_matrix_rotate(&mat,rotation);
+    vkvg_matrix_translate(&mat,-512,-400);
+
     VkvgContext ctx = vkvg_create(surf);
     vkvg_set_source_rgba(ctx,0.7,0.7,0.7,1);
     vkvg_paint(ctx);
 
+    vkvg_set_matrix(ctx,&mat);
     /*
     vkvg_set_source_rgba(ctx,0,1,0,1);
     vkvg_rectangle(ctx,0,0,600,600);
@@ -980,11 +990,12 @@ int main(int argc, char *argv[]) {
 
     //dumpLayerExts();
 
-    VkEngine* e = vke_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, 1024, 800);
+    vk_engine_t* e = vke_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, 1024, 800);
+    VkhPresenter r = e->renderer;
     vke_set_key_callback (e, key_callback);
 
-    device = vkvg_device_create(e->phy, e->dev, e->renderer.queue, e->renderer.qFam);
-    surf = vkvg_surface_create (device,1024,800);
+    device  = vkvg_device_create (e->dev->phy, e->dev->dev);
+    surf    = vkvg_surface_create(device, 1024, 800);
 
     //test_svg();
 
@@ -992,21 +1003,21 @@ int main(int argc, char *argv[]) {
 
     //test_grad_transforms();
 
-    cairo_tests();
-
     //test_colinear();
 
-    vke_init_blit_renderer(e, vkvg_surface_get_vk_image(surf));
+    vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf));
 
-    while (!glfwWindowShouldClose(e->renderer.window)) {
+    while (!vke_should_close (e)) {
         glfwPollEvents();
-        draw(e, vkvg_surface_get_vk_image(surf));
+        cairo_tests();
+        if (!vkh_presenter_draw (r))
+            vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf));
     }
 
-    vkDeviceWaitIdle(e->dev);
+    vkDeviceWaitIdle(e->dev->dev);
 
-    vkvg_surface_destroy(surf);
-    vkvg_device_destroy(device);
+    vkvg_surface_destroy    (surf);
+    vkvg_device_destroy     (device);
 
     vke_destroy (e);
 

diff --git a/tests/vkengine.c b/tests/vkengine.c
index e93cbd0d48d3c971e405af3a256cf130ceafef5f..4466a17bcbb4f4d150204e5b4cc1c13f65b1f5cc 100644 (file)
--- a/tests/vkengine.c
+++ b/tests/vkengine.c
@@ -24,129 +24,17 @@
 #include "vkh.h"
 #include "vkh_app.h"
 #include "vkh_phyinfo.h"
+#include "vkh_presenter.h"
+#include "vkh_image.h"
+#include "vkh_device.h"
 
 
-bool vkeCheckPhyPropBlitSource (VkEngine *e) {
+bool vkeCheckPhyPropBlitSource (vk_engine_t *e) {
     VkFormatProperties formatProps;
-    vkGetPhysicalDeviceFormatProperties(e->phy, e->renderer.format, &formatProps);
+    vkGetPhysicalDeviceFormatProperties(e->dev->phy, e->renderer->format, &formatProps);
     assert((formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT) && "Format cannot be used as transfer source");
 }
 
-void initPhySurface(VkEngine* e, VkFormat preferedFormat, VkPresentModeKHR presentMode){
-    vkh_presenter* r = &e->renderer;
-
-    uint32_t count;
-    VK_CHECK_RESULT(vkGetPhysicalDeviceSurfaceFormatsKHR (e->phy, r->surface, &count, NULL));
-    assert (count>0);
-    VkSurfaceFormatKHR formats[count];
-    VK_CHECK_RESULT(vkGetPhysicalDeviceSurfaceFormatsKHR (e->phy, r->surface, &count, formats));
-
-    for (int i=0; i<count; i++){
-        if (formats[i].format == preferedFormat) {
-            r->format = formats[i].format;
-            r->colorSpace = formats[i].colorSpace;
-            break;
-        }
-    }
-    assert (r->format != VK_FORMAT_UNDEFINED);
-
-    VK_CHECK_RESULT(vkGetPhysicalDeviceSurfacePresentModesKHR(e->phy, r->surface, &count, NULL));
-    assert (count>0);
-    VkPresentModeKHR presentModes[count];
-    VK_CHECK_RESULT(vkGetPhysicalDeviceSurfacePresentModesKHR(e->phy, r->surface, &count, presentModes));
-    r->presentMode = -1;
-    for (int i=0; i<count; i++){
-        if (presentModes[i] == presentMode) {
-            r->presentMode = presentModes[i];
-            break;
-        }
-    }
-    assert (r->presentMode >= 0);
-}
-
-void vke_swapchain_create (VkEngine* e){
-    // Ensure all operations on the device have been finished before destroying resources
-    vkDeviceWaitIdle(e->dev);
-    vkh_presenter* r = &e->renderer;
-
-    VkSurfaceCapabilitiesKHR surfCapabilities;
-    VK_CHECK_RESULT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(e->phy, r->surface, &surfCapabilities));
-    assert (surfCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT);
-
-
-    // width and height are either both 0xFFFFFFFF, or both not 0xFFFFFFFF.
-    if (surfCapabilities.currentExtent.width == 0xFFFFFFFF) {
-        // If the surface size is undefined, the size is set to
-        // the size of the images requested
-        if (r->width < surfCapabilities.minImageExtent.width)
-            r->width = surfCapabilities.minImageExtent.width;
-        else if (r->width > surfCapabilities.maxImageExtent.width)
-            r->width = surfCapabilities.maxImageExtent.width;
-        if (r->height < surfCapabilities.minImageExtent.height)
-            r->height = surfCapabilities.minImageExtent.height;
-        else if (r->height > surfCapabilities.maxImageExtent.height)
-            r->height = surfCapabilities.maxImageExtent.height;
-    } else {
-        // If the surface size is defined, the swap chain size must match
-        r->width = surfCapabilities.currentExtent.width;
-        r->height= surfCapabilities.currentExtent.height;
-    }
-
-    VkSwapchainKHR newSwapchain;
-    VkSwapchainCreateInfoKHR createInfo = { .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
-                                            .surface = r->surface,
-                                            .minImageCount = surfCapabilities.minImageCount,
-                                            .imageFormat = r->format,
-                                            .imageColorSpace = r->colorSpace,
-                                            .imageExtent = {r->width,r->height},
-                                            .imageArrayLayers = 1,
-                                            .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
-                                            .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
-                                            .preTransform = surfCapabilities.currentTransform,
-                                            .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-                                            .presentMode = r->presentMode,
-                                            .clipped = VK_TRUE,
-                                            .oldSwapchain = r->swapChain};
-
-    VK_CHECK_RESULT(vkCreateSwapchainKHR (e->dev, &createInfo, NULL, &newSwapchain));
-    if (r->swapChain != VK_NULL_HANDLE)
-        vke_swapchain_destroy(r);
-    r->swapChain = newSwapchain;
-
-    VK_CHECK_RESULT(vkGetSwapchainImagesKHR(e->dev, r->swapChain, &r->imgCount, NULL));
-    assert (r->imgCount>0);
-
-    VkImage images[r->imgCount];
-    VK_CHECK_RESULT(vkGetSwapchainImagesKHR(e->dev, r->swapChain, &r->imgCount,images));
-
-    r->ScBuffers = (ImageBuffer*)malloc(sizeof(ImageBuffer)*r->imgCount);
-    r->cmdBuffs = (VkCommandBuffer*)malloc(sizeof(VkCommandBuffer)*r->imgCount);
-
-    for (int i=0; i<r->imgCount; i++) {
-        ImageBuffer sc_buffer = {};
-        VkImageViewCreateInfo createInfo = { .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-                                             .image = images[i],
-                                             .viewType = VK_IMAGE_VIEW_TYPE_2D,
-                                             .format = r->format,
-                                             .components = {VK_COMPONENT_SWIZZLE_R,VK_COMPONENT_SWIZZLE_G,VK_COMPONENT_SWIZZLE_B,VK_COMPONENT_SWIZZLE_A},
-                                             .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT,0,1,0,1}};
-        VK_CHECK_RESULT(vkCreateImageView(e->dev, &createInfo, NULL, &sc_buffer.view));
-        sc_buffer.image = images[i];
-        r->ScBuffers [i] = sc_buffer;
-        r->cmdBuffs [i] = vkh_cmd_buff_create(e->dev, e->renderer.cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
-    }
-    r->currentScBufferIndex = 0;
-}
-void vke_swapchain_destroy (vkh_presenter* r){
-    for (uint32_t i = 0; i < r->imgCount; i++)
-    {
-        vkDestroyImageView (r->dev, r->ScBuffers[i].view, NULL);
-        vkFreeCommandBuffers (r->dev, r->cmdPool, 1, &r->cmdBuffs[i]);
-    }
-    vkDestroySwapchainKHR(r->dev, r->swapChain, NULL);
-    free(r->ScBuffers);
-    free(r->cmdBuffs);
-}
 
 VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts)
 {
@@ -159,7 +47,7 @@ VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts)
     return VK_SAMPLE_COUNT_1_BIT;
 }
 
-void vkengine_dump_Infos (VkEngine* e){
+void vkengine_dump_Infos (vk_engine_t* 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);
@@ -186,13 +74,9 @@ void vkengine_dump_Infos (VkEngine* e){
         printf("\n");
     }
 }
-void vkengine_get_queues_properties (VkEngine* e, VkQueueFamilyProperties** qFamProps, uint32_t* count){
-    vkGetPhysicalDeviceQueueFamilyProperties (e->phy, count, NULL);
-    (*qFamProps) = (VkQueueFamilyProperties*)malloc((*count) * sizeof(VkQueueFamilyProperties));
-    vkGetPhysicalDeviceQueueFamilyProperties (e->phy, count, (*qFamProps));
-}
-VkEngine* vke_create (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t height) {
-    VkEngine* e = (VkEngine*)calloc(1,sizeof(VkEngine));
+vk_engine_t* vke_create (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t height) {
+    vk_engine_t* e = (vk_engine_t*)calloc(1,sizeof(vk_engine_t));
+
     glfwInit();
     assert (glfwVulkanSupported()==GLFW_TRUE);
 
@@ -201,15 +85,24 @@ VkEngine* vke_create (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t
 
     e->app = vkh_app_create("vkvgTest", enabledExtsCount, enabledExts);
 
-    VkhPhyInfo* phys = vkh_app_get_phyinfos(e->app, &phyCount);
+    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+    glfwWindowHint(GLFW_RESIZABLE,  GLFW_TRUE);
+    glfwWindowHint(GLFW_FLOATING,   GLFW_FALSE);
+    glfwWindowHint(GLFW_DECORATED,  GLFW_FALSE);
+
+    e->window = glfwCreateWindow (width, height, "Window Title", NULL, NULL);
+    VkSurfaceKHR surf;
+
+    assert (glfwCreateWindowSurface(e->app->inst, e->window, NULL, &surf)==VK_SUCCESS);
+
+
+    VkhPhyInfo* phys = vkh_app_get_phyinfos (e->app, &phyCount, surf);
 
     VkhPhyInfo pi = NULL;
     for (int i=0; i<phyCount; i++){
         pi = phys[i];
-        if (pi->properties.deviceType == preferedGPU){
-            e->phy = pi->phy;
+        if (pi->properties.deviceType == preferedGPU)
             break;
-        }
     }
 
     e->memory_properties = pi->memProps;
@@ -272,66 +165,30 @@ VkEngine* vke_create (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t
                                        .ppEnabledExtensionNames = dex
                                      };
 
-    VK_CHECK_RESULT(vkCreateDevice(e->phy, &device_info, NULL, &e->dev));
+    VkDevice dev;
+    VK_CHECK_RESULT(vkCreateDevice (pi->phy, &device_info, NULL, &dev));
+    e->dev = vkh_device_create(pi->phy, dev);
 
+    e->renderer = vkh_presenter_create
+            (e->dev, pi->pQueue, surf, width, height, VK_FORMAT_B8G8R8A8_UNORM, VK_PRESENT_MODE_FIFO_KHR);
 
-    assert (glfwGetPhysicalDevicePresentationSupport (e->app->inst, e->phy, pi->gQueue)==GLFW_TRUE);
-
-    e->renderer.width = width;
-    e->renderer.height = height;
-
-    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
-    glfwWindowHint(GLFW_RESIZABLE,  GLFW_TRUE);
-    glfwWindowHint(GLFW_FLOATING,   GLFW_FALSE);
-    glfwWindowHint(GLFW_DECORATED,  GLFW_FALSE);
-
-    vkh_presenter* r = &e->renderer;
-    r->dev = e->dev;
-
-    r->window = glfwCreateWindow(r->width, r->height, "Window Title", NULL, NULL);
-
-    assert (glfwCreateWindowSurface(e->app->inst, r->window, NULL, &r->surface)==VK_SUCCESS);
-
-    VkBool32 isSupported;
-    vkGetPhysicalDeviceSurfaceSupportKHR(e->phy, pi->gQueue, r->surface, &isSupported);
-    assert (isSupported && "vkGetPhysicalDeviceSurfaceSupportKHR");
-
-    vkGetDeviceQueue(e->dev, pi->gQueue, 0, &e->renderer.queue);
-    e->renderer.qFam = pi->gQueue;
-    vkGetDeviceQueue(e->dev, pi->cQueue, 0, &e->computer.queue);
-    vkGetDeviceQueue(e->dev, pi->tQueue, 0, &e->loader.queue);
-
-    e->renderer.cmdPool = vkh_cmd_pool_create (e->dev, pi->gQueue, 0);
-    e->computer.cmdPool = vkh_cmd_pool_create (e->dev, pi->cQueue, 0);
-    e->loader.cmdPool = vkh_cmd_pool_create (e->dev, pi->tQueue, 0);
 
     vkh_app_free_phyinfos (phyCount, phys);
 
-    r->semaPresentEnd = vkh_semaphore_create(e->dev);
-    r->semaDrawEnd = vkh_semaphore_create(e->dev);
-
-    initPhySurface(e,VK_FORMAT_B8G8R8A8_UNORM,VK_PRESENT_MODE_FIFO_KHR);
-
-    vke_swapchain_create(e);
 
     return e;
 }
 
-void vke_destroy (VkEngine* e) {
-    vkDeviceWaitIdle(e->dev);
-    vkh_presenter* r = &e->renderer;
-    vke_swapchain_destroy(r);
+void vke_destroy (vk_engine_t* e) {
+    vkDeviceWaitIdle(e->dev->dev);
 
-    vkDestroySemaphore(e->dev, r->semaDrawEnd, NULL);
-    vkDestroySemaphore(e->dev, r->semaPresentEnd, NULL);
+    vkDestroySurfaceKHR (e->app->inst, e->renderer->surface, NULL);
 
-    vkDestroyCommandPool (e->dev, e->renderer.cmdPool, NULL);
-    vkDestroyCommandPool (e->dev, e->computer.cmdPool, NULL);
-    vkDestroyCommandPool (e->dev, e->loader.cmdPool, NULL);
+    vkh_presenter_destroy (e->renderer);
 
-    vkDestroyDevice (e->dev, NULL);
-    vkDestroySurfaceKHR (e->app->inst, r->surface, NULL);
-    glfwDestroyWindow (r->window);
+    vkDestroyDevice (e->dev->dev, NULL);
+
+    glfwDestroyWindow (e->window);
     glfwTerminate ();
 
     vkh_app_destroy (e->app);
@@ -352,75 +209,11 @@ static void char_callback (GLFWwindow* window, uint32_t c){}
 static void mouse_move_callback(GLFWwindow* window, double x, double y){}
 static void mouse_button_callback(GLFWwindow* window, int but, int state, int modif){}
 
-void vke_set_key_callback (VkEngine* e, GLFWkeyfun key_callback){
-    glfwSetKeyCallback(e->renderer.window, key_callback);
+inline bool vke_should_close (vk_engine_t* e) {
+    return glfwWindowShouldClose (e->window);
+}
+void vke_set_key_callback (vk_engine_t* e, GLFWkeyfun key_callback){
+    glfwSetKeyCallback (e->window, key_callback);
 }
-void vke_init_blit_renderer(VkEngine* e, VkImage blitSource){
-    vkh_presenter* r = &e->renderer;
-    for (int32_t i = 0; i < r->imgCount; ++i)
-    {
-        VkImage bltDstImage = r->ScBuffers[i].image;
-
-        VkCommandBuffer cb = r->cmdBuffs[i];
-        vkh_cmd_begin(cb,VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
-
-        set_image_layout(cb, bltDstImage, VK_IMAGE_ASPECT_COLOR_BIT,
-                VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
-
-        set_image_layout(cb, blitSource, VK_IMAGE_ASPECT_COLOR_BIT,
-                VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
-
-        VkImageCopy cregion = { .srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
-                                .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
-                                .srcOffset = {},
-                                .dstOffset = {0,0,0},
-                                .extent = {1024,800,1}};
-
-        vkCmdCopyImage(cb, blitSource, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, bltDstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                       1, &cregion);
 
-        set_image_layout(cb, bltDstImage, VK_IMAGE_ASPECT_COLOR_BIT,
-                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-                         VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
 
-        vkh_cmd_end(cb);
-    }
-}
-void submitCommandBuffer(VkQueue queue, VkCommandBuffer *pCmdBuff, VkSemaphore* pWaitSemaphore, VkSemaphore* pSignalSemaphore){
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-    VkSubmitInfo submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
-                                 .commandBufferCount = 1,
-                                 .signalSemaphoreCount = 1,
-                                 .pSignalSemaphores = pSignalSemaphore,
-                                 .waitSemaphoreCount = 1,
-                                 .pWaitSemaphores = pWaitSemaphore,
-                                 .pWaitDstStageMask = &dstStageMask,
-                                 .pCommandBuffers = pCmdBuff};
-    VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submit_info, NULL));
-}
-void draw(VkEngine* e, VkImage blitSource) {
-    vkh_presenter* r = &e->renderer;
-    // Get the index of the next available swapchain image:
-    VkResult err = vkAcquireNextImageKHR(e->dev, r->swapChain, UINT64_MAX, r->semaPresentEnd, VK_NULL_HANDLE,
-                                &r->currentScBufferIndex);
-    if ((err == VK_ERROR_OUT_OF_DATE_KHR) || (err == VK_SUBOPTIMAL_KHR)){
-        vke_swapchain_create(e);
-        vke_init_blit_renderer(e, blitSource);
-    }else{
-        VK_CHECK_RESULT(err);
-        submitCommandBuffer (r->queue, &r->cmdBuffs[r->currentScBufferIndex], &r->semaPresentEnd, &r->semaDrawEnd);
-
-        /* Now present the image in the window */
-        VkPresentInfoKHR present = { .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
-                                     .swapchainCount = 1,
-                                     .pSwapchains = &r->swapChain,
-                                     .waitSemaphoreCount = 1,
-                                     .pWaitSemaphores = &r->semaDrawEnd,
-                                     .pImageIndices = &r->currentScBufferIndex };
-
-        /* Make sure command buffer is finished before presenting */
-        VK_CHECK_RESULT(vkQueuePresentKHR(r->queue, &present));
-    }
-}

diff --git a/tests/vkengine.h b/tests/vkengine.h
index 3efdb8982ead13907e27734347bc87160301ed96..62bc2a29320853b0404018a86ac481784ea7c85e 100644 (file)
--- a/tests/vkengine.h
+++ b/tests/vkengine.h
@@ -36,73 +36,31 @@
 /* renderpass creation and pipeline creation.                     */
 #define FENCE_TIMEOUT 100000000
 
-typedef struct ImageBuffer_t {
-    VkImage     image;
-    VkImageView view;
-}ImageBuffer;
 
-typedef struct vkh_presenter_t {
-    VkQueue         queue;
-    VkCommandPool   cmdPool;
-    uint32_t        qFam;
-    VkDevice        dev;
-
-    GLFWwindow*     window;
-    VkSurfaceKHR    surface;
-
-    VkSemaphore     semaPresentEnd;
-    VkSemaphore     semaDrawEnd;
-
-    VkFormat        format;
-    VkColorSpaceKHR colorSpace;
-    VkPresentModeKHR presentMode;
-    uint32_t        width;
-    uint32_t        height;
-
-    uint32_t        imgCount;
-    uint32_t        currentScBufferIndex;
-
-    VkRenderPass    renderPass;
-    VkSwapchainKHR  swapChain;
-    ImageBuffer*    ScBuffers;
-    VkCommandBuffer* cmdBuffs;
-    VkFramebuffer*  frameBuffs;
-}vkh_presenter;
-
-typedef struct VkLoader_t {
-    VkQueue queue;
-    VkCommandPool cmdPool;
-}VkLoader;
-
-typedef struct VkComputer_t {
-    VkQueue queue;
-    VkCommandPool cmdPool;
-}VkComputer;
-
-typedef struct VkEngine_t {
+typedef struct _vk_engine_t {
     VkhApp              app;
-    VkPhysicalDevice    phy;
     VkPhysicalDeviceMemoryProperties    memory_properties;
     VkPhysicalDeviceProperties          gpu_props;
-    VkDevice            dev;
+    VkhDevice           dev;
+    GLFWwindow*         window;
 
-    vkh_presenter       renderer;
-    VkComputer          computer;
-    VkLoader            loader;
-}VkEngine;
+    VkhPresenter        renderer;
+}vk_engine_t;
 
-VkEngine*   vke_create  (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t height);
-void        vke_destroy (VkEngine* e);
+vk_engine_t*   vke_create  (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t height);
+void        vke_destroy (vk_engine_t* e);
 
-void initPhySurface(VkEngine* e, VkFormat preferedFormat, VkPresentModeKHR presentMode);
+void initPhySurface(VkhPresenter r, VkFormat preferedFormat, VkPresentModeKHR presentMode);
 
 VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts);
 
-void vkengine_dump_Infos (VkEngine* e);
-void vkengine_get_queues_properties (VkEngine* e, VkQueueFamilyProperties** qFamProps, uint32_t* count);
+void vkengine_dump_Infos (vk_engine_t* e);
+void vkengine_get_queues_properties (vk_engine_t* e, VkQueueFamilyProperties** qFamProps, uint32_t* count);
+
 
+//void vke_init_blit_renderer (VkhPresenter r, VkImage blitSource);
+bool vke_should_close       (vk_engine_t* e);
 
-void vke_init_blit_renderer(VkEngine* e, VkImage blitSource);
-void submitCommandBuffer(VkQueue queue, VkCommandBuffer *pCmdBuff, VkSemaphore* pWaitSemaphore, VkSemaphore* pSignalSemaphore);
-void draw(VkEngine* e, VkImage blitSource);
+//void submitCommandBuffer(VkQueue queue, VkCommandBuffer *pCmdBuff, VkSemaphore* pWaitSemaphore, VkSemaphore* pSignalSemaphore);
+//void draw(vk_engine_t* e, VkImage blitSource);
 #endif

diff --git a/vkh b/vkh
index d54f6f1c5b8847fe75431e9fd2e70e4aeb7462b9..2f95a96a10b27bed90961f0e2b8390beb7b99f58 160000 (submodule)
--- a/vkh
+++ b/vkh
@@ -1 +1 @@
-Subproject commit d54f6f1c5b8847fe75431e9fd2e70e4aeb7462b9
+Subproject commit 2f95a96a10b27bed90961f0e2b8390beb7b99f58