improve VK_IMAGE_LAYOUT handling, solves several problems with multiple drivers ...

diff --git a/include/vkvg.h b/include/vkvg.h
index 0d2444ffd9b6e914320d84dfaab033a6095770b2..110077e0af6ceed650ab8025f0e8f0ea7b0df2fe 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);
+VkvgDevice     vkvg_device_create                      (VkPhysicalDevice phy, VkDevice vkdev, uint32_t qFamIdx, uint32_t qIndex);
 void           vkvg_device_destroy                     (VkvgDevice dev);
 VkvgDevice  vkvg_device_reference           (VkvgDevice dev);
 uint32_t    vkvg_device_get_reference_count (VkvgDevice dev);
@@ -209,6 +209,7 @@ float               vkvg_get_line_width     (VkvgContext ctx);
 vkvg_line_cap_t     vkvg_get_line_cap       (VkvgContext ctx);
 vkvg_line_join_t    vkvg_get_line_join      (VkvgContext ctx);
 vkvg_operator_t     vkvg_get_operator       (VkvgContext ctx);
+VkvgPattern         vkvg_get_source         (VkvgContext ctx);
 
 void vkvg_save              (VkvgContext ctx);
 void vkvg_restore           (VkvgContext ctx);

diff --git a/src/vkvg_context.c b/src/vkvg_context.c
index aaa6d3018c8660c68948b71c62e031df740acd08..03b0aeebe591637db95c4680dc160419f7adefd5 100644 (file)
--- a/src/vkvg_context.c
+++ b/src/vkvg_context.c
@@ -121,6 +121,9 @@ void vkvg_destroy (VkvgContext ctx)
 
     _flush_cmd_buff(ctx);
 
+    if (ctx->pattern)
+        vkvg_pattern_destroy (ctx->pattern);
+
     VkDevice dev = ctx->pSurf->dev->vkDev;
 
     vkDestroyFence      (dev, ctx->flushFence,NULL);
@@ -561,6 +564,10 @@ vkvg_line_join_t vkvg_get_line_join (VkvgContext ctx){
 vkvg_operator_t vkvg_get_operator (VkvgContext ctx){
     return ctx->curOperator;
 }
+VkvgPattern vkvg_get_source (VkvgContext ctx){
+    vkvg_pattern_reference (ctx->pattern);
+    return ctx->pattern;
+}
 
 void vkvg_select_font_face (VkvgContext ctx, const char* name){
     _select_font_face (ctx, name);
@@ -598,9 +605,9 @@ void vkvg_save (VkvgContext ctx){
     vkh_cmd_begin (ctx->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
 
     vkh_image_set_layout (ctx->cmd, ctx->pSurf->stencilMS, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
     vkh_image_set_layout (ctx->cmd, sav->stencilMS, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
     VkImageCopy cregion = { .srcSubresource = {VK_IMAGE_ASPECT_STENCIL_BIT, 0, 0, 1},
                             .dstSubresource = {VK_IMAGE_ASPECT_STENCIL_BIT, 0, 0, 1},
@@ -611,7 +618,7 @@ void vkvg_save (VkvgContext ctx){
                    1, &cregion);
 
     vkh_image_set_layout (ctx->cmd, ctx->pSurf->stencilMS, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+          VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT);
 
     VK_CHECK_RESULT(vkEndCommandBuffer(ctx->cmd));
     _submit_ctx_cmd(ctx);
@@ -667,9 +674,9 @@ void vkvg_restore (VkvgContext ctx){
     vkh_cmd_begin (ctx->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
 
     vkh_image_set_layout (ctx->cmd, ctx->pSurf->stencilMS, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
     vkh_image_set_layout (ctx->cmd, sav->stencilMS, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
     VkImageCopy cregion = { .srcSubresource = {VK_IMAGE_ASPECT_STENCIL_BIT, 0, 0, 1},
                             .dstSubresource = {VK_IMAGE_ASPECT_STENCIL_BIT, 0, 0, 1},
@@ -679,7 +686,7 @@ void vkvg_restore (VkvgContext ctx){
                    vkh_image_get_vkimage (ctx->pSurf->stencilMS),VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                    1, &cregion);
     vkh_image_set_layout (ctx->cmd, ctx->pSurf->stencilMS, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+          VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT);
 
     VK_CHECK_RESULT(vkEndCommandBuffer(ctx->cmd));
     _submit_ctx_cmd(ctx);

diff --git a/src/vkvg_context_internal.c b/src/vkvg_context_internal.c
index 67546f179d32b1fa177a85df7383649896ad2ad9..5b6e5e7bab8e3c55802b38b16c1d9c93a26ded12 100644 (file)
--- a/src/vkvg_context_internal.c
+++ b/src/vkvg_context_internal.c
@@ -197,9 +197,9 @@ inline void _submit_wait_and_reset_cmd (VkvgContext ctx){
 }
 void _explicit_ms_resolve (VkvgContext ctx){
     vkh_image_set_layout (ctx->cmd, ctx->pSurf->imgMS, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
     vkh_image_set_layout (ctx->cmd, ctx->pSurf->img, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
     VkImageResolve re = {
         .extent = {ctx->pSurf->width, ctx->pSurf->height,1},
@@ -212,7 +212,7 @@ void _explicit_ms_resolve (VkvgContext ctx){
                       vkh_image_get_vkimage (ctx->pSurf->img) ,VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                       1,&re);
     vkh_image_set_layout (ctx->cmd, ctx->pSurf->imgMS, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL ,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
 }
 
 void _flush_cmd_buff (VkvgContext ctx){
@@ -343,7 +343,7 @@ void _update_cur_pattern (VkvgContext ctx, VkvgPattern pat) {
             vkh_cmd_begin (ctx->cmd,VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
 
             vkh_image_set_layout        (ctx->cmd, ctx->source, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+                    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
             vkh_cmd_end                 (ctx->cmd);
 
             _submit_wait_and_reset_cmd  (ctx);

diff --git a/src/vkvg_device.c b/src/vkvg_device.c
index de2e42b7d854ea78b19a47a762cf1e7caf98baba..1edb6e474d8034d0ed98102ffe80efa41e8b0f3b 100644 (file)
--- a/src/vkvg_device.c
+++ b/src/vkvg_device.c
@@ -24,7 +24,7 @@
 #include "vkh_queue.h"
 #include "vkh_phyinfo.h"
 
-VkvgDevice vkvg_device_create(VkPhysicalDevice phy, VkDevice vkdev)
+VkvgDevice vkvg_device_create(VkPhysicalDevice phy, VkDevice vkdev, uint32_t qFamIdx, uint32_t qIndex)
 {
     VkvgDevice dev = (vkvg_device*)malloc(sizeof(vkvg_device));
 
@@ -36,7 +36,7 @@ VkvgDevice vkvg_device_create(VkPhysicalDevice phy, VkDevice vkdev)
     VkhPhyInfo phyInfos = vkh_phyinfo_create (dev->phy, NULL);
 
     dev->phyMemProps = phyInfos->memProps;
-    dev->gQueue = vkh_queue_create (dev, phyInfos->gQueue, 0, phyInfos->queues[phyInfos->gQueue].queueFlags);
+    dev->gQueue = vkh_queue_create (dev, qFamIdx, qIndex, phyInfos->queues[qFamIdx].queueFlags);
 
     vkh_phyinfo_destroy (phyInfos);
 
@@ -46,7 +46,7 @@ VkvgDevice vkvg_device_create(VkPhysicalDevice phy, VkDevice vkdev)
     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);
+    //_create_pipeline_cache      (dev);
     _init_fonts_cache           (dev);
     _setupRenderPass            (dev);
     _createDescriptorSetLayout  (dev);
@@ -78,7 +78,7 @@ void vkvg_device_destroy (VkvgDevice dev)
     vkDestroyPipeline               (dev->vkDev, dev->pipelineLineList, NULL);
 
     vkDestroyPipelineLayout         (dev->vkDev, dev->pipelineLayout, NULL);
-    vkDestroyPipelineCache          (dev->vkDev, dev->pipelineCache, NULL);
+    //vkDestroyPipelineCache          (dev->vkDev, dev->pipelineCache, NULL);
     vkDestroyRenderPass             (dev->vkDev, dev->renderPass, NULL);
 
     vkWaitForFences                 (dev->vkDev, 1, &dev->fence, VK_TRUE, UINT64_MAX);

diff --git a/src/vkvg_device_internal.c b/src/vkvg_device_internal.c
index e570fd4c0d07e4fbebc70be72af35e60ad7ef343..51b2d2e96b606fe08aae399d9a934d7bae9d3c78 100644 (file)
--- a/src/vkvg_device_internal.c
+++ b/src/vkvg_device_internal.c
@@ -52,16 +52,17 @@ void _setupRenderPass(VkvgDevice dev)
                     .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
                     .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
                     .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-                    .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+                    .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                    .finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL };
     VkAttachmentDescription attColorResolve = {
                     .format = FB_COLOR_FORMAT,
                     .samples = VK_SAMPLE_COUNT_1_BIT,
-                    .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
-                    .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
+                    .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                    .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
                     .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
                     .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-                    .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
-                    .finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL };
+                    .initialLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                    .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
     VkAttachmentDescription attDS = {
                     .format = VK_FORMAT_S8_UINT,
                     .samples = VKVG_SAMPLES,
@@ -69,6 +70,7 @@ void _setupRenderPass(VkvgDevice dev)
                     .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
                     .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
                     .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                    .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
                     .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
 /*    VkAttachmentDescription attDSResolve = {
                     .format = VK_FORMAT_S8_UINT,
@@ -255,36 +257,36 @@ void _setupPipelines(VkvgDevice dev)
     pipelineCreateInfo.layout = dev->pipelineLayout;
 
 
-    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelinePolyFill));
+    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &dev->pipelinePolyFill));
 
     inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
     dsStateCreateInfo.back = dsStateCreateInfo.front = clipingOpState;
-    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineClipping));
+    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &dev->pipelineClipping));
 
     dsStateCreateInfo.back = dsStateCreateInfo.front = stencilOpState;
     blendAttachmentState.colorWriteMask=0xf;
     dynamicState.dynamicStateCount = 3;
-    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipe_OVER));
+    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &dev->pipe_OVER));
 
     blendAttachmentState.alphaBlendOp = blendAttachmentState.colorBlendOp = VK_BLEND_OP_SUBTRACT;
-    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipe_SUB));
+    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &dev->pipe_SUB));
 
     blendAttachmentState.blendEnable = VK_FALSE;
     //rasterizationState.polygonMode = VK_POLYGON_MODE_POINT;
     //shaderStages[1].pName = "op_CLEAR";
-    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipe_CLEAR));
+    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &dev->pipe_CLEAR));
 
     rasterizationState.polygonMode = VK_POLYGON_MODE_FILL;
     inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
     shaderStages[1].pName = "main";
-    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineLineList));
+    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &dev->pipelineLineList));
 
     shaderStages[1].module = modFragWired;
     //pipelineCreateInfo.pStages = shaderStages;
 
     inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
     rasterizationState.polygonMode = VK_POLYGON_MODE_LINE;
-    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineWired));
+    VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &dev->pipelineWired));
 
     vkDestroyShaderModule(dev->vkDev, modVert, NULL);
     vkDestroyShaderModule(dev->vkDev, modFrag, NULL);

diff --git a/src/vkvg_fonts.c b/src/vkvg_fonts.c
index 39b038b22647e9a2bc700a4641579b4a444782f8..0aced480bd226c1a67b43b929a758360090734b3 100644 (file)
--- a/src/vkvg_fonts.c
+++ b/src/vkvg_fonts.c
@@ -90,7 +90,7 @@ void _increase_font_tex_array (VkvgDevice dev){
                                 vkh_image_get_vkimage (newImg), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &cregion);
 
     vkh_image_set_layout_subres(cache->cmd, newImg, subresNew, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                     VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+                     VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
 
     VK_CHECK_RESULT(vkEndCommandBuffer(cache->cmd));
 
@@ -209,7 +209,7 @@ void _flush_chars_to_tex (VkvgDevice dev, _vkvg_font_t* f) {
                            vkh_image_get_vkimage (cache->cacheTex), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &bufferCopyRegion);
 
     vkh_image_set_layout_subres(cache->cmd, cache->cacheTex, subres, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                     VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+                     VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
 
     VK_CHECK_RESULT(vkEndCommandBuffer(cache->cmd));
 

diff --git a/src/vkvg_surface.c b/src/vkvg_surface.c
index ce9d19c78c21b7e24084c17e69a1178da677b115..3bb202044f4af6651f1636a387dede23f39a7a0f 100644 (file)
--- a/src/vkvg_surface.c
+++ b/src/vkvg_surface.c
@@ -41,13 +41,13 @@ void _clear_stencil (VkvgSurface surf)
     VkImageSubresourceRange range = {VK_IMAGE_ASPECT_STENCIL_BIT,0,1,0,1};
 
     vkh_image_set_layout (cmd, surf->stencilMS, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
     vkCmdClearDepthStencilImage (cmd, vkh_image_get_vkimage (surf->stencilMS),
                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,&clr,1,&range);
 
     vkh_image_set_layout (cmd, surf->stencilMS, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT);
     vkh_cmd_end (cmd);
 
     vkh_cmd_submit (dev->gQueue, &cmd, dev->fence);
@@ -82,6 +82,10 @@ void _init_surface (VkvgSurface surf) {
 
     _clear_stencil(surf);
 }
+
+void vkvg_surface_test (VkvgSurface* pSurf, VkvgSurface surf) {
+    pSurf = &surf;
+}
 VkvgSurface vkvg_surface_create(VkvgDevice dev, uint32_t width, uint32_t height){
     VkvgSurface surf = (vkvg_surface*)calloc(1,sizeof(vkvg_surface));
 
@@ -96,30 +100,20 @@ VkvgSurface vkvg_surface_create(VkvgDevice dev, uint32_t width, uint32_t height)
 
     return surf;
 }
-
-VkvgSurface vkvg_surface_create_from_image (VkvgDevice dev, const char* filePath) {
-    int w = 0,
-        h = 0,
-        channels = 0;
-    unsigned char *img = stbi_load(filePath, &w, &h, &channels, 4);//force 4 components per pixel
-    if (img == NULL){
-        fprintf (stderr, "Could not load texture from %s, %s\n", filePath, stbi_failure_reason());
-        return NULL;
-    }
-
+VkvgSurface vkvg_surface_create_from_bitmap (VkvgDevice dev, unsigned char* img, uint32_t width, uint32_t height) {
     VkvgSurface surf = (vkvg_surface*)calloc(1,sizeof(vkvg_surface));
 
     surf->dev = dev;
-    surf->width = w;
-    surf->height = h;
+    surf->width = width;
+    surf->height = height;
 
     _init_surface (surf);
 
-    uint32_t imgSize = w * h * 4;
+    uint32_t imgSize = width * height * 4;
     VkImageSubresourceLayers imgSubResLayers = {VK_IMAGE_ASPECT_COLOR_BIT,0,0,1};
     //original format image
     VkhImage stagImg= vkh_image_create (surf->dev,VK_FORMAT_R8G8B8A8_UNORM,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
-                                         VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                                         VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
                                          VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
     //bgra bliting target
     VkhImage tmpImg = vkh_image_create (surf->dev,surf->format,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
@@ -132,13 +126,17 @@ VkvgSurface vkvg_surface_create_from_image (VkvgDevice dev, const char* filePath
     VK_CHECK_RESULT (vkh_buffer_map (buff));
     memcpy (vkh_buffer_get_mapped_pointer (buff), img, imgSize);
 
+    /*unsigned char* mapImg = vkh_image_map (stagImg);
+    memcpy (mapImg, img, imgSize);
+    vkh_image_unmap (stagImg);*/
+
     VkCommandBuffer cmd = dev->cmd;
 
     _wait_device_fence (dev);
 
     vkh_cmd_begin (cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
     vkh_image_set_layout (cmd, stagImg, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
+            VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
 
     VkBufferImageCopy bufferCopyRegion = { .imageSubresource = imgSubResLayers,
@@ -148,7 +146,7 @@ VkvgSurface vkvg_surface_create_from_image (VkvgDevice dev, const char* filePath
         vkh_image_get_vkimage (stagImg), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &bufferCopyRegion);
 
     vkh_image_set_layout (cmd, stagImg, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-            VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
+            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
     vkh_image_set_layout (cmd, tmpImg, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
@@ -162,6 +160,9 @@ VkvgSurface vkvg_surface_create_from_image (VkvgDevice dev, const char* filePath
                      vkh_image_get_vkimage (stagImg), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                      vkh_image_get_vkimage (tmpImg),  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_LINEAR);
 
+    vkh_image_set_layout (cmd, tmpImg, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+
     vkh_cmd_end     (cmd);
     vkh_cmd_submit  (dev->gQueue, &cmd, dev->fence);
 
@@ -174,9 +175,9 @@ VkvgSurface vkvg_surface_create_from_image (VkvgDevice dev, const char* filePath
     //create tmp context with rendering pipeline to create the multisample img
     VkvgContext ctx = vkvg_create (surf);
 
-    VkClearAttachment ca = {VK_IMAGE_ASPECT_COLOR_BIT,0, { 0.0f, 0.0f, 0.0f, 0.0f }};
+/*    VkClearAttachment ca = {VK_IMAGE_ASPECT_COLOR_BIT,0, { 0.0f, 0.0f, 0.0f, 0.0f }};
     VkClearRect cr = {{{0,0},{surf->width,surf->height}},0,1};
-    vkCmdClearAttachments(ctx->cmd, 1, &ca, 1, &cr);
+    vkCmdClearAttachments(ctx->cmd, 1, &ca, 1, &cr);*/
 
     vec4 srcRect = {0,0,surf->width,surf->height};
     ctx->pushConsts.source = srcRect;
@@ -195,6 +196,22 @@ VkvgSurface vkvg_surface_create_from_image (VkvgDevice dev, const char* filePath
 
     return surf;
 }
+VkvgSurface vkvg_surface_create_from_image (VkvgDevice dev, const char* filePath) {
+    int w = 0,
+        h = 0,
+        channels = 0;
+    unsigned char *img = stbi_load(filePath, &w, &h, &channels, 4);//force 4 components per pixel
+    if (img == NULL){
+        fprintf (stderr, "Could not load texture from %s, %s\n", filePath, stbi_failure_reason());
+        return NULL;
+    }
+
+    VkvgSurface surf = vkvg_surface_create_from_bitmap(dev, img, w, h);
+
+    stbi_image_free (img);
+
+    return surf;
+}
 
 void vkvg_surface_destroy(VkvgSurface surf)
 {

diff --git a/tests/test1.c b/tests/test1.c
index db030417c162a16db6a2a41c1c09bfaa7758f5b5..0b837d36af296edf7d601fa8a05bdf06bc8b5a22 100644 (file)
--- a/tests/test1.c
+++ b/tests/test1.c
@@ -26,6 +26,7 @@
 #define NANOSVG_IMPLEMENTATION // Expands implementation
 #include "nanosvg.h"
 #include "vkh_device.h"
+#include "vkh_presenter.h"
 
 VkvgDevice device;
 VkvgSurface surf = NULL;
@@ -329,8 +330,8 @@ void test_img_surface (VkvgContext ctx) {
     imgSurf = vkvg_surface_create_from_image(device, "/mnt/data/images/miroir.jpg");
     vkvg_set_source_surface(ctx, imgSurf, 0, 0);
     vkvg_paint(ctx);
-    vkvg_flush(ctx);
-    vkvg_set_source_rgba(ctx,0,0,0,1);
+    //vkvg_flush(ctx);
+    vkvg_set_source_rgba(ctx,1,0,0,1);
     vkvg_surface_destroy(imgSurf);
 }
 void test_line_caps (VkvgContext ctx) {
@@ -457,7 +458,7 @@ void test_colinear () {
 
 void multi_test1 () {
     VkvgSurface surf2 = vkvg_surface_create (device,800,800);;
-    VkvgContext ctx = vkvg_create(surf2);
+    VkvgContext ctx = vkvg_create (surf2);
 
     vkvg_set_source_rgba(ctx,0.1,0.1,0.3,1.0);
     vkvg_paint(ctx);
@@ -532,7 +533,7 @@ void multi_test1 () {
     vkvg_paint(ctx);
     vkvg_rotate(ctx,0.7);
     vkvg_paint(ctx);
-
+    vkvg_pattern_destroy (pat);
     vkvg_destroy(ctx);
     vkvg_surface_destroy(surf2);
 }
@@ -846,6 +847,7 @@ void cairo_tests () {
 
 //    cairo_test_clip(ctx);
 //    vkvg_reset_clip(ctx);
+    //test_img_surface (ctx);
 
     cairo_print_arc(ctx);
 
@@ -855,6 +857,7 @@ void cairo_tests () {
     vkvg_translate(ctx,250,0);
     cairo_test_rounded_rect(ctx);
 
+
 /*
     vkvg_set_operator(ctx, VKVG_OPERATOR_CLEAR);
     vkvg_rectangle(ctx,100,100,500,500);
@@ -862,6 +865,7 @@ void cairo_tests () {
     vkvg_set_operator(ctx, VKVG_OPERATOR_OVER);
 */
 
+
     vkvg_translate(ctx,-450,250);
     cairo_test_fill_and_stroke2(ctx);
 
@@ -986,20 +990,49 @@ void test_svg () {
     vkvg_destroy(ctx);
 }
 
+void test_painting () {
+    VkvgSurface surf2 = vkvg_surface_create (device,400,400);;
+    VkvgContext ctx = vkvg_create (surf2);
+
+    vkvg_set_source_rgba(ctx,1.0,0.,0.,1.0);
+    vkvg_paint (ctx);
+
+    vkvg_destroy (ctx);
+    ctx = vkvg_create (surf);
+
+    vkvg_set_source_rgba(ctx,0.1,0.1,0.3,1.0);
+    vkvg_paint (ctx);
+
+    //vkvg_set_source_surface(ctx,surf2,0,0);
+
+    //VkvgPattern pat = vkvg_get_source (ctx);
+    VkvgPattern pat = vkvg_pattern_create_for_surface(surf2);
+    vkvg_pattern_set_extend (pat,VKVG_EXTEND_REFLECT);
+    vkvg_set_source(ctx,pat);
+    //vkvg_paint (ctx);
+    //vkvg_set_source_rgba(ctx,0,1,0,1.0);
+    vkvg_rectangle(ctx,100,100,200,200);
+    vkvg_fill(ctx);
+
+    vkvg_destroy (ctx);
+    vkvg_surface_destroy (surf2);
+    vkvg_pattern_destroy (pat);
+}
+
 int main(int argc, char *argv[]) {
 
     //dumpLayerExts();
 
-    vk_engine_t* e = vke_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, 1024, 800);
+    vk_engine_t* e = vkengine_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, 1024, 800);
     VkhPresenter r = e->renderer;
-    vke_set_key_callback (e, key_callback);
+    vkengine_set_key_callback (e, key_callback);
 
-    device  = vkvg_device_create (e->dev->phy, e->dev->dev);
+    device  = vkvg_device_create (r->dev->phy, r->dev->dev, r->qFam, 0);
     surf    = vkvg_surface_create(device, 1024, 800);
 
     //test_svg();
 
-    //multi_test1();
+    //
 
     //test_grad_transforms();
 
@@ -1007,9 +1040,11 @@ int main(int argc, char *argv[]) {
 
     vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf));
 
-    while (!vke_should_close (e)) {
+    while (!vkengine_should_close (e)) {
         glfwPollEvents();
         cairo_tests();
+        //multi_test1();
+        //test_painting();
         if (!vkh_presenter_draw (r))
             vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf));
     }
@@ -1019,7 +1054,7 @@ int main(int argc, char *argv[]) {
     vkvg_surface_destroy    (surf);
     vkvg_device_destroy     (device);
 
-    vke_destroy (e);
+    vkengine_destroy (e);
 
     return 0;
 }

diff --git a/tests/vkengine.c b/tests/vkengine.c
index 4466a17bcbb4f4d150204e5b4cc1c13f65b1f5cc..f115b3e6bee3f590bd88868c22e6db73f944c565 100644 (file)
--- a/tests/vkengine.c
+++ b/tests/vkengine.c
@@ -28,14 +28,12 @@
 #include "vkh_image.h"
 #include "vkh_device.h"
 
-
-bool vkeCheckPhyPropBlitSource (vk_engine_t *e) {
+bool vkeCheckPhyPropBlitSource (VkEngine e) {
     VkFormatProperties 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");
 }
 
-
 VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts)
 {
     if (counts & VK_SAMPLE_COUNT_64_BIT) { return VK_SAMPLE_COUNT_64_BIT; }
@@ -47,7 +45,7 @@ VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts)
     return VK_SAMPLE_COUNT_1_BIT;
 }
 
-void vkengine_dump_Infos (vk_engine_t* e){
+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);
@@ -74,7 +72,7 @@ void vkengine_dump_Infos (vk_engine_t* e){
         printf("\n");
     }
 }
-vk_engine_t* vke_create (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t height) {
+vk_engine_t* vkengine_create (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t height) {
     vk_engine_t* e = (vk_engine_t*)calloc(1,sizeof(vk_engine_t));
 
     glfwInit();
@@ -175,16 +173,16 @@ vk_engine_t* vke_create (VkPhysicalDeviceType preferedGPU, uint32_t width, uint3
 
     vkh_app_free_phyinfos (phyCount, phys);
 
-
     return e;
 }
 
-void vke_destroy (vk_engine_t* e) {
+void vkengine_destroy (VkEngine e) {
     vkDeviceWaitIdle(e->dev->dev);
 
-    vkDestroySurfaceKHR (e->app->inst, e->renderer->surface, NULL);
+    VkSurfaceKHR surf = e->renderer->surface;
 
     vkh_presenter_destroy (e->renderer);
+    vkDestroySurfaceKHR (e->app->inst, surf, NULL);
 
     vkDestroyDevice (e->dev->dev, NULL);
 
@@ -195,25 +193,49 @@ void vke_destroy (vk_engine_t* e) {
 
     free(e);
 }
-
-static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
-    if (action != GLFW_PRESS)
-        return;
-    switch (key) {
-    case GLFW_KEY_ESCAPE :
-        glfwSetWindowShouldClose(window, GLFW_TRUE);
-        break;
+void vkengine_close (VkEngine e) {
+    glfwSetWindowShouldClose(e->window, GLFW_TRUE);
+}
+void vkengine_blitter_run (VkEngine e, VkImage img) {
+    VkhPresenter p = e->renderer;
+    vkh_presenter_build_blit_cmd (p, img);
+
+    while (!vkengine_should_close (e)) {
+        glfwPollEvents();
+        if (!vkh_presenter_draw (p))
+            vkh_presenter_build_blit_cmd (p, img);
     }
 }
-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){}
-
-inline bool vke_should_close (vk_engine_t* e) {
+inline bool vkengine_should_close (VkEngine e) {
     return glfwWindowShouldClose (e->window);
 }
-void vke_set_key_callback (vk_engine_t* e, GLFWkeyfun key_callback){
-    glfwSetKeyCallback (e->window, key_callback);
+
+VkDevice vkengine_get_device (VkEngine e){
+    return e->dev->dev;
+}
+VkPhysicalDevice vkengine_get_physical_device (VkEngine e){
+    return e->dev->phy;
+}
+VkQueue vkengine_get_queue (VkEngine e){
+    return e->renderer->queue;
+}
+uint32_t vkengine_get_queue_fam_idx (VkEngine e){
+    return e->renderer->qFam;
 }
 
+void vkengine_set_key_callback (VkEngine e, GLFWkeyfun key_callback){
+    glfwSetKeyCallback (e->window, key_callback);
+}
+void vkengine_set_mouse_but_callback (VkEngine e, GLFWmousebuttonfun onMouseBut){
+    glfwSetMouseButtonCallback(e->window, onMouseBut);
+}
+void vkengine_set_cursor_pos_callback (VkEngine e, GLFWcursorposfun onMouseMove){
+    glfwSetCursorPosCallback(e->window, onMouseMove);
+}
+void vkengine_set_scroll_callback (VkEngine e, GLFWscrollfun onScroll){
+    glfwSetScrollCallback(e->window, onScroll);
+}
+void vkengine_set_char_callback (VkEngine e, GLFWcharfun onChar){
+    glfwSetCharCallback(e->window, onChar);
+}
 

diff --git a/tests/vkengine.h b/tests/vkengine.h
index 62bc2a29320853b0404018a86ac481784ea7c85e..1bf33a8b7b1617044681e40b8d2c340cf230bae5 100644 (file)
--- a/tests/vkengine.h
+++ b/tests/vkengine.h
@@ -36,6 +36,7 @@
 /* renderpass creation and pipeline creation.                     */
 #define FENCE_TIMEOUT 100000000
 
+typedef struct _vk_engine_t* VkEngine;
 
 typedef struct _vk_engine_t {
     VkhApp              app;
@@ -43,24 +44,25 @@ typedef struct _vk_engine_t {
     VkPhysicalDeviceProperties          gpu_props;
     VkhDevice           dev;
     GLFWwindow*         window;
-
     VkhPresenter        renderer;
 }vk_engine_t;
 
-vk_engine_t*   vke_create  (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t height);
-void        vke_destroy (vk_engine_t* e);
-
-void initPhySurface(VkhPresenter r, VkFormat preferedFormat, VkPresentModeKHR presentMode);
+vk_engine_t*   vkengine_create  (VkPhysicalDeviceType preferedGPU, uint32_t width, uint32_t height);
 
-VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts);
+void vkengine_destroy       (VkEngine e);
+bool vkengine_should_close  (VkEngine e);
+void vkengine_close         (VkEngine e);
+void vkengine_dump_Infos    (VkEngine e);
+VkDevice            vkengine_get_device         (VkEngine e);
+VkPhysicalDevice    vkengine_get_physical_device(VkEngine e);
+VkQueue             vkengine_get_queue          (VkEngine e);
+uint32_t            vkengine_get_queue_fam_idx  (VkEngine e);
 
-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 submitCommandBuffer(VkQueue queue, VkCommandBuffer *pCmdBuff, VkSemaphore* pWaitSemaphore, VkSemaphore* pSignalSemaphore);
-//void draw(vk_engine_t* e, VkImage blitSource);
+void vkengine_set_key_callback          (VkEngine e, GLFWkeyfun key_callback);
+void vkengine_set_mouse_but_callback    (VkEngine e, GLFWmousebuttonfun onMouseBut);
+void vkengine_set_cursor_pos_callback   (VkEngine e, GLFWcursorposfun onMouseMove);
+void vkengine_set_scroll_callback       (VkEngine e, GLFWscrollfun onScroll);
+void vkengine_set_char_callback         (VkEngine e, GLFWcharfun onChar);
 #endif