From: j-p Date: Tue, 10 Apr 2018 03:59:40 +0000 (+0200) Subject: Devel (#4) X-Git-Tag: v0.1-alpha~155 X-Git-Url: https://git.osiis.dedyn.io/?a=commitdiff_plain;h=88996c4e1f4844e183189eb578eff70d3bf09384;p=jp%2Fvkvg.git Devel (#4) * create surface from image, split device internal funs in separate file, update_descriptors from surf more generic * curve_to implementation with antigrain algorithm, should find correct limits --- diff --git a/include/vkvg.h b/include/vkvg.h index bb01625..2c86cbf 100644 --- a/include/vkvg.h +++ b/include/vkvg.h @@ -6,10 +6,17 @@ #define VKVG_SAMPLES VK_SAMPLE_COUNT_4_BIT -typedef enum VkvgDirection { +typedef enum _vkvg_direction { VKVG_HORIZONTAL = 0, VKVG_VERTICAL = 1 -}VkvgDirection; +}vkvg_direction_t; + +typedef enum _vkvg_format { + VKVG_FORMAT_ARGB32, + VKVG_FORMAT_RGB24, + VKVG_FORMAT_A8, + VKVG_FORMAT_A1 +} vkvg_format_t; typedef struct _vkvg_context_t* VkvgContext; typedef struct _vkvg_surface_t* VkvgSurface; @@ -20,6 +27,8 @@ VkvgDevice vkvg_device_create (VkPhysicalDevice phy, VkDevice vkdev, VkQueue q void vkvg_device_destroy (VkvgDevice dev); VkvgSurface vkvg_surface_create (VkvgDevice dev, uint32_t width, uint32_t height); +VkvgSurface vkvg_surface_create_from_image (VkvgDevice dev, const char* filePath); + void vkvg_surface_destroy (VkvgSurface surf); VkImage vkvg_surface_get_vk_image (VkvgSurface surf); VkImage vkvg_surface_get_vkh_image (VkvgSurface surf); @@ -71,6 +80,7 @@ void vkvg_close_path (VkvgContext ctx); void vkvg_line_to (VkvgContext ctx, float x, float y); void vkvg_move_to (VkvgContext ctx, float x, float y); void vkvg_arc (VkvgContext ctx, float xc, float yc, float radius, float a1, float a2); +void vkvg_curve_to (VkvgContext ctx, float x1, float y1, float x2, float y2, float x3, float y3); void vkvg_stroke (VkvgContext ctx); void vkvg_stroke_preserve (VkvgContext ctx); void vkvg_fill (VkvgContext ctx); diff --git a/src/vkvg_context.c b/src/vkvg_context.c index 21d3b9c..45bc9a1 100644 --- a/src/vkvg_context.c +++ b/src/vkvg_context.c @@ -46,7 +46,7 @@ VkvgContext vkvg_create(VkvgSurface surf) _create_cmd_buff (ctx); _createDescriptorPool (ctx); _init_descriptor_sets (ctx); - _update_font_descriptor_set (ctx); + _update_descriptor_set (ctx, ctx->pSurf->dev->fontCache->cacheTex, ctx->dsFont); _init_cmd_buff (ctx); _clear_path (ctx); @@ -79,14 +79,6 @@ void vkvg_flush (VkvgContext ctx){ } -void _free_ctx_save (vkvg_context_save_t* sav){ - free(sav->pathes); - free(sav->points); - free(sav->selectedFont.fontFile); - vkh_image_destroy (sav->stencilMS); - free (sav); -} - void vkvg_destroy (VkvgContext ctx) { _flush_cmd_buff(ctx); @@ -156,7 +148,7 @@ void vkvg_line_to (VkvgContext ctx, float x, float y) ctx->pathPtr++; _add_curpos(ctx); } - _add_point(ctx, x, y); + _add_point_cp_update(ctx, x, y); } void vkvg_arc (VkvgContext ctx, float xc, float yc, float radius, float a1, float a2){ @@ -185,14 +177,14 @@ void vkvg_arc (VkvgContext ctx, float xc, float yc, float radius, float a1, floa while(a > aa2){ v.x = cos(a)*radius + xc; v.y = sin(a)*radius + yc; - _add_point(ctx,v.x,v.y); + _add_point_cp_update(ctx,v.x,v.y); a-=step; } }else{ while(a < aa2){ v.x = cos(a)*radius + xc; v.y = sin(a)*radius + yc; - _add_point(ctx,v.x,v.y); + _add_point_cp_update(ctx,v.x,v.y); a+=step; } } @@ -200,7 +192,7 @@ void vkvg_arc (VkvgContext ctx, float xc, float yc, float radius, float a1, floa v.x = cos(a)*radius + xc; v.y = sin(a)*radius + yc; if (!vec2_equ (v,ctx->curPos)) - _add_point(ctx,v.x,v.y); + _add_point_cp_update(ctx,v.x,v.y); } void vkvg_move_to (VkvgContext ctx, float x, float y) @@ -211,6 +203,10 @@ void vkvg_move_to (VkvgContext ctx, float x, float y) ctx->curPos.y = y; } +void vkvg_curve_to (VkvgContext ctx, float x1, float y1, float x2, float y2, float x3, float y3) { + _bezier (ctx, ctx->curPos.x, ctx->curPos.y, x1, y1, x2, y2, x3, y3); +} + void vkvg_clip_preserve (VkvgContext ctx){ vkCmdBindPipeline(ctx->cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, ctx->pSurf->dev->pipelineClipping); vkvg_fill_preserve(ctx); @@ -465,7 +461,7 @@ void vkvg_set_source_surface(VkvgContext ctx, VkvgSurface surf, float x, float y _submit_wait_and_reset_cmd (ctx); } - _update_source_descriptor_set (ctx); + _update_descriptor_set (ctx, ctx->source, ctx->dsSrc); _init_cmd_buff (ctx); vec4 srcRect = {x,y,surf->width,surf->height}; @@ -488,7 +484,7 @@ void vkvg_set_font_size (VkvgContext ctx, uint32_t size){ _set_font_size (ctx,size); } -void vkvg_set_text_direction (vkvg_context* ctx, VkvgDirection direction){ +void vkvg_set_text_direction (vkvg_context* ctx, vkvg_direction_t direction){ } diff --git a/src/vkvg_context_internal.c b/src/vkvg_context_internal.c index e1056fd..97a14b1 100644 --- a/src/vkvg_context_internal.c +++ b/src/vkvg_context_internal.c @@ -1,3 +1,13 @@ + +//credits for bezier algorithms to: +// Anti-Grain Geometry (AGG) - Version 2.5 +// A high quality rendering engine for C++ +// Copyright (C) 2002-2006 Maxim Shemanarev +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://antigrain.com + + #include "vkvg_surface_internal.h" #include "vkvg_context_internal.h" #include "vkvg_device_internal.h" @@ -8,7 +18,12 @@ void _check_pathes_array (VkvgContext ctx){ ctx->sizePathes += VKVG_PATHES_SIZE; ctx->pathes = (uint32_t*) realloc (ctx->pathes, ctx->sizePathes*sizeof(uint32_t)); } -void _add_point(VkvgContext ctx, float x, float y){ +void _add_point (VkvgContext ctx, float x, float y){ + vec2 v = {x,y}; + ctx->points[ctx->pointCount] = v; + ctx->pointCount++; +} +void _add_point_cp_update(VkvgContext ctx, float x, float y){ ctx->curPos.x = x; ctx->curPos.y = y; ctx->points[ctx->pointCount] = ctx->curPos; @@ -197,32 +212,17 @@ uint32_t _get_last_point_of_closed_path(VkvgContext ctx, uint32_t ptrPath){ return ctx->pathes[ptrPath+2]-1; //last p is p prior to first idx of next path return ctx->pointCount-1; //last point of path is last point of point array } -void _update_source_descriptor_set (VkvgContext ctx){ - VkvgDevice dev = ctx->pSurf->dev; - VkDescriptorImageInfo descSrcTex = vkh_image_get_descriptor (ctx->source, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); +void _update_descriptor_set (VkvgContext ctx, VkhImage img, VkDescriptorSet ds){ + VkDescriptorImageInfo descSrcTex = vkh_image_get_descriptor (img, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); VkWriteDescriptorSet writeDescriptorSet = { .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = ctx->dsSrc, + .dstSet = ds, .dstBinding = 0, .descriptorCount = 1, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &descSrcTex }; - vkUpdateDescriptorSets(dev->vkDev, 1, &writeDescriptorSet, 0, NULL); -} -void _update_font_descriptor_set (VkvgContext ctx){ - VkvgDevice dev = ctx->pSurf->dev; - _font_cache_t* cache = dev->fontCache; - VkDescriptorImageInfo descFontTex = vkh_image_get_descriptor (cache->cacheTex, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); - VkWriteDescriptorSet writeDescriptorSet = { - .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = ctx->dsFont, - .dstBinding = 0, - .descriptorCount = 1, - .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - .pImageInfo = &descFontTex - }; - vkUpdateDescriptorSets(dev->vkDev, 1, &writeDescriptorSet, 0, NULL); + vkUpdateDescriptorSets(ctx->pSurf->dev->vkDev, 1, &writeDescriptorSet, 0, NULL); } void _createDescriptorPool (VkvgContext ctx) { VkvgDevice dev = ctx->pSurf->dev; @@ -300,3 +300,207 @@ bool ptInTriangle(vec2 p, vec2 p0, vec2 p1, vec2 p2) { return (s<=0) && (t<=0) && (s+t>=D); return (s>=0) && (t>=0) && (s+t<=D); } + +void _free_ctx_save (vkvg_context_save_t* sav){ + free(sav->pathes); + free(sav->points); + free(sav->selectedFont.fontFile); + vkh_image_destroy (sav->stencilMS); + free (sav); +} + + +#define m_approximation_scale 1.0 +#define m_angle_tolerance 0.5 +#define m_distance_tolerance 0.25 +#define m_cusp_limit 0.2 +#define curve_recursion_limit 32 +#define curve_collinearity_epsilon 0.01 +#define curve_angle_tolerance_epsilon 0.01 + +void _recursive_bezier (VkvgContext ctx, + float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + unsigned level) { + if(level > curve_recursion_limit) + { + return; + } + + // Calculate all the mid-points of the line segments + //---------------------- + float x12 = (x1 + x2) / 2; + float y12 = (y1 + y2) / 2; + float x23 = (x2 + x3) / 2; + float y23 = (y2 + y3) / 2; + float x34 = (x3 + x4) / 2; + float y34 = (y3 + y4) / 2; + float x123 = (x12 + x23) / 2; + float y123 = (y12 + y23) / 2; + float x234 = (x23 + x34) / 2; + float y234 = (y23 + y34) / 2; + float x1234 = (x123 + x234) / 2; + float y1234 = (y123 + y234) / 2; + + if(level > 0) // Enforce subdivision first time + { + // Try to approximate the full cubic curve by a single straight line + //------------------ + float dx = x4-x1; + float dy = y4-y1; + + float d2 = fabs(((x2 - x4) * dy - (y2 - y4) * dx)); + float d3 = fabs(((x3 - x4) * dy - (y3 - y4) * dx)); + + float da1, da2; + + if(d2 > curve_collinearity_epsilon && d3 > curve_collinearity_epsilon) + { + // Regular care + //----------------- + if((d2 + d3)*(d2 + d3) <= m_distance_tolerance * (dx*dx + dy*dy)) + { + // If the curvature doesn't exceed the distance_tolerance value + // we tend to finish subdivisions. + //---------------------- + if(m_angle_tolerance < curve_angle_tolerance_epsilon) + { + _add_point (ctx, x1234, y1234); + return; + } + + // Angle & Cusp Condition + //---------------------- + float a23 = atan2(y3 - y2, x3 - x2); + da1 = fabs(a23 - atan2(y2 - y1, x2 - x1)); + da2 = fabs(atan2(y4 - y3, x4 - x3) - a23); + if(da1 >= M_PI) da1 = M_2_PI - da1; + if(da2 >= M_PI) da2 = M_2_PI - da2; + + if(da1 + da2 < m_angle_tolerance) + { + // Finally we can stop the recursion + //---------------------- + _add_point (ctx, x1234, y1234); + return; + } + + if(m_cusp_limit != 0.0) + { + if(da1 > m_cusp_limit) + { + _add_point (ctx, x2, y2); + return; + } + + if(da2 > m_cusp_limit) + { + _add_point (ctx, x3, y3); + return; + } + } + } + } else { + if(d2 > curve_collinearity_epsilon) + { + // p1,p3,p4 are collinear, p2 is considerable + //---------------------- + if(d2 * d2 <= m_distance_tolerance * (dx*dx + dy*dy)) + { + if(m_angle_tolerance < curve_angle_tolerance_epsilon) + { + _add_point (ctx, x1234, y1234); + return; + } + + // Angle Condition + //---------------------- + da1 = fabs(atan2(y3 - y2, x3 - x2) - atan2(y2 - y1, x2 - x1)); + if(da1 >= M_PI) da1 = M_2_PI - da1; + + if(da1 < m_angle_tolerance) + { + _add_point (ctx, x2, y2); + _add_point (ctx, x3, y3); + return; + } + + if(m_cusp_limit != 0.0) + { + if(da1 > m_cusp_limit) + { + _add_point (ctx, x2, y2); + return; + } + } + } + } else if(d3 > curve_collinearity_epsilon) { + // p1,p2,p4 are collinear, p3 is considerable + //---------------------- + if(d3 * d3 <= m_distance_tolerance * (dx*dx + dy*dy)) + { + if(m_angle_tolerance < curve_angle_tolerance_epsilon) + { + _add_point (ctx, x1234, y1234); + return; + } + + // Angle Condition + //---------------------- + da1 = fabs(atan2(y4 - y3, x4 - x3) - atan2(y3 - y2, x3 - x2)); + if(da1 >= M_PI) da1 = M_2_PI - da1; + + if(da1 < m_angle_tolerance) + { + _add_point (ctx, x2, y2); + _add_point (ctx, x3, y3); + return; + } + + if(m_cusp_limit != 0.0) + { + if(da1 > m_cusp_limit) + { + _add_point (ctx, x3, y3); + return; + } + } + } + } + else + { + // Collinear case + //----------------- + dx = x1234 - (x1 + x4) / 2; + dy = y1234 - (y1 + y4) / 2; + if(dx*dx + dy*dy <= m_distance_tolerance) + { + _add_point (ctx, x1234, y1234); + return; + } + } + } + } + + // Continue subdivision + //---------------------- + _recursive_bezier(ctx, x1, y1, x12, y12, x123, y123, x1234, y1234, level + 1); + _recursive_bezier(ctx, x1234, y1234, x234, y234, x34, y34, x4, y4, level + 1); +} + +//------------------------------------------------------------------------ +void _bezier (VkvgContext ctx, + float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4) { + if (ctx->pathPtr % 2 == 0){//current path is empty + //set start to current idx in point array + ctx->pathes[ctx->pathPtr] = ctx->pointCount; + _check_pathes_array(ctx); + ctx->pathPtr++; + } + _add_point (ctx, x1, y1); + _recursive_bezier (ctx, x1, y1, x2, y2, x3, y3, x4, y4, 0); + _add_point_cp_update (ctx, x4, y4); +} diff --git a/src/vkvg_context_internal.h b/src/vkvg_context_internal.h index bd51c38..5399dfc 100644 --- a/src/vkvg_context_internal.h +++ b/src/vkvg_context_internal.h @@ -56,7 +56,7 @@ typedef struct _vkvg_context_save_t{ _vkvg_font_t selectedFont; //hold current face and size before cache addition _vkvg_font_t* currentFont; //font ready for lookup - VkvgDirection textDirection; + vkvg_direction_t textDirection; push_constants pushConsts; }vkvg_context_save_t; @@ -102,7 +102,7 @@ typedef struct _vkvg_context_t { _vkvg_font_t selectedFont; //hold current face and size before cache addition _vkvg_font_t* currentFont; //font ready for lookup - VkvgDirection textDirection; + vkvg_direction_t textDirection; push_constants pushConsts; @@ -112,7 +112,8 @@ typedef struct _vkvg_context_t { void _check_pathes_array (VkvgContext ctx); float _normalizeAngle (float a); -void _add_point (VkvgContext ctx, float x, float y); +void _add_point (VkvgContext ctx, float x, float y); +void _add_point_cp_update (VkvgContext ctx, float x, float y); void _add_point_v2 (VkvgContext ctx, vec2 v); void _add_curpos (VkvgContext ctx); void _vkvg_fill_rectangle (VkvgContext ctx, float x, float y, float width, float height); @@ -120,8 +121,8 @@ void _vkvg_fill_rectangle (VkvgContext ctx, float x, float y, float width, flo void _create_vertices_buff (VkvgContext ctx); void _add_vertex (VkvgContext ctx, Vertex v); void _set_vertex (VkvgContext ctx, uint32_t idx, Vertex v); +void _add_triangle_indices (VkvgContext ctx, uint32_t i0, uint32_t i1,uint32_t i2); void _add_tri_indices_for_rect (VkvgContext ctx, uint32_t i); -void _add_triangle_indices (VkvgContext ctx, uint32_t i0, uint32_t i1,uint32_t i2); void _create_cmd_buff (VkvgContext ctx); void _init_cmd_buff (VkvgContext ctx); @@ -136,10 +137,10 @@ void _clear_path (VkvgContext ctx); bool _path_is_closed (VkvgContext ctx, uint32_t ptrPath); uint32_t _get_last_point_of_closed_path (VkvgContext ctx, uint32_t ptrPath); -void _createDescriptorPool (VkvgContext ctx); -void _init_descriptor_sets (VkvgContext ctx); -void _update_source_descriptor_set (VkvgContext ctx); -void _update_font_descriptor_set (VkvgContext ctx); +void _createDescriptorPool (VkvgContext ctx); +void _init_descriptor_sets (VkvgContext ctx); +void _update_descriptor_set (VkvgContext ctx, VkhImage img, VkDescriptorSet ds); +void _free_ctx_save (vkvg_context_save_t* sav); static inline float vec2_zcross (vec2 v1, vec2 v2){ return v1.x*v2.y-v1.y*v2.x; @@ -147,4 +148,11 @@ static inline float vec2_zcross (vec2 v1, vec2 v2){ static inline float ecp_zcross (ear_clip_point* p0, ear_clip_point* p1, ear_clip_point* p2){ return vec2_zcross (vec2_sub (p1->pos, p0->pos), vec2_sub (p2->pos, p0->pos)); } +void _recursive_bezier(VkvgContext ctx, + float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + unsigned level); +void _bezier (VkvgContext ctx, + float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4); #endif diff --git a/src/vkvg_device.c b/src/vkvg_device.c index f0df8a6..8d4e397 100644 --- a/src/vkvg_device.c +++ b/src/vkvg_device.c @@ -1,11 +1,4 @@ #include "vkvg_device_internal.h" -#include "vkvg_context_internal.h" -#include "shaders.h" - -void _create_pipeline_cache (VkvgDevice dev); -void _setupRenderPass (VkvgDevice dev); -void _setupPipelines (VkvgDevice dev); -void _createDescriptorSetLayout (VkvgDevice dev); VkvgDevice vkvg_device_create(VkPhysicalDevice phy, VkDevice vkdev, VkQueue queue, uint32_t qFam) { @@ -17,23 +10,26 @@ VkvgDevice vkvg_device_create(VkPhysicalDevice phy, VkDevice vkdev, VkQueue queu dev->vkDev = vkdev; vkGetPhysicalDeviceMemoryProperties (phy, &dev->phyMemProps); - dev->queue = queue; - dev->qFam = qFam; - dev->lastCtx = NULL; - - dev->cmdPool = vkh_cmd_pool_create (dev->vkDev, qFam, 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); - - _create_pipeline_cache(dev); + for (int i=0; i<120; i++){ + VkFormatProperties formatProps = {}; + vkGetPhysicalDeviceFormatProperties (phy, (VkFormat)i, &formatProps); + printf("%d => Buff = %d, Lin = %d, Opt = %d\n", i, formatProps.bufferFeatures, formatProps.linearTilingFeatures, formatProps.optimalTilingFeatures); + } - _init_fonts_cache(dev); + dev->queue = queue; + dev->qFam = qFam; + dev->lastCtx= NULL; - _setupRenderPass (dev); + dev->cmdPool= vkh_cmd_pool_create (dev->vkDev, qFam, 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); - _createDescriptorSetLayout (dev); + _create_pipeline_cache (dev); + _init_fonts_cache (dev); + _setupRenderPass (dev); + _createDescriptorSetLayout (dev); + _setupPipelines (dev); - _setupPipelines (dev); return dev; } @@ -61,276 +57,3 @@ void vkvg_device_destroy(VkvgDevice dev) _destroy_font_cache(dev); free(dev); } -void _flush_all_contexes (VkvgDevice dev){ - VkvgContext next = dev->lastCtx; - while (next != NULL){ - _flush_cmd_buff(next); - next = next->pPrev; - } -} -void _init_all_contexes (VkvgDevice dev){ - VkvgContext next = dev->lastCtx; - while (next != NULL){ - _init_cmd_buff (next); - next = next->pPrev; - } -} - -void _create_pipeline_cache(VkvgDevice dev){ - VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO}; - VK_CHECK_RESULT(vkCreatePipelineCache(dev->vkDev, &pipelineCacheCreateInfo, NULL, &dev->pipelineCache)); -} -void _setupRenderPass(VkvgDevice dev) -{ - VkAttachmentDescription attColor = { - .format = FB_COLOR_FORMAT, - .samples = VKVG_SAMPLES, - .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD, - .storeOp = VK_ATTACHMENT_STORE_OP_STORE, - .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD, - .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, - .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; - VkAttachmentDescription attColorResolve = { - .format = FB_COLOR_FORMAT, - .samples = VK_SAMPLE_COUNT_1_BIT, - .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - .storeOp = VK_ATTACHMENT_STORE_OP_STORE, - .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 }; - VkAttachmentDescription attDS = { - .format = VK_FORMAT_S8_UINT, - .samples = VKVG_SAMPLES, - .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR, - .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, - .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD, - .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, - .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }; -/* VkAttachmentDescription attDSResolve = { - .format = VK_FORMAT_S8_UINT, - .samples = VK_SAMPLE_COUNT_1_BIT, - .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - .storeOp = VK_ATTACHMENT_STORE_OP_STORE, - .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, - .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED, - .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };*/ - VkAttachmentDescription attachments[] = {attColor,attColorResolve,attDS}; - VkAttachmentReference colorRef = { - .attachment = 0, - .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; - VkAttachmentReference colorResolveRef = { - .attachment = 1, - .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; - VkAttachmentReference dsRef = { - .attachment = 2, - .layout = VK_IMAGE_LAYOUT_GENERAL }; - /*VkAttachmentReference dsResolveRef = { - .attachment = 3, - .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };*/ - VkSubpassDescription subpassDescription = { .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, - .colorAttachmentCount = 1, - .pColorAttachments = &colorRef, - .pResolveAttachments = &colorResolveRef, - .pDepthStencilAttachment = &dsRef}; - VkSubpassDependency dep0 = { - .srcSubpass = VK_SUBPASS_EXTERNAL, - .dstSubpass = 0, - .srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - .srcAccessMask = VK_ACCESS_MEMORY_READ_BIT, - .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT }; - VkSubpassDependency dep1 = { - .srcSubpass = 0, - .dstSubpass = VK_SUBPASS_EXTERNAL, - .srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - .dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT, - .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT }; - - VkSubpassDependency dependencies[] = {dep0,dep1}; - VkRenderPassCreateInfo renderPassInfo = { .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, - .attachmentCount = 3, - .pAttachments = attachments, - .subpassCount = 1, - .pSubpasses = &subpassDescription, - .dependencyCount = 2, - .pDependencies = dependencies }; - - VK_CHECK_RESULT(vkCreateRenderPass(dev->vkDev, &renderPassInfo, NULL, &dev->renderPass)); -} - -void _setupPipelines(VkvgDevice dev) -{ - VkGraphicsPipelineCreateInfo pipelineCreateInfo = { .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, - .renderPass = dev->renderPass }; - - VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST }; - - VkPipelineRasterizationStateCreateInfo rasterizationState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, - .polygonMode = VK_POLYGON_MODE_FILL, - .cullMode = VK_CULL_MODE_NONE, - .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, - .depthClampEnable = VK_FALSE, - .rasterizerDiscardEnable = VK_FALSE, - .depthBiasEnable = VK_FALSE, - .lineWidth = 1.0f }; - - VkPipelineColorBlendAttachmentState blendAttachmentState = - { .colorWriteMask = 0x0, .blendEnable = VK_TRUE, - .srcColorBlendFactor = VK_BLEND_FACTOR_ONE, - .dstColorBlendFactor= VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - .colorBlendOp = VK_BLEND_OP_ADD, - .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, - .dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - .alphaBlendOp = VK_BLEND_OP_ADD, - }; - - VkPipelineColorBlendStateCreateInfo colorBlendState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - .attachmentCount = 1, - .pAttachments = &blendAttachmentState }; - - /*failOp,passOp,depthFailOp,compareOp, compareMask, writeMask, reference;*/ - VkStencilOpState clipingOpState = {VK_STENCIL_OP_KEEP,VK_STENCIL_OP_INCREMENT_AND_CLAMP,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,0x0,0xf,0}; - VkStencilOpState stencilOpState = {VK_STENCIL_OP_KEEP,VK_STENCIL_OP_REPLACE,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,0xf,0x0,0}; - - VkPipelineDepthStencilStateCreateInfo dsStateCreateInfo = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, - .depthTestEnable = VK_FALSE, - .depthWriteEnable = VK_FALSE, - .depthCompareOp = VK_COMPARE_OP_ALWAYS, - .stencilTestEnable = VK_TRUE, - .front = clipingOpState, - .back = clipingOpState }; - - VkDynamicState dynamicStateEnables[] = { - VK_DYNAMIC_STATE_VIEWPORT, - VK_DYNAMIC_STATE_SCISSOR, - VK_DYNAMIC_STATE_STENCIL_REFERENCE, - }; - VkPipelineDynamicStateCreateInfo dynamicState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, - .dynamicStateCount = 3, - .pDynamicStates = dynamicStateEnables }; - - VkPipelineViewportStateCreateInfo viewportState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, - .viewportCount = 1, .scissorCount = 1 }; - - VkPipelineMultisampleStateCreateInfo multisampleState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, - .rasterizationSamples = VKVG_SAMPLES }; - if (VKVG_SAMPLES != VK_SAMPLE_COUNT_1_BIT){ - multisampleState.sampleShadingEnable = VK_TRUE; - multisampleState.minSampleShading = 0.25f; - multisampleState.alphaToCoverageEnable = VK_FALSE; - multisampleState.alphaToOneEnable = VK_FALSE; - } - VkVertexInputBindingDescription vertexInputBinding = { .binding = 0, - .stride = sizeof(Vertex), - .inputRate = VK_VERTEX_INPUT_RATE_VERTEX }; - - VkVertexInputAttributeDescription vertexInputAttributs[2] = { - {0, 0, VK_FORMAT_R32G32_SFLOAT, 0}, - {1, 0, VK_FORMAT_R32G32B32_SFLOAT, sizeof(vec2)} - }; - - VkPipelineVertexInputStateCreateInfo vertexInputState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - .vertexBindingDescriptionCount = 1, - .pVertexBindingDescriptions = &vertexInputBinding, - .vertexAttributeDescriptionCount = 2, - .pVertexAttributeDescriptions = vertexInputAttributs }; - - VkShaderModule modVert, modFrag; - VkShaderModuleCreateInfo createInfo = { .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, - .pCode = triangle_vert_spv, - .codeSize = triangle_vert_spv_len }; - VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modVert)); - createInfo.pCode = triangle_frag_spv; - createInfo.codeSize = triangle_frag_spv_len; - VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modFrag)); - - VkPipelineShaderStageCreateInfo vertStage = { .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .stage = VK_SHADER_STAGE_VERTEX_BIT, - .module = modVert, - .pName = "main", - }; - VkPipelineShaderStageCreateInfo fragStage = { .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .stage = VK_SHADER_STAGE_FRAGMENT_BIT, - .module = modFrag, - .pName = "main", - }; - - // Use specialization constants to pass number of samples to the shader (used for MSAA resolve) - VkSpecializationMapEntry specializationEntry = { - .constantID = 0, - .offset = 0, - .size = sizeof(uint32_t)}; - uint32_t specializationData = VKVG_SAMPLES; - VkSpecializationInfo specializationInfo = { - .mapEntryCount = 1, - .pMapEntries = &specializationEntry, - .dataSize = sizeof(specializationData), - .pData = &specializationData}; - - VkPipelineShaderStageCreateInfo shaderStages[] = {vertStage,fragStage}; - - pipelineCreateInfo.stageCount = 2; - pipelineCreateInfo.pStages = shaderStages; - pipelineCreateInfo.pVertexInputState = &vertexInputState; - pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState; - pipelineCreateInfo.pViewportState = &viewportState; - pipelineCreateInfo.pRasterizationState = &rasterizationState; - pipelineCreateInfo.pMultisampleState = &multisampleState; - pipelineCreateInfo.pColorBlendState = &colorBlendState; - pipelineCreateInfo.pDepthStencilState = &dsStateCreateInfo; - pipelineCreateInfo.pDynamicState = &dynamicState; - pipelineCreateInfo.layout = dev->pipelineLayout; - - VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineClipping)); - - //dsStateCreateInfo.back.writeMask = dsStateCreateInfo.front.writeMask = 0; - dsStateCreateInfo.back = dsStateCreateInfo.front = stencilOpState; - blendAttachmentState.colorWriteMask=0xf; - VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipeline)); - - blendAttachmentState.alphaBlendOp = blendAttachmentState.colorBlendOp = VK_BLEND_OP_SUBTRACT; - VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipeline_OP_SUB)); - - 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)); - - rasterizationState.polygonMode = VK_POLYGON_MODE_FILL; - inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST; - VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineLineList)); - - vkDestroyShaderModule(dev->vkDev, shaderStages[0].module, NULL); - vkDestroyShaderModule(dev->vkDev, shaderStages[1].module, NULL); -} - -void _createDescriptorSetLayout (VkvgDevice dev) { - - VkDescriptorSetLayoutBinding dsLayoutBinding = - {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,VK_SHADER_STAGE_FRAGMENT_BIT}; - VkDescriptorSetLayoutCreateInfo dsLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - .bindingCount = 1, - .pBindings = &dsLayoutBinding }; - VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslFont)); - VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslSrc)); - - VkPushConstantRange pushConstantRange[] = { - {VK_SHADER_STAGE_VERTEX_BIT,0,sizeof(push_constants)}, - //{VK_SHADER_STAGE_FRAGMENT_BIT,0,sizeof(push_constants)} - }; - VkDescriptorSetLayout dsls[] = {dev->dslFont,dev->dslSrc}; - - VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, - .pushConstantRangeCount = 1, - .pPushConstantRanges = &pushConstantRange, - .setLayoutCount = 2, - .pSetLayouts = dsls }; - VK_CHECK_RESULT(vkCreatePipelineLayout(dev->vkDev, &pipelineLayoutCreateInfo, NULL, &dev->pipelineLayout)); -} - - diff --git a/src/vkvg_device_internal.c b/src/vkvg_device_internal.c new file mode 100644 index 0000000..61e6a94 --- /dev/null +++ b/src/vkvg_device_internal.c @@ -0,0 +1,280 @@ +#include "vkvg_device_internal.h" +#include "vkvg_context_internal.h" +#include "shaders.h" + +void _flush_all_contexes (VkvgDevice dev){ + VkvgContext next = dev->lastCtx; + while (next != NULL){ + _flush_cmd_buff(next); + next = next->pPrev; + } +} +void _init_all_contexes (VkvgDevice dev){ + VkvgContext next = dev->lastCtx; + while (next != NULL){ + _init_cmd_buff (next); + next = next->pPrev; + } +} + +void _create_pipeline_cache(VkvgDevice dev){ + VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO}; + VK_CHECK_RESULT(vkCreatePipelineCache(dev->vkDev, &pipelineCacheCreateInfo, NULL, &dev->pipelineCache)); +} +void _setupRenderPass(VkvgDevice dev) +{ + VkAttachmentDescription attColor = { + .format = FB_COLOR_FORMAT, + .samples = VKVG_SAMPLES, + .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD, + .storeOp = VK_ATTACHMENT_STORE_OP_STORE, + .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD, + .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, + .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; + VkAttachmentDescription attColorResolve = { + .format = FB_COLOR_FORMAT, + .samples = VK_SAMPLE_COUNT_1_BIT, + .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + .storeOp = VK_ATTACHMENT_STORE_OP_STORE, + .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 }; + VkAttachmentDescription attDS = { + .format = VK_FORMAT_S8_UINT, + .samples = VKVG_SAMPLES, + .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR, + .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, + .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD, + .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, + .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }; +/* VkAttachmentDescription attDSResolve = { + .format = VK_FORMAT_S8_UINT, + .samples = VK_SAMPLE_COUNT_1_BIT, + .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + .storeOp = VK_ATTACHMENT_STORE_OP_STORE, + .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, + .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED, + .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };*/ + VkAttachmentDescription attachments[] = {attColor,attColorResolve,attDS}; + VkAttachmentReference colorRef = { + .attachment = 0, + .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; + VkAttachmentReference colorResolveRef = { + .attachment = 1, + .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; + VkAttachmentReference dsRef = { + .attachment = 2, + .layout = VK_IMAGE_LAYOUT_GENERAL }; + /*VkAttachmentReference dsResolveRef = { + .attachment = 3, + .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };*/ + VkSubpassDescription subpassDescription = { .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, + .colorAttachmentCount = 1, + .pColorAttachments = &colorRef, + .pResolveAttachments = &colorResolveRef, + .pDepthStencilAttachment = &dsRef}; + VkSubpassDependency dep0 = { + .srcSubpass = VK_SUBPASS_EXTERNAL, + .dstSubpass = 0, + .srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + .srcAccessMask = VK_ACCESS_MEMORY_READ_BIT, + .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT }; + VkSubpassDependency dep1 = { + .srcSubpass = 0, + .dstSubpass = VK_SUBPASS_EXTERNAL, + .srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + .dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT, + .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT }; + + VkSubpassDependency dependencies[] = {dep0,dep1}; + VkRenderPassCreateInfo renderPassInfo = { .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, + .attachmentCount = 3, + .pAttachments = attachments, + .subpassCount = 1, + .pSubpasses = &subpassDescription, + .dependencyCount = 2, + .pDependencies = dependencies }; + + VK_CHECK_RESULT(vkCreateRenderPass(dev->vkDev, &renderPassInfo, NULL, &dev->renderPass)); +} + +void _setupPipelines(VkvgDevice dev) +{ + VkGraphicsPipelineCreateInfo pipelineCreateInfo = { .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + .renderPass = dev->renderPass }; + + VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST }; + + VkPipelineRasterizationStateCreateInfo rasterizationState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, + .polygonMode = VK_POLYGON_MODE_FILL, + .cullMode = VK_CULL_MODE_NONE, + .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, + .depthClampEnable = VK_FALSE, + .rasterizerDiscardEnable = VK_FALSE, + .depthBiasEnable = VK_FALSE, + .lineWidth = 1.0f }; + + VkPipelineColorBlendAttachmentState blendAttachmentState = + { .colorWriteMask = 0x0, .blendEnable = VK_TRUE, + .srcColorBlendFactor = VK_BLEND_FACTOR_ONE, + .dstColorBlendFactor= VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + .colorBlendOp = VK_BLEND_OP_ADD, + .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, + .dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + .alphaBlendOp = VK_BLEND_OP_ADD, + }; + + VkPipelineColorBlendStateCreateInfo colorBlendState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + .attachmentCount = 1, + .pAttachments = &blendAttachmentState }; + + /*failOp,passOp,depthFailOp,compareOp, compareMask, writeMask, reference;*/ + VkStencilOpState clipingOpState = {VK_STENCIL_OP_KEEP,VK_STENCIL_OP_INCREMENT_AND_CLAMP,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,0x0,0xf,0}; + VkStencilOpState stencilOpState = {VK_STENCIL_OP_KEEP,VK_STENCIL_OP_REPLACE,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,0xf,0x0,0}; + + VkPipelineDepthStencilStateCreateInfo dsStateCreateInfo = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, + .depthTestEnable = VK_FALSE, + .depthWriteEnable = VK_FALSE, + .depthCompareOp = VK_COMPARE_OP_ALWAYS, + .stencilTestEnable = VK_TRUE, + .front = clipingOpState, + .back = clipingOpState }; + + VkDynamicState dynamicStateEnables[] = { + VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_SCISSOR, + VK_DYNAMIC_STATE_STENCIL_REFERENCE, + }; + VkPipelineDynamicStateCreateInfo dynamicState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + .dynamicStateCount = 3, + .pDynamicStates = dynamicStateEnables }; + + VkPipelineViewportStateCreateInfo viewportState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, + .viewportCount = 1, .scissorCount = 1 }; + + VkPipelineMultisampleStateCreateInfo multisampleState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, + .rasterizationSamples = VKVG_SAMPLES }; + if (VKVG_SAMPLES != VK_SAMPLE_COUNT_1_BIT){ + multisampleState.sampleShadingEnable = VK_TRUE; + multisampleState.minSampleShading = 0.25f; + multisampleState.alphaToCoverageEnable = VK_FALSE; + multisampleState.alphaToOneEnable = VK_FALSE; + } + VkVertexInputBindingDescription vertexInputBinding = { .binding = 0, + .stride = sizeof(Vertex), + .inputRate = VK_VERTEX_INPUT_RATE_VERTEX }; + + VkVertexInputAttributeDescription vertexInputAttributs[2] = { + {0, 0, VK_FORMAT_R32G32_SFLOAT, 0}, + {1, 0, VK_FORMAT_R32G32B32_SFLOAT, sizeof(vec2)} + }; + + VkPipelineVertexInputStateCreateInfo vertexInputState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + .vertexBindingDescriptionCount = 1, + .pVertexBindingDescriptions = &vertexInputBinding, + .vertexAttributeDescriptionCount = 2, + .pVertexAttributeDescriptions = vertexInputAttributs }; + + VkShaderModule modVert, modFrag; + VkShaderModuleCreateInfo createInfo = { .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .pCode = triangle_vert_spv, + .codeSize = triangle_vert_spv_len }; + VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modVert)); + createInfo.pCode = triangle_frag_spv; + createInfo.codeSize = triangle_frag_spv_len; + VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modFrag)); + + VkPipelineShaderStageCreateInfo vertStage = { .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .stage = VK_SHADER_STAGE_VERTEX_BIT, + .module = modVert, + .pName = "main", + }; + VkPipelineShaderStageCreateInfo fragStage = { .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .stage = VK_SHADER_STAGE_FRAGMENT_BIT, + .module = modFrag, + .pName = "main", + }; + + // Use specialization constants to pass number of samples to the shader (used for MSAA resolve) + VkSpecializationMapEntry specializationEntry = { + .constantID = 0, + .offset = 0, + .size = sizeof(uint32_t)}; + uint32_t specializationData = VKVG_SAMPLES; + VkSpecializationInfo specializationInfo = { + .mapEntryCount = 1, + .pMapEntries = &specializationEntry, + .dataSize = sizeof(specializationData), + .pData = &specializationData}; + + VkPipelineShaderStageCreateInfo shaderStages[] = {vertStage,fragStage}; + + pipelineCreateInfo.stageCount = 2; + pipelineCreateInfo.pStages = shaderStages; + pipelineCreateInfo.pVertexInputState = &vertexInputState; + pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState; + pipelineCreateInfo.pViewportState = &viewportState; + pipelineCreateInfo.pRasterizationState = &rasterizationState; + pipelineCreateInfo.pMultisampleState = &multisampleState; + pipelineCreateInfo.pColorBlendState = &colorBlendState; + pipelineCreateInfo.pDepthStencilState = &dsStateCreateInfo; + pipelineCreateInfo.pDynamicState = &dynamicState; + pipelineCreateInfo.layout = dev->pipelineLayout; + + VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineClipping)); + + //dsStateCreateInfo.back.writeMask = dsStateCreateInfo.front.writeMask = 0; + dsStateCreateInfo.back = dsStateCreateInfo.front = stencilOpState; + blendAttachmentState.colorWriteMask=0xf; + VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipeline)); + + blendAttachmentState.alphaBlendOp = blendAttachmentState.colorBlendOp = VK_BLEND_OP_SUBTRACT; + VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipeline_OP_SUB)); + + 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)); + + rasterizationState.polygonMode = VK_POLYGON_MODE_FILL; + inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST; + VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineLineList)); + + vkDestroyShaderModule(dev->vkDev, shaderStages[0].module, NULL); + vkDestroyShaderModule(dev->vkDev, shaderStages[1].module, NULL); +} + +void _createDescriptorSetLayout (VkvgDevice dev) { + + VkDescriptorSetLayoutBinding dsLayoutBinding = + {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,VK_SHADER_STAGE_FRAGMENT_BIT}; + VkDescriptorSetLayoutCreateInfo dsLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + .bindingCount = 1, + .pBindings = &dsLayoutBinding }; + VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslFont)); + VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslSrc)); + + VkPushConstantRange pushConstantRange[] = { + {VK_SHADER_STAGE_VERTEX_BIT,0,sizeof(push_constants)}, + //{VK_SHADER_STAGE_FRAGMENT_BIT,0,sizeof(push_constants)} + }; + VkDescriptorSetLayout dsls[] = {dev->dslFont,dev->dslSrc}; + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + .pushConstantRangeCount = 1, + .pPushConstantRanges = &pushConstantRange, + .setLayoutCount = 2, + .pSetLayouts = dsls }; + VK_CHECK_RESULT(vkCreatePipelineLayout(dev->vkDev, &pipelineLayoutCreateInfo, NULL, &dev->pipelineLayout)); +} + +void _wait_device_fence (VkvgDevice dev) { + vkWaitForFences (dev->vkDev, 1, &dev->fence, VK_TRUE, UINT64_MAX); + vkResetFences (dev->vkDev, 1, &dev->fence); +} diff --git a/src/vkvg_device_internal.h b/src/vkvg_device_internal.h index de11ab3..95099e3 100644 --- a/src/vkvg_device_internal.h +++ b/src/vkvg_device_internal.h @@ -35,6 +35,11 @@ typedef struct _vkvg_device_t{ VkvgContext lastCtx; //double linked list last elmt }vkvg_device; -void _flush_all_contexes (VkvgDevice dev); -void _init_all_contexes (VkvgDevice dev); +void _create_pipeline_cache (VkvgDevice dev); +void _setupRenderPass (VkvgDevice dev); +void _setupPipelines (VkvgDevice dev); +void _createDescriptorSetLayout (VkvgDevice dev); +void _flush_all_contexes (VkvgDevice dev); +void _init_all_contexes (VkvgDevice dev); +void _wait_device_fence (VkvgDevice dev); #endif diff --git a/src/vkvg_fonts.c b/src/vkvg_fonts.c index c8aed0a..b57f6fa 100644 --- a/src/vkvg_fonts.c +++ b/src/vkvg_fonts.c @@ -8,8 +8,7 @@ int defaultFontCharSize = 12<<6; void _init_fonts_cache (VkvgDevice dev){ - _font_cache_t* cache = (_font_cache_t*)malloc(sizeof(_font_cache_t)); - memset (cache, 0, sizeof(_font_cache_t)); + _font_cache_t* cache = (_font_cache_t*)calloc(1, sizeof(_font_cache_t)); cache->config = FcInitLoadConfigAndFonts(); @@ -87,7 +86,7 @@ void _increase_font_tex_array (VkvgDevice dev){ VkvgContext next = dev->lastCtx; while (next != NULL){ - _update_source_descriptor_set (next); + _update_descriptor_set (next, next->source, next->dsSrc); next = next->pPrev; } diff --git a/src/vkvg_surface.c b/src/vkvg_surface.c index 4e36af2..2fe0a9a 100644 --- a/src/vkvg_surface.c +++ b/src/vkvg_surface.c @@ -1,13 +1,15 @@ #include "vkvg_surface_internal.h" #include "vkvg_device_internal.h" +#include "vkvg_context_internal.h" +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" void _clear_stencil (VkvgSurface surf) { VkvgDevice dev = surf->dev; VkCommandBuffer cmd = dev->cmd; - vkWaitForFences (dev->vkDev, 1, &dev->fence, VK_TRUE, UINT64_MAX); - vkResetFences (dev->vkDev, 1, &dev->fence); + _wait_device_fence (dev); vkh_cmd_begin (cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT); @@ -27,18 +29,13 @@ void _clear_stencil (VkvgSurface surf) vkh_cmd_submit (dev->queue, &cmd, dev->fence); } -VkvgSurface vkvg_surface_create(VkvgDevice dev, uint32_t width, uint32_t height){ - VkvgSurface surf = (vkvg_surface*)calloc(1,sizeof(vkvg_surface)); - - surf->dev = dev; - surf->width = width; - surf->height = height; - - surf->img = vkh_image_create(dev,FB_COLOR_FORMAT,width,height,VK_IMAGE_TILING_LINEAR,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, +void _init_surface (VkvgSurface surf) { + surf->format = FB_COLOR_FORMAT;//force bgra internally + surf->img = vkh_image_create(surf->dev,surf->format,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT); - surf->imgMS = vkh_image_ms_create(dev,FB_COLOR_FORMAT,VKVG_SAMPLES,width,height,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + surf->imgMS = vkh_image_ms_create(surf->dev,surf->format,VKVG_SAMPLES,surf->width,surf->height,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT); - surf->stencilMS = vkh_image_ms_create(dev,VK_FORMAT_S8_UINT,VKVG_SAMPLES,width,height,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + surf->stencilMS = vkh_image_ms_create(surf->dev,VK_FORMAT_S8_UINT,VKVG_SAMPLES,surf->width,surf->height,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT); vkh_image_create_descriptor(surf->img, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST,VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER); @@ -51,15 +48,115 @@ VkvgSurface vkvg_surface_create(VkvgDevice dev, uint32_t width, uint32_t height) vkh_image_get_view (surf->stencilMS), }; VkFramebufferCreateInfo frameBufferCreateInfo = { .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, - .renderPass = dev->renderPass, + .renderPass = surf->dev->renderPass, .attachmentCount = 3, .pAttachments = attachments, - .width = width, - .height = height, + .width = surf->width, + .height = surf->height, .layers = 1 }; VK_CHECK_RESULT(vkCreateFramebuffer(surf->dev->vkDev, &frameBufferCreateInfo, NULL, &surf->fb)); _clear_stencil(surf); +} +VkvgSurface vkvg_surface_create(VkvgDevice dev, uint32_t width, uint32_t height){ + VkvgSurface surf = (vkvg_surface*)calloc(1,sizeof(vkvg_surface)); + + surf->dev = dev; + surf->width = width; + surf->height = height; + + _init_surface (surf); + + 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*)calloc(1,sizeof(vkvg_surface)); + + surf->dev = dev; + surf->width = w; + surf->height = h; + + _init_surface (surf); + + uint32_t imgSize = w * h * 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_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, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT); + vkh_image_create_descriptor (tmpImg, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, + VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER); + //staging buffer + VkhBuffer buff = vkh_buffer_create (dev, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, imgSize); + VK_CHECK_RESULT (vkh_buffer_map (buff)); + memcpy (vkh_buffer_get_mapped_pointer (buff), img, imgSize); + + 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); + + + VkBufferImageCopy bufferCopyRegion = { .imageSubresource = imgSubResLayers, + .imageExtent = {surf->width,surf->height,1}}; + + vkCmdCopyBufferToImage(cmd, vkh_buffer_get_vkbuffer (buff), + 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); + 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); + + VkImageBlit blit = { + .srcSubresource = imgSubResLayers, + .srcOffsets[1] = {surf->width, surf->height, 1}, + .dstSubresource = imgSubResLayers, + .dstOffsets[1] = {surf->width, surf->height, 1}, + }; + vkCmdBlitImage (cmd, + 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_cmd_end (cmd); + vkh_cmd_submit (dev->queue, &cmd, dev->fence); + + _wait_device_fence (dev); + + vkh_buffer_unmap (buff); + vkh_buffer_destroy (buff); + vkh_image_destroy (stagImg); + + //create tmp context with rendering pipeline to create the multisample img + VkvgContext ctx = vkvg_create (surf); + vec4 srcRect = {0,0,surf->width,surf->height}; + ctx->pushConsts.source = srcRect; + ctx->pushConsts.srcType = VKVG_SRC_PATTERN; + vkCmdPushConstants(ctx->cmd, ctx->pSurf->dev->pipelineLayout, + VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(push_constants), &ctx->pushConsts); + + _update_descriptor_set (ctx, tmpImg, ctx->dsSrc); + + vkvg_paint (ctx); + vkvg_destroy (ctx); + vkh_image_destroy (tmpImg); return surf; } diff --git a/src/vkvg_surface_internal.h b/src/vkvg_surface_internal.h index 1139a49..7d2d069 100644 --- a/src/vkvg_surface_internal.h +++ b/src/vkvg_surface_internal.h @@ -9,6 +9,7 @@ typedef struct _vkvg_surface_t { VkvgDevice dev; uint32_t width; uint32_t height; + VkFormat format; VkFramebuffer fb; VkhImage img; VkhImage imgMS; diff --git a/tests/test1.c b/tests/test1.c index 6d17b5e..b9499d2 100644 --- a/tests/test1.c +++ b/tests/test1.c @@ -1,5 +1,5 @@ -#define STB_IMAGE_IMPLEMENTATION -#include "stb_image.h" +//#define STB_IMAGE_IMPLEMENTATION +//#include "stb_image.h" #include "vke.h" //#include "compute.h" @@ -146,7 +146,7 @@ VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts) return VK_SAMPLE_COUNT_1_BIT; } -void vkengine_DumpInfos (VkEngine* 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); @@ -457,6 +457,22 @@ void vkvg_test_fill(VkvgContext ctx){ vkvg_fill(ctx); } +void vkvg_test_curves (VkvgContext ctx) { + vkvg_set_rgba (ctx, 1.0,1.0,1.0,1.0); + vkvg_set_linewidth(ctx, 10); + + /* + vkvg_move_to (ctx, 100, 400); + vkvg_curve_to (ctx, 100, 100, 600,700,600,400); + */ + //vkvg_move_to (ctx, 100, 100); + //vkvg_curve_to (ctx, 1000, 100, 100, 800, 1000, 800); + vkvg_move_to (ctx, 100, 100); + vkvg_curve_to (ctx, 1000, 500, 700, 500, 700, 100); + + vkvg_stroke (ctx); +} + void vkvg_rectangle(VkvgContext ctx, float x, float y, float width, float height){ vkvg_move_to(ctx,x,y); vkvg_line_to(ctx,x+width,y); @@ -502,54 +518,7 @@ void vkvg_test_stroke(VkvgContext ctx){ vkvg_stroke(ctx); } - - -int main(int argc, char *argv[]) { - dumpLayerExts(); - - VkEngine e = {}; - - EngineInit(&e); - - device = vkvg_device_create(e.phy, e.dev, e.renderer.queue, e.renderer.qFam); - - surf = vkvg_surface_create (device,1024,800); - - vkeCheckPhyPropBlitSource (&e); - glfwSetKeyCallback(e.renderer.window, key_callback); - - vke_swapchain_create(&e); - - VkvgSurface surf2 = vkvg_surface_create (device,1024,800);; - VkvgContext ctx = vkvg_create(surf2); - VkvgContext ctx2 = vkvg_create(surf); - vkvg_destroy(ctx2); - /*vkvg_destroy(ctx); - ctx = vkvg_create(surf); - vkvg_destroy(ctx); - - - ctx = vkvg_create(surf);*/ - vkvg_set_rgba(ctx,0.5,0,0,1); - vkvg_rectangle(ctx,0,0,1024,800); - vkvg_fill (ctx); - - vkvg_set_rgba(ctx,1,1,0,1); - vkvg_rectangle(ctx,200,200,400,400); - vkvg_fill (ctx); - vkvg_set_rgba(ctx,0,0,1,1); - vkvg_rectangle(ctx,300,300,400,400); - vkvg_stroke(ctx); - //vkvg_clip_preserve(ctx); - //vkvg_clip(ctx); - //vkvg_fill_preserve(ctx); - //vkvg_set_rgba(ctx,1,0,1,1); - - - //vkvg_select_font_face(ctx, "/usr/local/share/fonts/DroidSansMono.ttf"); - - //vkvg_select_font_face(ctx, "/usr/share/fonts/truetype/unifont/unifont.ttf"); - +void test_text (VkvgContext ctx) { int size = 19; int penY = 50; int penX = 10; @@ -557,6 +526,9 @@ int main(int argc, char *argv[]) { /*vkvg_rectangle(ctx,30,0,100,400); vkvg_clip(ctx);*/ + //vkvg_select_font_face(ctx, "/usr/local/share/fonts/DroidSansMono.ttf"); + //vkvg_select_font_face(ctx, "/usr/share/fonts/truetype/unifont/unifont.ttf"); + vkvg_set_font_size(ctx,size-10); vkvg_select_font_face(ctx, "droid"); vkvg_move_to(ctx, penX,penY); @@ -603,54 +575,84 @@ int main(int argc, char *argv[]) { vkvg_move_to(ctx, penX,penY); vkvg_show_text (ctx,"ABCDEFGHIJKLMNOPQRSTUVWXYZ"); penY+=size; + vkvg_move_to(ctx, penX,penY); + vkvg_show_text (ctx,"this is a test"); + penY+=size; + vkvg_move_to(ctx, penX,penY); + vkvg_show_text (ctx,"this is another test to see if label is working"); + penY+=size; vkvg_select_font_face(ctx, "mono"); vkvg_move_to(ctx, penX,penY); vkvg_show_text (ctx,"ABCDEFGHIJKLMNOPQRSTUVWXYZ"); penY+=size; + vkvg_move_to(ctx, 80,400); + vkvg_show_text (ctx,"Ленивый рыжий кот"); + + + /*vkvg_move_to(ctx, 150,250); + vkvg_show_text (ctx,"test string é€"); + vkvg_move_to(ctx, 150,300); + vkvg_show_text (ctx,"كسول الزنجبيل القط"); + vkvg_move_to(ctx, 150,350); + vkvg_show_text (ctx,"懶惰的姜貓");*/ //vkvg_show_text (ctx,"ABCDABCD"); //vkvg_show_text (ctx,"j"); +} - vkvg_test_fill(ctx); +void test_img_surface (VkvgContext ctx) { + VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "/mnt/data/images/blason.png"); + //VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "/mnt/data/images/2000px-Tux.svg.png"); + //VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "/mnt/data/images/path2674.png"); + //VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "/mnt/data/images/horse-black-head-shape-of-a-chess-piece_318-52446.jpg"); + vkvg_set_source_surface(ctx, imgSurf, 300, 300); + vkvg_paint(ctx); + vkvg_flush(ctx); + vkvg_surface_destroy(imgSurf); +} - //vkvg_rectangle(ctx,300,300,400,400); - //vkvg_clip(ctx); +int main(int argc, char *argv[]) { + dumpLayerExts(); + VkEngine e = {}; - vkvg_test_stroke(ctx); + EngineInit(&e); - //vkvg_reset_clip(ctx); - /*vkvg_set_rgba(ctx,1.0,0.0,0.0,0.1); - vkvg_move_to(ctx, 80,400); - vkvg_show_text (ctx,"Ленивый рыжий кот");*/ + device = vkvg_device_create(e.phy, e.dev, e.renderer.queue, e.renderer.qFam); + surf = vkvg_surface_create (device,1024,800); - /*vkvg_move_to(ctx, 150,250); - vkvg_show_text (ctx,"test string é€"); - vkvg_move_to(ctx, 150,300); - vkvg_show_text (ctx,"كسول الزنجبيل القط"); - vkvg_move_to(ctx, 150,350); - vkvg_show_text (ctx,"懶惰的姜貓");*/ + vkeCheckPhyPropBlitSource (&e); + glfwSetKeyCallback(e.renderer.window, key_callback); + vke_swapchain_create(&e); - vkvg_destroy(ctx); + VkvgSurface surf2 = vkvg_surface_create (device,1024,800);; + VkvgContext ctx = vkvg_create(surf); + + vkvg_set_rgba(ctx,0.01,0.01,0.1,1); + //vkvg_paint(ctx); + vkvg_rectangle(ctx,0,0,1024,800); + vkvg_fill (ctx); - ctx = vkvg_create(surf); + vkvg_test_fill(ctx); + vkvg_test_stroke(ctx); + vkvg_test_curves(ctx); + test_text(ctx); - vkvg_set_rgba(ctx,0.0,0.0,0.3,1); - vkvg_paint(ctx); + //test_img_surface(ctx); - vkvg_set_source_surface(ctx, surf2, 0, 0); + //vkvg_destroy(ctx); + //ctx = vkvg_create(surf); - //vkvg_set_rgba(ctx,0.0,1.0,1.0,1); - //vkvg_set_rgba(ctx,1.0,1.0,0,1); - //vkvg_rectangle(ctx,0,0,400,400); + //vkvg_set_rgba(ctx,0.0,0.0,0.0,1); + //vkvg_paint(ctx); - //vkvg_fill (ctx); - vkvg_paint(ctx); + //vkvg_set_source_surface(ctx, surf2, 0, 0); + //vkvg_paint(ctx); vkvg_destroy(ctx); diff --git a/vkh b/vkh index e533302..11a3c03 160000 --- a/vkh +++ b/vkh @@ -1 +1 @@ -Subproject commit e5333027ccbb7bb1c1e11e1164329530eac1da96 +Subproject commit 11a3c034e013251ae11e39d1bce38119b376db47