From: Jean-Philippe Bruyère Date: Wed, 15 Jul 2020 11:48:04 +0000 (+0200) Subject: copy tests from master X-Git-Url: https://git.osiis.dedyn.io/?a=commitdiff_plain;h=refs%2Fheads%2Fnewvx-post-transform;p=jp%2Fvkvg.git copy tests from master --- diff --git a/scripts/batchTests.sh b/scripts/batchTests.sh new file mode 100755 index 0000000..b880572 --- /dev/null +++ b/scripts/batchTests.sh @@ -0,0 +1,65 @@ +#!/bin/bash +#!/bin/bash +today=`date '+%Y%m%d-%HH%MM%S'`; +logdir=`pwd` + +POSITIONAL=() +while [[ $# -gt 0 ]] +do +key="$1" + +case $key in + -i|--iterations) + ITERATIONS="$2" + shift # past argument + shift # past value + ;; + -s|--size) + SIZE="$2" + shift # past argument + shift # past value + ;; + -d|--directory) + TESTDIR="$2" + shift # past argument + shift # past value + ;; + *) # unknown option + POSITIONAL+=("$1") # save it in an array for later + shift # past argument + ;; +esac +done +set -- "${POSITIONAL[@]}" # restore positional parameters + +if test -z "$TESTDIR" +then + TESTDIR="." +fi +if test -z "$ITERATIONS" +then + ITERATIONS="100" +fi +if test -z "$SIZE" +then + SIZE="100" +fi + + +cd $TESTDIR + +logfile="$logdir/log-$today.txt" + +git log -n 1 --pretty=format:'%h %d %s%n%n' > $logfile + +echo "_____________________________________________________________________________________________________" >> $logfile +echo "| Test File Name | Sub Test | Iter | SIZE | FPS | Average | Median | Sigma |" >> $logfile +echo "|-----------------|---------------------------|------|------|---------|---------|---------|---------|" >> $logfile +for file in test_* +do + if [[ -x "$file" ]] + then + ./"$file" $ITERATIONS $SIZE >> $logfile + fi +done +echo "_____________________________________________________________________________________________________" >> $logfile diff --git a/src/vkvg_context_internal.c b/src/vkvg_context_internal.c index 45261fe..d7ac701 100644 --- a/src/vkvg_context_internal.c +++ b/src/vkvg_context_internal.c @@ -1110,6 +1110,16 @@ void _fill_ec (VkvgContext ctx){ uint32_t pathPointCount = lastPtIdx - firstPtIdx + 1; uint32_t firstVertIdx = ctx->vertCount-ctx->curVertOffset; + if (pathPointCount == 3){ + v.pos = ctx->points[firstPtIdx]; + _add_vertex(ctx, v); + v.pos = ctx->points[firstPtIdx+1]; + _add_vertex(ctx, v); + v.pos = ctx->points[firstPtIdx+2]; + _add_vertex(ctx, v); + _add_triangle_indices (ctx, firstVertIdx, firstVertIdx+1, firstVertIdx+2); + } + ear_clip_point ecps[pathPointCount]; uint32_t ecps_count = 0, i = 0; diff --git a/src/vkvg_device_internal.c b/src/vkvg_device_internal.c index 1755e98..4b05b03 100644 --- a/src/vkvg_device_internal.c +++ b/src/vkvg_device_internal.c @@ -28,475 +28,478 @@ #include "shaders.h" void _flush_all_contexes (VkvgDevice dev){ - VkvgContext next = dev->lastCtx; - while (next != NULL){ - _flush_cmd_buff(next); - next = next->pPrev; - } + VkvgContext next = dev->lastCtx; + while (next != NULL){ + _flush_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)); + VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO}; + VK_CHECK_RESULT(vkCreatePipelineCache(dev->vkDev, &pipelineCacheCreateInfo, NULL, &dev->pipelineCache)); } VkRenderPass _createRenderPassNoResolve(VkvgDevice dev, VkAttachmentLoadOp loadOp, VkAttachmentLoadOp stencilLoadOp) { - VkAttachmentDescription attColor = { - .format = FB_COLOR_FORMAT, - .samples = dev->samples, - .loadOp = loadOp, - .storeOp = VK_ATTACHMENT_STORE_OP_STORE, - .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, - .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; - VkAttachmentDescription attDS = { - .format = FB_STENCIL_FORMAT, - .samples = dev->samples, - .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, - .stencilLoadOp = stencilLoadOp, - .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, - .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }; - - VkAttachmentDescription attachments[] = {attColor,attDS}; - VkAttachmentReference colorRef = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; - VkAttachmentReference dsRef = {1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL}; - - VkSubpassDescription subpassDescription = { .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, - .colorAttachmentCount = 1, - .pColorAttachments = &colorRef, - .pDepthStencilAttachment= &dsRef}; - - VkSubpassDependency dependencies[] = - { - { VK_SUBPASS_EXTERNAL, 0, - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - VK_ACCESS_MEMORY_READ_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - VK_DEPENDENCY_BY_REGION_BIT}, - { 0, VK_SUBPASS_EXTERNAL, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT, - VK_DEPENDENCY_BY_REGION_BIT}, - }; - - VkRenderPassCreateInfo renderPassInfo = { .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, - .attachmentCount = 2, - .pAttachments = attachments, - .subpassCount = 1, - .pSubpasses = &subpassDescription, - .dependencyCount = 2, - .pDependencies = dependencies - }; - VkRenderPass rp; - VK_CHECK_RESULT(vkCreateRenderPass(dev->vkDev, &renderPassInfo, NULL, &rp)); - return rp; + VkAttachmentDescription attColor = { + .format = FB_COLOR_FORMAT, + .samples = dev->samples, + .loadOp = loadOp, + .storeOp = VK_ATTACHMENT_STORE_OP_STORE, + .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, + .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; + VkAttachmentDescription attDS = { + .format = FB_STENCIL_FORMAT, + .samples = dev->samples, + .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, + .stencilLoadOp = stencilLoadOp, + .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, + .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }; + + VkAttachmentDescription attachments[] = {attColor,attDS}; + VkAttachmentReference colorRef = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; + VkAttachmentReference dsRef = {1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL}; + + VkSubpassDescription subpassDescription = { .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, + .colorAttachmentCount = 1, + .pColorAttachments = &colorRef, + .pDepthStencilAttachment= &dsRef}; + + VkSubpassDependency dependencies[] = + { + { VK_SUBPASS_EXTERNAL, 0, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + VK_ACCESS_MEMORY_READ_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + VK_DEPENDENCY_BY_REGION_BIT}, + { 0, VK_SUBPASS_EXTERNAL, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT, + VK_DEPENDENCY_BY_REGION_BIT}, + }; + + VkRenderPassCreateInfo renderPassInfo = { .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, + .attachmentCount = 2, + .pAttachments = attachments, + .subpassCount = 1, + .pSubpasses = &subpassDescription, + .dependencyCount = 2, + .pDependencies = dependencies + }; + VkRenderPass rp; + VK_CHECK_RESULT(vkCreateRenderPass(dev->vkDev, &renderPassInfo, NULL, &rp)); + return rp; } VkRenderPass _createRenderPassMS(VkvgDevice dev, VkAttachmentLoadOp loadOp, VkAttachmentLoadOp stencilLoadOp) { - VkAttachmentDescription attColor = { - .format = FB_COLOR_FORMAT, - .samples = dev->samples, - .loadOp = loadOp, - .storeOp = VK_ATTACHMENT_STORE_OP_STORE, - .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, - .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - .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_COLOR_ATTACHMENT_OPTIMAL }; - VkAttachmentDescription attDS = { - .format = FB_STENCIL_FORMAT, - .samples = dev->samples, - .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, - .stencilLoadOp = stencilLoadOp, - .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, - .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }; - - VkAttachmentDescription attachments[] = {attColorResolve,attDS,attColor}; - VkAttachmentReference resolveRef= {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; - VkAttachmentReference dsRef = {1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL}; - VkAttachmentReference colorRef = {2, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; - - VkSubpassDescription subpassDescription = { .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, - .colorAttachmentCount = 1, - .pColorAttachments = &colorRef, - .pResolveAttachments = &resolveRef, - .pDepthStencilAttachment= &dsRef}; - - VkSubpassDependency dependencies[] = - { - { VK_SUBPASS_EXTERNAL, 0, - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - VK_ACCESS_MEMORY_READ_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - VK_DEPENDENCY_BY_REGION_BIT}, - { 0, VK_SUBPASS_EXTERNAL, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT, - VK_DEPENDENCY_BY_REGION_BIT}, - }; - - VkRenderPassCreateInfo renderPassInfo = { .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, - .attachmentCount = 3, - .pAttachments = attachments, - .subpassCount = 1, - .pSubpasses = &subpassDescription, - .dependencyCount = 2, - .pDependencies = dependencies - }; - VkRenderPass rp; - VK_CHECK_RESULT(vkCreateRenderPass(dev->vkDev, &renderPassInfo, NULL, &rp)); - return rp; + VkAttachmentDescription attColor = { + .format = FB_COLOR_FORMAT, + .samples = dev->samples, + .loadOp = loadOp, + .storeOp = VK_ATTACHMENT_STORE_OP_STORE, + .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, + .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + .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_COLOR_ATTACHMENT_OPTIMAL }; + VkAttachmentDescription attDS = { + .format = FB_STENCIL_FORMAT, + .samples = dev->samples, + .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, + .stencilLoadOp = stencilLoadOp, + .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE, + .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }; + + VkAttachmentDescription attachments[] = {attColorResolve,attDS,attColor}; + VkAttachmentReference resolveRef= {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; + VkAttachmentReference dsRef = {1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL}; + VkAttachmentReference colorRef = {2, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; + + VkSubpassDescription subpassDescription = { .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, + .colorAttachmentCount = 1, + .pColorAttachments = &colorRef, + .pResolveAttachments = &resolveRef, + .pDepthStencilAttachment= &dsRef}; + + VkSubpassDependency dependencies[] = + { + { VK_SUBPASS_EXTERNAL, 0, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + VK_ACCESS_MEMORY_READ_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + VK_DEPENDENCY_BY_REGION_BIT}, + { 0, VK_SUBPASS_EXTERNAL, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT, + VK_DEPENDENCY_BY_REGION_BIT}, + }; + + VkRenderPassCreateInfo renderPassInfo = { .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, + .attachmentCount = 3, + .pAttachments = attachments, + .subpassCount = 1, + .pSubpasses = &subpassDescription, + .dependencyCount = 2, + .pDependencies = dependencies + }; + VkRenderPass rp; + VK_CHECK_RESULT(vkCreateRenderPass(dev->vkDev, &renderPassInfo, NULL, &rp)); + return rp; } 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_FAN }; - - 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, + 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_FAN }; + + 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, #ifdef VKVG_PREMULT_ALPHA - .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, - .alphaBlendOp = VK_BLEND_OP_ADD, + .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, + .alphaBlendOp = VK_BLEND_OP_ADD, #else - .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, - .dstColorBlendFactor= VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - .colorBlendOp = VK_BLEND_OP_ADD, - .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, - .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO, - .alphaBlendOp = VK_BLEND_OP_ADD, + .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, + .dstColorBlendFactor= VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + .colorBlendOp = VK_BLEND_OP_ADD, + .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, + .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO, + .alphaBlendOp = VK_BLEND_OP_ADD, #endif - }; - - VkPipelineColorBlendStateCreateInfo colorBlendState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - .attachmentCount = 1, - .pAttachments = &blendAttachmentState }; - - /*failOp,passOp,depthFailOp,compareOp, compareMask, writeMask, reference;*/ - VkStencilOpState polyFillOpState ={VK_STENCIL_OP_KEEP,VK_STENCIL_OP_INVERT,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,STENCIL_CLIP_BIT,STENCIL_FILL_BIT,0}; - VkStencilOpState clipingOpState = {VK_STENCIL_OP_ZERO,VK_STENCIL_OP_REPLACE,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,STENCIL_FILL_BIT,STENCIL_ALL_BIT,0x2}; - VkStencilOpState stencilOpState = {VK_STENCIL_OP_KEEP,VK_STENCIL_OP_ZERO,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,STENCIL_FILL_BIT,STENCIL_FILL_BIT,0x1}; - - 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 = polyFillOpState, - .back = polyFillOpState }; - - VkDynamicState dynamicStateEnables[] = { - VK_DYNAMIC_STATE_VIEWPORT, - VK_DYNAMIC_STATE_SCISSOR, - VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, - VK_DYNAMIC_STATE_STENCIL_REFERENCE, - VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, - }; - VkPipelineDynamicStateCreateInfo dynamicState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, - .dynamicStateCount = 2, - .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 = dev->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[4] = { - {0, 0, VK_FORMAT_R32G32_SFLOAT, 0}, - {1, 0, VK_FORMAT_R8G8B8A8_UNORM, 8}, - {2, 0, VK_FORMAT_R32G32_SFLOAT, 12}, - {3, 0, VK_FORMAT_R8_SINT, 20}, - }; - - VkPipelineVertexInputStateCreateInfo vertexInputState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - .vertexBindingDescriptionCount = 1, - .pVertexBindingDescriptions = &vertexInputBinding, - .vertexAttributeDescriptionCount = 4, - .pVertexAttributeDescriptions = vertexInputAttributs }; - - VkShaderModule modVert, modFrag, modFragWired; - VkShaderModuleCreateInfo createInfo = { .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, - .pCode = (uint32_t*)vkvg_main_vert_spv, - .codeSize = vkvg_main_vert_spv_len }; - VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modVert)); + }; + + VkPipelineColorBlendStateCreateInfo colorBlendState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + .attachmentCount = 1, + .pAttachments = &blendAttachmentState }; + + /*failOp,passOp,depthFailOp,compareOp, compareMask, writeMask, reference;*/ + VkStencilOpState polyFillOpState ={VK_STENCIL_OP_KEEP,VK_STENCIL_OP_INVERT,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,STENCIL_CLIP_BIT,STENCIL_FILL_BIT,0}; + VkStencilOpState clipingOpState = {VK_STENCIL_OP_ZERO,VK_STENCIL_OP_REPLACE,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,STENCIL_FILL_BIT,STENCIL_ALL_BIT,0x2}; + VkStencilOpState stencilOpState = {VK_STENCIL_OP_KEEP,VK_STENCIL_OP_ZERO,VK_STENCIL_OP_KEEP,VK_COMPARE_OP_EQUAL,STENCIL_FILL_BIT,STENCIL_FILL_BIT,0x1}; + + 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 = polyFillOpState, + .back = polyFillOpState }; + + VkDynamicState dynamicStateEnables[] = { + VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_SCISSOR, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, + VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, + }; + VkPipelineDynamicStateCreateInfo dynamicState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + .dynamicStateCount = 2, + .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 = dev->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[4] = { + {0, 0, VK_FORMAT_R32G32_SFLOAT, 0}, + {1, 0, VK_FORMAT_R8G8B8A8_UNORM, 8}, + {2, 0, VK_FORMAT_R32G32_SFLOAT, 12}, + {3, 0, VK_FORMAT_R8_SINT, 20}, + }; + + VkPipelineVertexInputStateCreateInfo vertexInputState = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + .vertexBindingDescriptionCount = 1, + .pVertexBindingDescriptions = &vertexInputBinding, + .vertexAttributeDescriptionCount = 4, + .pVertexAttributeDescriptions = vertexInputAttributs }; + + VkShaderModule modVert, modFrag, modFragWired; + VkShaderModuleCreateInfo createInfo = { .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .pCode = (uint32_t*)vkvg_main_vert_spv, + .codeSize = vkvg_main_vert_spv_len }; + VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modVert)); #ifdef VKVG_LCD_FONT_FILTER - createInfo.pCode = (uint32_t*)vkvg_main_lcd_frag_spv; - createInfo.codeSize = vkvg_main_lcd_frag_spv_len; + createInfo.pCode = (uint32_t*)vkvg_main_lcd_frag_spv; + createInfo.codeSize = vkvg_main_lcd_frag_spv_len; #else - createInfo.pCode = (uint32_t*)vkvg_main_frag_spv; - createInfo.codeSize = vkvg_main_frag_spv_len; + createInfo.pCode = (uint32_t*)vkvg_main_frag_spv; + createInfo.codeSize = vkvg_main_frag_spv_len; #endif - 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 = 1; - 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->pipelinePolyFill)); - - inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - dsStateCreateInfo.back = dsStateCreateInfo.front = clipingOpState; - dynamicState.dynamicStateCount = 5; - //VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineClipping)); - - dsStateCreateInfo.back = dsStateCreateInfo.front = stencilOpState; - blendAttachmentState.colorWriteMask=0xf; - dynamicState.dynamicStateCount = 3; - pipelineCreateInfo.stageCount = 2; - VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 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)); - - 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(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 = 1; + 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->pipelinePolyFill)); + + inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + dsStateCreateInfo.back = dsStateCreateInfo.front = clipingOpState; + dynamicState.dynamicStateCount = 5; + //VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 1, &pipelineCreateInfo, NULL, &dev->pipelineClipping)); + + dsStateCreateInfo.back = dsStateCreateInfo.front = stencilOpState; + blendAttachmentState.colorWriteMask=0xf; + dynamicState.dynamicStateCount = 3; + pipelineCreateInfo.stageCount = 2; + VK_CHECK_RESULT(vkCreateGraphicsPipelines(dev->vkDev, dev->pipelineCache, 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)); + + 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)); #ifdef VKVG_WIRED_DEBUG - 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)); - - createInfo.pCode = (uint32_t*)wired_frag_spv; - createInfo.codeSize = wired_frag_spv_len; - VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modFragWired)); - - shaderStages[1].module = modFragWired; - 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)); - vkDestroyShaderModule(dev->vkDev, modFragWired, NULL); + 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)); + + createInfo.pCode = (uint32_t*)wired_frag_spv; + createInfo.codeSize = wired_frag_spv_len; + VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modFragWired)); + + shaderStages[1].module = modFragWired; + 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)); + vkDestroyShaderModule(dev->vkDev, modFragWired, NULL); #endif - vkDestroyShaderModule(dev->vkDev, modVert, NULL); - vkDestroyShaderModule(dev->vkDev, modFrag, NULL); + vkDestroyShaderModule(dev->vkDev, modVert, NULL); + vkDestroyShaderModule(dev->vkDev, modFrag, NULL); } void _createDescriptorSetLayout (VkvgDevice dev) { - VkDescriptorSetLayoutBinding dsLayoutBinding[] = { - {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,VK_SHADER_STAGE_FRAGMENT_BIT, NULL}, - {1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,VK_SHADER_STAGE_FRAGMENT_BIT, NULL}, - {2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1,VK_SHADER_STAGE_FRAGMENT_BIT, NULL} - }; - VkDescriptorSetLayoutCreateInfo dsLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - .bindingCount = 3, - .pBindings = dsLayoutBinding }; - if (CmdPushDescriptorSet) - dsLayoutCreateInfo.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR; - - //VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslFont)); - VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslSrc)); - //dsLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - - //VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslGrad)); - - VkPushConstantRange pushConstantRange[] = { - {VK_SHADER_STAGE_VERTEX_BIT,0,sizeof(push_constants)}, - }; - //VkDescriptorSetLayout dsls[] = {dev->dslFont,dev->dslSrc,dev->dslGrad}; - - VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, - .pushConstantRangeCount = 1, - .pPushConstantRanges = (VkPushConstantRange*)&pushConstantRange, - .setLayoutCount = 1, - .pSetLayouts = &dev->dslSrc }; - VK_CHECK_RESULT(vkCreatePipelineLayout(dev->vkDev, &pipelineLayoutCreateInfo, NULL, &dev->pipelineLayout)); + VkDescriptorSetLayoutBinding dsLayoutBinding[] = { + {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,VK_SHADER_STAGE_FRAGMENT_BIT, NULL}, + {1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,VK_SHADER_STAGE_FRAGMENT_BIT, NULL}, + {2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1,VK_SHADER_STAGE_FRAGMENT_BIT, NULL} + }; + VkDescriptorSetLayoutCreateInfo dsLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + .bindingCount = 3, + .pBindings = dsLayoutBinding }; + if (CmdPushDescriptorSet) + dsLayoutCreateInfo.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR; + + //VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslFont)); + VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslSrc)); + //dsLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + + //VK_CHECK_RESULT(vkCreateDescriptorSetLayout(dev->vkDev, &dsLayoutCreateInfo, NULL, &dev->dslGrad)); + + VkPushConstantRange pushConstantRange[] = { + {VK_SHADER_STAGE_VERTEX_BIT,0,sizeof(push_constants)}, + }; + //VkDescriptorSetLayout dsls[] = {dev->dslFont,dev->dslSrc,dev->dslGrad}; + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + .pushConstantRangeCount = 1, + .pPushConstantRanges = (VkPushConstantRange*)&pushConstantRange, + .setLayoutCount = 1, + .pSetLayouts = &dev->dslSrc }; + VK_CHECK_RESULT(vkCreatePipelineLayout(dev->vkDev, &pipelineLayoutCreateInfo, NULL, &dev->pipelineLayout)); } VkSampler _get_sampler_for_pattern (VkvgDevice dev, VkvgPattern pat) { - VkFilter filter = VK_FILTER_NEAREST; - switch (pat->filter) { - case VKVG_FILTER_BILINEAR: - case VKVG_FILTER_BEST: - filter = VK_FILTER_LINEAR; - break; - default: - filter = VK_FILTER_NEAREST; - break; - } - VkSamplerAddressMode addrMode; - switch (pat->extend) { - case VKVG_EXTEND_NONE: - addrMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; - break; - case VKVG_EXTEND_PAD: - addrMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - break; - case VKVG_EXTEND_REPEAT: - addrMode = VK_SAMPLER_ADDRESS_MODE_REPEAT; - break; - case VKVG_EXTEND_REFLECT: - addrMode = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; - break; - } - if (dev->samplers[filter][addrMode] == VK_NULL_HANDLE) - dev->samplers[filter][addrMode] = vkh_device_create_sampler((VkhDevice)dev, filter, filter, - VK_SAMPLER_MIPMAP_MODE_NEAREST, addrMode); - return dev->samplers[filter][addrMode]; + VkFilter filter = VK_FILTER_NEAREST; + switch (pat->filter) { + case VKVG_FILTER_BILINEAR: + case VKVG_FILTER_BEST: + filter = VK_FILTER_LINEAR; + break; + default: + filter = VK_FILTER_NEAREST; + break; + } + VkSamplerAddressMode addrMode; + switch (pat->extend) { + case VKVG_EXTEND_NONE: + addrMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; + break; + case VKVG_EXTEND_PAD: + addrMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + break; + case VKVG_EXTEND_REPEAT: + addrMode = VK_SAMPLER_ADDRESS_MODE_REPEAT; + break; + case VKVG_EXTEND_REFLECT: + addrMode = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; + break; + } + if (dev->samplers[filter][addrMode] == VK_NULL_HANDLE) + dev->samplers[filter][addrMode] = vkh_device_create_sampler((VkhDevice)dev, filter, filter, + VK_SAMPLER_MIPMAP_MODE_NEAREST, addrMode); + return dev->samplers[filter][addrMode]; } void _destroy_samplers (VkvgDevice dev) { - for (int i=0;i<5;i++) { - for (int j=0;j<2;j++) { - if (dev->samplers[j][i] != VK_NULL_HANDLE) - vkh_device_destroy_sampler((VkhDevice)dev, dev->samplers[j][i]); - } - } + for (int i=0;i<5;i++) { + for (int j=0;j<2;j++) { + if (dev->samplers[j][i] != VK_NULL_HANDLE) + vkh_device_destroy_sampler((VkhDevice)dev, dev->samplers[j][i]); + } + } } void _wait_idle (VkvgDevice dev) { - vkDeviceWaitIdle (dev->vkDev); + vkDeviceWaitIdle (dev->vkDev); } void _wait_and_reset_device_fence (VkvgDevice dev) { - vkWaitForFences (dev->vkDev, 1, &dev->fence, VK_TRUE, UINT64_MAX); - vkResetFences (dev->vkDev, 1, &dev->fence); - vkResetCommandBuffer (dev->cmd, 0); + vkWaitForFences (dev->vkDev, 1, &dev->fence, VK_TRUE, UINT64_MAX); + vkResetFences (dev->vkDev, 1, &dev->fence); + vkResetCommandBuffer (dev->cmd, 0); } void _submit_cmd (VkvgDevice dev, VkCommandBuffer* cmd, VkFence fence) { - MUTEX_LOCK (&dev->gQMutex); - vkh_cmd_submit (dev->gQueue, cmd, fence); - MUTEX_UNLOCK (&dev->gQMutex); + MUTEX_LOCK (&dev->gQMutex); + vkh_cmd_submit (dev->gQueue, cmd, fence); + MUTEX_UNLOCK (&dev->gQMutex); } void _init_function_pointers (VkvgDevice dev) { - CmdBindPipeline = GetInstProcAddress(dev->instance, vkCmdBindPipeline); - CmdBindDescriptorSets = GetInstProcAddress(dev->instance, vkCmdBindDescriptorSets); - CmdBindIndexBuffer = GetInstProcAddress(dev->instance, vkCmdBindIndexBuffer); - CmdBindVertexBuffers = GetInstProcAddress(dev->instance, vkCmdBindVertexBuffers); - CmdDrawIndexed = GetInstProcAddress(dev->instance, vkCmdDrawIndexed); - CmdDraw = GetInstProcAddress(dev->instance, vkCmdDraw); - CmdSetStencilCompareMask= GetInstProcAddress(dev->instance, vkCmdSetStencilCompareMask); - CmdSetStencilReference = GetInstProcAddress(dev->instance, vkCmdSetStencilReference); - CmdSetStencilWriteMask = GetInstProcAddress(dev->instance, vkCmdSetStencilWriteMask); - CmdBeginRenderPass = GetInstProcAddress(dev->instance, vkCmdBeginRenderPass); - CmdEndRenderPass = GetInstProcAddress(dev->instance, vkCmdEndRenderPass); - CmdSetViewport = GetInstProcAddress(dev->instance, vkCmdSetViewport); - CmdSetScissor = GetInstProcAddress(dev->instance, vkCmdSetScissor); - CmdPushConstants = GetInstProcAddress(dev->instance, vkCmdPushConstants); - CmdPushDescriptorSet = (PFN_vkCmdPushDescriptorSetKHR)vkGetInstanceProcAddr(dev->instance, "vkCmdPushDescriptorSetKHR"); + CmdBindPipeline = GetInstProcAddress(dev->instance, vkCmdBindPipeline); + CmdBindDescriptorSets = GetInstProcAddress(dev->instance, vkCmdBindDescriptorSets); + CmdBindIndexBuffer = GetInstProcAddress(dev->instance, vkCmdBindIndexBuffer); + CmdBindVertexBuffers = GetInstProcAddress(dev->instance, vkCmdBindVertexBuffers); + CmdDrawIndexed = GetInstProcAddress(dev->instance, vkCmdDrawIndexed); + CmdDraw = GetInstProcAddress(dev->instance, vkCmdDraw); + CmdSetStencilCompareMask= GetInstProcAddress(dev->instance, vkCmdSetStencilCompareMask); + CmdSetStencilReference = GetInstProcAddress(dev->instance, vkCmdSetStencilReference); + CmdSetStencilWriteMask = GetInstProcAddress(dev->instance, vkCmdSetStencilWriteMask); + CmdBeginRenderPass = GetInstProcAddress(dev->instance, vkCmdBeginRenderPass); + CmdEndRenderPass = GetInstProcAddress(dev->instance, vkCmdEndRenderPass); + CmdSetViewport = GetInstProcAddress(dev->instance, vkCmdSetViewport); + CmdSetScissor = GetInstProcAddress(dev->instance, vkCmdSetScissor); + CmdPushConstants = GetInstProcAddress(dev->instance, vkCmdPushConstants); + CmdPushDescriptorSet = (PFN_vkCmdPushDescriptorSetKHR)vkGetInstanceProcAddr(dev->instance, "vkCmdPushDescriptorSetKHR"); +#ifdef DEBUG + vkh_device_init_debug_utils ((VkhDevice)dev); +#endif } void _create_empty_texture (VkvgDevice dev) { - //create empty image to bind to context source descriptor when not in use - dev->emptyImg = vkh_image_create((VkhDevice)dev,FB_COLOR_FORMAT,16,16,VKVG_TILING,VMA_MEMORY_USAGE_GPU_ONLY, - VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); - vkh_image_create_descriptor(dev->emptyImg, 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_EDGE); + //create empty image to bind to context source descriptor when not in use + dev->emptyImg = vkh_image_create((VkhDevice)dev,FB_COLOR_FORMAT,16,16,VKVG_TILING,VMA_MEMORY_USAGE_GPU_ONLY, + VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); + vkh_image_create_descriptor(dev->emptyImg, 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_EDGE); - _wait_and_reset_device_fence (dev); - vkh_cmd_begin (dev->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT); + _wait_and_reset_device_fence (dev); + vkh_cmd_begin (dev->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT); #ifdef DEBUG - vkh_cmd_label_start(dev->cmd, "create empty texture", (float[]){0.5,0,0,1}); + vkh_cmd_label_start(dev->cmd, "create empty texture", (float[]){0.5,0,0,1}); #endif - vkh_image_set_layout (dev->cmd, dev->emptyImg, VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); + vkh_image_set_layout (dev->cmd, dev->emptyImg, VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); #ifdef DEBUG - vkh_cmd_label_end(dev->cmd); + vkh_cmd_label_end(dev->cmd); #endif - vkh_cmd_end (dev->cmd); - _submit_cmd (dev, &dev->cmd, dev->fence); + vkh_cmd_end (dev->cmd); + _submit_cmd (dev, &dev->cmd, dev->fence); } void _dump_image_format_properties (VkvgDevice dev) { - VkImageFormatProperties imgProps; - VK_CHECK_RESULT(vkGetPhysicalDeviceImageFormatProperties(dev->phy, - FB_COLOR_FORMAT, VK_IMAGE_TYPE_2D, VKVG_TILING, - VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT, - 0, &imgProps)); - printf ("tiling = %d\n", VKVG_TILING); - printf ("max extend = (%d, %d, %d)\n", imgProps.maxExtent.width, imgProps.maxExtent.height, imgProps.maxExtent.depth); - printf ("max mip levels = %d\n", imgProps.maxMipLevels); - printf ("max array layers = %d\n", imgProps.maxArrayLayers); - printf ("sample counts = "); - if (imgProps.sampleCounts & VK_SAMPLE_COUNT_1_BIT) - printf ("1,"); - if (imgProps.sampleCounts & VK_SAMPLE_COUNT_2_BIT) - printf ("2,"); - if (imgProps.sampleCounts & VK_SAMPLE_COUNT_4_BIT) - printf ("4,"); - if (imgProps.sampleCounts & VK_SAMPLE_COUNT_8_BIT) - printf ("8,"); - if (imgProps.sampleCounts & VK_SAMPLE_COUNT_16_BIT) - printf ("16,"); - if (imgProps.sampleCounts & VK_SAMPLE_COUNT_32_BIT) - printf ("32,"); - printf ("\n"); - printf ("max resource size= %lu\n", imgProps.maxResourceSize); + VkImageFormatProperties imgProps; + VK_CHECK_RESULT(vkGetPhysicalDeviceImageFormatProperties(dev->phy, + FB_COLOR_FORMAT, VK_IMAGE_TYPE_2D, VKVG_TILING, + VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT, + 0, &imgProps)); + printf ("tiling = %d\n", VKVG_TILING); + printf ("max extend = (%d, %d, %d)\n", imgProps.maxExtent.width, imgProps.maxExtent.height, imgProps.maxExtent.depth); + printf ("max mip levels = %d\n", imgProps.maxMipLevels); + printf ("max array layers = %d\n", imgProps.maxArrayLayers); + printf ("sample counts = "); + if (imgProps.sampleCounts & VK_SAMPLE_COUNT_1_BIT) + printf ("1,"); + if (imgProps.sampleCounts & VK_SAMPLE_COUNT_2_BIT) + printf ("2,"); + if (imgProps.sampleCounts & VK_SAMPLE_COUNT_4_BIT) + printf ("4,"); + if (imgProps.sampleCounts & VK_SAMPLE_COUNT_8_BIT) + printf ("8,"); + if (imgProps.sampleCounts & VK_SAMPLE_COUNT_16_BIT) + printf ("16,"); + if (imgProps.sampleCounts & VK_SAMPLE_COUNT_32_BIT) + printf ("32,"); + printf ("\n"); + printf ("max resource size= %lu\n", imgProps.maxResourceSize); } diff --git a/tests/arcs.c b/tests/arcs.c index 3d10c35..daeb48c 100644 --- a/tests/arcs.c +++ b/tests/arcs.c @@ -1,25 +1,91 @@ #include "test.h" -void test(){ - VkvgContext ctx = vkvg_create(surf); +void draw_growing_circles (VkvgContext ctx, float y, int count) { + float x = 2; + for (int i=1; itv_sec = (long) ((nTime - EPOCH) / 10000000L); + tp->tv_usec = (long) (nSystemTime.wMilliseconds * 1000); + return 0; +} +#endif + +float panX = 0.f; +float panY = 0.f; float lastX = 0.f; float lastY = 0.f; -float zoom = 1.0f; +float zoom = 1.0f; bool mouseDown = false; -VkvgDevice device = NULL; -VkvgSurface surf = NULL; +VkvgDevice device = NULL; +VkvgSurface surf = NULL; + +uint32_t test_size = 100; // items drawn in one run, or complexity +uint32_t iterations = 1000;// repeat test n times +uint32_t test_width = 1024; +uint32_t test_height= 768; +bool test_vsync = false; -uint test_size = 100; // items drawn in one run, or complexity -int iterations = 40000; // repeat test n times static bool paused = false; -static VkSampleCountFlags samples = VK_SAMPLE_COUNT_4_BIT; +static VkSampleCountFlags samples = VK_SAMPLE_COUNT_8_BIT; static vk_engine_t* 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_SPACE: - paused = !paused; - break; - case GLFW_KEY_ESCAPE : - glfwSetWindowShouldClose(window, GLFW_TRUE); - break; - } + if (action != GLFW_PRESS) + return; + switch (key) { + case GLFW_KEY_SPACE: + paused = !paused; + break; + case GLFW_KEY_ESCAPE : + glfwSetWindowShouldClose(window, GLFW_TRUE); + break; + } } static void char_callback (GLFWwindow* window, uint32_t c){} static void mouse_move_callback(GLFWwindow* window, double x, double y){ - if (mouseDown) { - panX += ((float)x-lastX); - panY += ((float)y-lastY); - } - lastX = (float)x; - lastY = (float)y; + if (mouseDown) { + panX += ((float)x-lastX); + panY += ((float)y-lastY); + } + lastX = (float)x; + lastY = (float)y; } static void scroll_callback(GLFWwindow* window, double x, double y){ - if (y<0.f) - zoom *= 0.5f; - else - zoom *= 2.0f; + if (y<0.f) + zoom *= 0.5f; + else + zoom *= 2.0f; } static void mouse_button_callback(GLFWwindow* window, int but, int state, int modif){ - if (but != GLFW_MOUSE_BUTTON_1) - return; - if (state == GLFW_TRUE) - mouseDown = true; - else - mouseDown = false; + if (but != GLFW_MOUSE_BUTTON_1) + return; + if (state == GLFW_TRUE) + mouseDown = true; + else + mouseDown = false; } double time_diff(struct timeval x , struct timeval y) { - double x_ms , y_ms , diff; + double x_ms , y_ms , diff; - x_ms = (double)x.tv_sec*1000000 + (double)x.tv_usec; - y_ms = (double)y.tv_sec*1000000 + (double)y.tv_usec; + x_ms = (double)x.tv_sec*1000000 + (double)x.tv_usec; + y_ms = (double)y.tv_sec*1000000 + (double)y.tv_usec; - diff = (double)y_ms - (double)x_ms; + diff = (double)y_ms - (double)x_ms; - return diff; + return diff; } void randomize_color (VkvgContext ctx) { - vkvg_set_source_rgba(ctx, - (float)rand()/RAND_MAX, - (float)rand()/RAND_MAX, - (float)rand()/RAND_MAX, - (float)rand()/RAND_MAX - ); - //vkvg_set_source_color(ctx,(uint32_t) rand()); + vkvg_set_source_rgba(ctx, + (float)rand()/RAND_MAX, + (float)rand()/RAND_MAX, + (float)rand()/RAND_MAX, + (float)rand()/RAND_MAX + ); } /* from caskbench */ double get_tick (void) { - struct timeval now; - gettimeofday (&now, NULL); - return (double)now.tv_sec + (double)now.tv_usec / 1000000.0; + struct timeval now; + gettimeofday (&now, NULL); + return (double)now.tv_sec + (double)now.tv_usec / 1000000.0; } double median_run_time (double data[], int n) { - double temp; - int i, j; - for (i = 0; i < n; i++) - for (j = i+1; j < n; j++) - { - if (data[i] > data[j]) - { - temp = data[j]; - data[j] = data[i]; - data[i] = temp; - } - } - if (n % 2 == 0) - return (data[n/2] + data[n/2-1])/2; - else - return data[n/2]; + double temp; + int i, j; + for (i = 0; i < n; i++) + for (j = i+1; j < n; j++) + { + if (data[i] > data[j]) + { + temp = data[j]; + data[j] = data[i]; + data[i] = temp; + } + } + if (n % 2 == 0) + return (data[n/2] + data[n/2-1])/2; + else + return data[n/2]; } double standard_deviation (const double data[], int n, double mean) { - double sum_deviation = 0.0; - for (int i = 0; i < n; ++i) - sum_deviation += (data[i]-mean) * (data[i]-mean); - return sqrt (sum_deviation / n); + double sum_deviation = 0.0; + int i; + for (i = 0; i < n; ++i) + sum_deviation += (data[i]-mean) * (data[i]-mean); + return sqrt (sum_deviation / n); } /***************/ -void init_test (uint width, uint height){ - e = vkengine_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PRESENT_MODE_MAILBOX_KHR, width, height); - VkhPresenter r = e->renderer; - vkengine_set_key_callback (e, key_callback); - vkengine_set_mouse_but_callback(e, mouse_button_callback); - vkengine_set_cursor_pos_callback(e, mouse_move_callback); - vkengine_set_scroll_callback(e, scroll_callback); - - bool deferredResolve = false; - - device = vkvg_device_create_multisample(vkh_app_get_inst(e->app), r->dev->phy, r->dev->dev, r->qFam, 0, samples, deferredResolve); - - vkvg_device_set_dpy(device, 96, 96); - - surf = vkvg_surface_create(device, width, height); - - vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf), width, height); -} -void run_test_func (void(*testfunc)(void),uint width, uint height) { - bool deferredResolve = false; - VkhPresenter r = e->renderer; - - double start_time, stop_time, run_time, run_total, min_run_time = -1, max_run_time; - double run_time_values[iterations]; - - int i = 0; - - while (!vkengine_should_close (e) && i < iterations) { - glfwPollEvents(); +void init_test (uint32_t width, uint32_t height){ + if (test_vsync) + e = vkengine_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PRESENT_MODE_FIFO_KHR, width, height); + else + e = vkengine_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PRESENT_MODE_MAILBOX_KHR, width, height); - start_time = get_tick(); + VkhPresenter r = e->renderer; + vkengine_set_key_callback (e, key_callback); + vkengine_set_mouse_but_callback(e, mouse_button_callback); + vkengine_set_cursor_pos_callback(e, mouse_move_callback); + vkengine_set_scroll_callback(e, scroll_callback); - if (!paused) - testfunc(); + bool deferredResolve = false; - if (deferredResolve) - vkvg_multisample_surface_resolve(surf); - if (!vkh_presenter_draw (r)) - vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf), width, height); + device = vkvg_device_create_multisample(vkh_app_get_inst(e->app), r->dev->phy, r->dev->dev, r->qFam, 0, samples, deferredResolve); - vkDeviceWaitIdle(e->dev->dev); + vkvg_device_set_dpy(device, 96, 96); - stop_time = get_tick(); - run_time = stop_time - start_time; - run_time_values[i] = run_time; + surf = vkvg_surface_create(device, width, height); - if (min_run_time < 0) - min_run_time = run_time; - else - min_run_time = MIN(run_time, min_run_time); - max_run_time = MAX(run_time, max_run_time); - run_total += run_time; - i++; - } - - double avg_run_time = run_total / (double)i; - double med_run_time = median_run_time (run_time_values, i); - double standard_dev = standard_deviation (run_time_values, i, avg_run_time); - double avg_frames_per_second = (1.0 / avg_run_time); - avg_frames_per_second = (avg_frames_per_second<9999) ? avg_frames_per_second:9999; + vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf), width, height); +} - printf ("size:%d iter:%d avgFps: %f avg: %4.2f%% med: %4.2f%% sd: %4.2f%% \n", test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev); +// printf ("size:%d iter:%d avgFps: %f avg: %4.2f%% med: %4.2f%% sd: %4.2f%% \n", test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev); -} void clear_test () { - vkDeviceWaitIdle(e->dev->dev); + vkDeviceWaitIdle(e->dev->dev); - vkvg_surface_destroy (surf); - vkvg_device_destroy (device); + vkvg_surface_destroy (surf); + vkvg_device_destroy (device); - vkengine_destroy (e); + vkengine_destroy (e); } #ifdef VKVG_TEST_DIRECT_DRAW VkvgSurface* surfaces; #endif -void perform_test (void(*testfunc)(void),uint width, uint height) { - e = vkengine_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PRESENT_MODE_MAILBOX_KHR, width, height); - VkhPresenter r = e->renderer; - vkengine_set_key_callback (e, key_callback); - vkengine_set_mouse_but_callback(e, mouse_button_callback); - vkengine_set_cursor_pos_callback(e, mouse_move_callback); - vkengine_set_scroll_callback(e, scroll_callback); +void perform_test (void(*testfunc)(void), const char *testName, int argc, char* argv[]) { + //init random gen + struct timeval currentTime; + gettimeofday(¤tTime, NULL); + srand((unsigned) currentTime.tv_usec); + + //dumpLayerExts(); + if (argc > 1) + iterations = atoi (argv[1]); + if (argc > 2) + test_size = atoi (argv[2]); + if (iterations == 0 || test_size == 0) { + printf("usage: test [iterations] [size]\n"); + return; + } + + char* whoami; + (whoami = strrchr(argv[0], '/')) ? ++whoami : (whoami = argv[0]); + + if (test_vsync) + e = vkengine_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PRESENT_MODE_FIFO_KHR, test_width, test_height); + else + e = vkengine_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PRESENT_MODE_MAILBOX_KHR, test_width, test_height); + + VkhPresenter r = e->renderer; + vkengine_set_key_callback (e, key_callback); + vkengine_set_mouse_but_callback(e, mouse_button_callback); + vkengine_set_cursor_pos_callback(e, mouse_move_callback); + vkengine_set_scroll_callback(e, scroll_callback); - bool deferredResolve = false; + bool deferredResolve = false; - device = vkvg_device_create_multisample(vkh_app_get_inst(e->app), r->dev->phy, r->dev->dev, r->qFam, 0, samples, deferredResolve); + device = vkvg_device_create_multisample(vkh_app_get_inst(e->app), r->dev->phy, r->dev->dev, r->qFam, 0, samples, deferredResolve); - vkvg_device_set_dpy(device, 96, 96); + vkvg_device_set_dpy(device, 96, 96); #ifdef VKVG_TEST_DIRECT_DRAW - surfaces = (VkvgSurface*)malloc(r->imgCount * sizeof (VkvgSurface)); - for (uint i=0; i < r->imgCount;i++) - surfaces[i] = vkvg_surface_create_for_VkhImage (device, r->ScBuffers[i]); + surfaces = (VkvgSurface*)malloc(r->imgCount * sizeof (VkvgSurface)); + for (uint32_t i=0; i < r->imgCount;i++) + surfaces[i] = vkvg_surface_create_for_VkhImage (device, r->ScBuffers[i]); #else - surf = vkvg_surface_create(device, width, height); - vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf), width, height); + surf = vkvg_surface_create(device, test_width, test_height); + vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf), test_width, test_height); #endif - double start_time = 0, stop_time = 0, run_time = 0, run_total = 0, min_run_time = -1, max_run_time = 0; - double run_time_values[iterations]; + double start_time = 0.0, stop_time = 0.0, run_time = 0.0, run_total = 0.0, min_run_time = -1, max_run_time = 0.0; + double* run_time_values = (double*)malloc(iterations*sizeof(double)); - int i = 0; + uint32_t i = 0; - while (!vkengine_should_close (e) && i < iterations) { - glfwPollEvents(); + vkengine_set_title(e, testName); - start_time = get_tick(); + while (!vkengine_should_close (e) && i < iterations) { + glfwPollEvents(); + + start_time = get_tick(); #ifdef VKVG_TEST_DIRECT_DRAW - if (!vkh_presenter_acquireNextImage(r, NULL, NULL)) { - for (uint i=0; i < r->imgCount;i++) - vkvg_surface_destroy (surfaces[i]); + if (!vkh_presenter_acquireNextImage(r, NULL, NULL)) { + for (uint32_t i=0; i < r->imgCount;i++) + vkvg_surface_destroy (surfaces[i]); - vkh_presenter_create_swapchain (r); + vkh_presenter_create_swapchain (r); - for (uint i=0; i < r->imgCount;i++) - surfaces[i] = vkvg_surface_create_for_VkhImage (device, r->ScBuffers[i]); - }else{ - surf = surfaces[r->currentScBufferIndex]; + for (uint32_t i=0; i < r->imgCount;i++) + surfaces[i] = vkvg_surface_create_for_VkhImage (device, r->ScBuffers[i]); + }else{ + surf = surfaces[r->currentScBufferIndex]; - testfunc(); + testfunc(); - if (deferredResolve) - vkvg_multisample_surface_resolve(surf); + if (deferredResolve) + vkvg_multisample_surface_resolve(surf); - VkPresentInfoKHR present = { .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, - .swapchainCount = 1, - .pSwapchains = &r->swapChain, - .pImageIndices = &r->currentScBufferIndex }; + VkPresentInfoKHR present = { .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, + .swapchainCount = 1, + .pSwapchains = &r->swapChain, + .pImageIndices = &r->currentScBufferIndex }; - vkQueuePresentKHR(r->queue, &present); - } + vkQueuePresentKHR(r->queue, &present); + } #else - if (!paused) - testfunc(); - - if (deferredResolve) - vkvg_multisample_surface_resolve(surf); - if (!vkh_presenter_draw (r)) - vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf), width, height); + if (!paused) + testfunc(); + + if (deferredResolve) + vkvg_multisample_surface_resolve(surf); + if (!vkh_presenter_draw (r)){ + vkh_presenter_get_size (r, &test_width, &test_height); + vkvg_surface_destroy (surf); + surf = vkvg_surface_create(device, test_width, test_height); + vkh_presenter_build_blit_cmd (r, vkvg_surface_get_vk_image(surf), test_width, test_height); + vkDeviceWaitIdle(r->dev->dev); + continue; + } #endif - vkDeviceWaitIdle(e->dev->dev); + if (paused) + continue; + + stop_time = get_tick(); + run_time = stop_time - start_time; + run_time_values[i] = run_time; - if (paused) - continue; + if (min_run_time < 0) + min_run_time = run_time; + else + min_run_time = MIN(run_time, min_run_time); + max_run_time = MAX(run_time, max_run_time); + run_total += run_time; + i++; + } - stop_time = get_tick(); - run_time = stop_time - start_time; - run_time_values[i] = run_time; + double avg_run_time = run_total / (double)i; + double med_run_time = median_run_time (run_time_values, i); + double standard_dev = standard_deviation (run_time_values, i, avg_run_time); + double avg_frames_per_second = (1.0 / avg_run_time); + avg_frames_per_second = (avg_frames_per_second<9999) ? avg_frames_per_second:9999; - if (min_run_time < 0) - min_run_time = run_time; - else - min_run_time = MIN(run_time, min_run_time); - max_run_time = MAX(run_time, max_run_time); - run_total += run_time; - i++; - } + free (run_time_values); - double avg_run_time = run_total / (double)i; - double med_run_time = median_run_time (run_time_values, i); - double standard_dev = standard_deviation (run_time_values, i, avg_run_time); - double avg_frames_per_second = (1.0 / avg_run_time); - avg_frames_per_second = (avg_frames_per_second<9999) ? avg_frames_per_second:9999; - printf ("size:%d iter:%d avgFps: %f avg: %4.2f%% med: %4.2f%% sd: %4.2f%% \n", test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev); + //printf ("size:%d iter:%d avgFps: %f avg: %4.2f%% med: %4.2f%% sd: %4.2f%% \n", test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev); + printf ("| %-15s | %-25s | ",whoami + 5, testName); + printf ("%4d | %4d | %7.2f | %6.5f | %6.5f | %6.5f |\n", + test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev); - vkDeviceWaitIdle(e->dev->dev); + //printf ("%s size:%d iter:%d avgFps: %f avg: %4.2f%% med: %4.2f%% sd: %4.2f%% \n", whoami+5, test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev); + + vkDeviceWaitIdle(e->dev->dev); #ifdef VKVG_TEST_DIRECT_DRAW - for (uint i=0; iimgCount;i++) - vkvg_surface_destroy (surfaces[i]); + for (uint32_t i=0; iimgCount;i++) + vkvg_surface_destroy (surfaces[i]); - free (surfaces); + free (surfaces); #else - vkvg_surface_destroy (surf); + vkvg_surface_destroy (surf); #endif - vkvg_device_destroy (device); + vkvg_device_destroy (device); - vkengine_destroy (e); + vkengine_destroy (e); +} +const int star_points[11][2] = { + { 0, 85 }, + { 75, 75 }, + { 100, 10 }, + { 125, 75 }, + { 200, 85 }, + { 150, 125 }, + { 160, 190 }, + { 100, 150 }, + { 40, 190 }, + { 50, 125 }, + { 0, 85 } +}; + +void draw_random_shape (VkvgContext ctx, shape_t shape, float sizeFact) { + float w = (float)test_width; + float h = (float)test_height; + + float x, y, z, v, r; + + randomize_color (ctx); + + switch (shape) { + case SHAPE_LINE: + x = (float)rand()/RAND_MAX * w; + y = (float)rand()/RAND_MAX * h; + z = (float)rand()/RAND_MAX * w; + v = (float)rand()/RAND_MAX * h; + + vkvg_move_to(ctx, x, y); + vkvg_line_to(ctx, z, v); + vkvg_stroke(ctx); + break; + case SHAPE_RECTANGLE: + z = truncf((sizeFact*w*rand()/RAND_MAX)+1.f); + v = truncf((sizeFact*h*rand()/RAND_MAX)+1.f); + x = truncf((w-z)*rand()/RAND_MAX); + y = truncf((h-v)*rand()/RAND_MAX); + + vkvg_rectangle(ctx, x+1, y+1, z, v); + break; + case SHAPE_ROUNDED_RECTANGLE: + z = truncf((sizeFact*w*rand()/RAND_MAX)+1.f); + v = truncf((sizeFact*h*rand()/RAND_MAX)+1.f); + x = truncf((w-z)*rand()/RAND_MAX); + y = truncf((h-v)*rand()/RAND_MAX); + r = truncf((0.2f*z*rand()/RAND_MAX)+1.f); + + if ((r > v / 2) || (r > z / 2)) + r = MIN(v / 2, z / 2); + + vkvg_move_to(ctx, x, y + r); + vkvg_arc(ctx, x + r, y + r, r, (float)M_PI, (float)-M_PI_2); + vkvg_line_to(ctx, x + z - r, y); + vkvg_arc(ctx, x + z - r, y + r, r, (float)-M_PI_2, 0); + vkvg_line_to(ctx, x + z, y + v - r); + vkvg_arc(ctx, x + z - r, y + v - r, r, 0, (float)M_PI_2); + vkvg_line_to(ctx, x + r, y + v); + vkvg_arc(ctx, x + r, y + v - r, r, (float)M_PI_2, (float)M_PI); + vkvg_line_to(ctx, x, y + r); + vkvg_close_path(ctx); + break; + case SHAPE_CIRCLE: + /*x = truncf((float)w * rnd()/RAND_MAX); + y = truncf((float)h * rnd()/RAND_MAX); + v = truncf((float)w * rnd()/RAND_MAX * 0.2f);*/ + x = (float)rand()/RAND_MAX * w; + y = (float)rand()/RAND_MAX * h; + + r = truncf((sizeFact*MIN(w,h)*rand()/RAND_MAX)+1.f); + + /*float r = 0.5f*w*rand()/RAND_MAX; + float x = truncf(0.5f * w*rand()/RAND_MAX + r); + float y = truncf(0.5f * w*rand()/RAND_MAX + r);*/ + + vkvg_arc(ctx, x, y, r, 0, (float)M_PI * 2.0f); + break; + case SHAPE_TRIANGLE: + case SHAPE_STAR: + x = (float)rand()/RAND_MAX * w; + y = (float)rand()/RAND_MAX * h; + z = (float)rand()/RAND_MAX * sizeFact + 0.15f; //scale + + vkvg_move_to (ctx, x+star_points[0][0]*z, y+star_points[0][1]*z); + for (int s=1; s<11; s++) + vkvg_line_to (ctx, x+star_points[s][0]*z, y+star_points[s][1]*z); + vkvg_close_path (ctx); + break; + case SHAPE_RANDOM: + draw_random_shape(ctx, 1 + rand()%4, sizeFact); + break; + } } + +/*void draw_random_shape (VkvgContext ctx, shape_t shape) { + float w = (float)test_width; + float h = (float)test_height; + randomize_color(ctx); + float z = truncf((0.5f*w*rand()/RAND_MAX)+1.f); + float v = truncf((0.5f*w*rand()/RAND_MAX)+1.f); + float x = truncf((w-z)*rand()/RAND_MAX); + float y = truncf((h-v)*rand()/RAND_MAX); + vkvg_rectangle(ctx, x, y, z, v); +}*/ diff --git a/tests/common/test.h b/tests/common/test.h index f916c45..91b6393 100644 --- a/tests/common/test.h +++ b/tests/common/test.h @@ -1,7 +1,10 @@ #include "vkengine.h" -#include "stdio.h" -#include "stdlib.h" -#include "time.h" +#include +#include +#define _USE_MATH_DEFINES +#include +#include + #include "vkvg.h" #include "vkh_device.h" @@ -18,64 +21,59 @@ # define MAX(a,b) (((a) > (b)) ? (a) : (b)) #endif -#ifdef _WIN32 // MSC_VER - #define WIN32_LEAN_AND_MEAN - #define NOMINMAX - #include // Windows.h -> WinDef.h defines min() max() - - /* - typedef uint16_t WORD ; - typedef uint32_t DWORD; - - typedef struct _FILETIME { - DWORD dwLowDateTime; - DWORD dwHighDateTime; - } FILETIME; - - typedef struct _SYSTEMTIME { - WORD wYear; - WORD wMonth; - WORD wDayOfWeek; - WORD wDay; - WORD wHour; - WORD wMinute; - WORD wSecond; - WORD wMilliseconds; - } SYSTEMTIME, *PSYSTEMTIME; - */ - - // *sigh* Microsoft has this in winsock2.h because they are too lazy to put it in the standard location ... !?!? - typedef struct timeval { - long tv_sec; - long tv_usec; - } timeval; - - // *sigh* no gettimeofday on Win32/Win64 - int gettimeofday(struct timeval * tp, struct timezone * tzp) - { - // FILETIME Jan 1 1970 00:00:00 - // Note: some broken versions only have 8 trailing zero's, the correct epoch has 9 trailing zero's - static const uint64_t EPOCH = ((uint64_t) 116444736000000000ULL); - - SYSTEMTIME nSystemTime; - FILETIME nFileTime; - uint64_t nTime; - - GetSystemTime( &nSystemTime ); - SystemTimeToFileTime( &nSystemTime, &nFileTime ); - nTime = ((uint64_t)nFileTime.dwLowDateTime ) ; - nTime += ((uint64_t)nFileTime.dwHighDateTime) << 32; - - tp->tv_sec = (long) ((nTime - EPOCH) / 10000000L); - tp->tv_usec = (long) (nSystemTime.wMilliseconds * 1000); - return 0; - } +#define PERFORM_TEST(testName, argc, argv) perform_test(testName, #testName, argc, argv); +#if defined(_WIN32) || defined(_WIN64) + #define WIN32_LEAN_AND_MEAN + #define NOMINMAX + #include // Windows.h -> WinDef.h defines min() max() + + /* + typedef uint16_t WORD ; + typedef uint32_t DWORD; + + typedef struct _FILETIME { + DWORD dwLowDateTime; + DWORD dwHighDateTime; + } FILETIME; + + typedef struct _SYSTEMTIME { + WORD wYear; + WORD wMonth; + WORD wDayOfWeek; + WORD wDay; + WORD wHour; + WORD wMinute; + WORD wSecond; + WORD wMilliseconds; + } SYSTEMTIME, *PSYSTEMTIME; + */ + + // *sigh* Microsoft has this in winsock2.h because they are too lazy to put it in the standard location ... !?!? + typedef struct timeval { + long tv_sec; + long tv_usec; + } timeval; + + // *sigh* no gettimeofday on Win32/Win64 + int gettimeofday(struct timeval * tp, void * tzp); #else - #include -#endif // _WIN32 + #include +#endif -extern uint test_size; -extern int iterations; +typedef enum _shape_t { + SHAPE_LINE, + SHAPE_RECTANGLE, + SHAPE_ROUNDED_RECTANGLE, + SHAPE_CIRCLE, + SHAPE_TRIANGLE, + SHAPE_STAR, + SHAPE_RANDOM, +} shape_t; + +extern uint32_t test_size; +extern uint32_t iterations; +extern uint32_t test_width; +extern uint32_t test_height; extern float panX; extern float panY; @@ -88,10 +86,11 @@ extern VkvgDevice device; extern VkvgSurface surf; //run test in one step -void perform_test (void(*testfunc)(void),uint width, uint height); -void randomize_color (VkvgContext ctx); +void perform_test (void(*testfunc)(), const char* testName, int argc, char *argv[]); + +void randomize_color (VkvgContext ctx); +void draw_random_shape (VkvgContext ctx, shape_t shape, float sizeFact); //run test in 3 step: init, run, clear. -void init_test (uint width, uint height); -void run_test_func (void(*testfunc)(void),uint width, uint height); +void init_test (uint32_t width, uint32_t height); void clear_test (); diff --git a/tests/common/vkengine.c b/tests/common/vkengine.c index 6e8157e..9aac16b 100644 --- a/tests/common/vkengine.c +++ b/tests/common/vkengine.c @@ -29,261 +29,234 @@ #include "vkh_device.h" bool vkeCheckPhyPropBlitSource (VkEngine e) { - VkFormatProperties formatProps; - vkGetPhysicalDeviceFormatProperties(e->dev->phy, e->renderer->format, &formatProps); - + VkFormatProperties formatProps; + vkGetPhysicalDeviceFormatProperties(e->dev->phy, e->renderer->format, &formatProps); #ifdef VKVG_TILING_OPTIMAL - assert((formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT) && "Format cannot be used as transfer source"); + return formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT; #else - assert((formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT) && "Format cannot be used as transfer source"); + return formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT; #endif } VkSampleCountFlagBits getMaxUsableSampleCount(VkSampleCountFlags counts) { - if (counts & VK_SAMPLE_COUNT_64_BIT) { return VK_SAMPLE_COUNT_64_BIT; } - if (counts & VK_SAMPLE_COUNT_32_BIT) { return VK_SAMPLE_COUNT_32_BIT; } - if (counts & VK_SAMPLE_COUNT_16_BIT) { return VK_SAMPLE_COUNT_16_BIT; } - if (counts & VK_SAMPLE_COUNT_8_BIT) { return VK_SAMPLE_COUNT_8_BIT; } - if (counts & VK_SAMPLE_COUNT_4_BIT) { return VK_SAMPLE_COUNT_4_BIT; } - if (counts & VK_SAMPLE_COUNT_2_BIT) { return VK_SAMPLE_COUNT_2_BIT; } - return VK_SAMPLE_COUNT_1_BIT; + if (counts & VK_SAMPLE_COUNT_64_BIT) { return VK_SAMPLE_COUNT_64_BIT; } + if (counts & VK_SAMPLE_COUNT_32_BIT) { return VK_SAMPLE_COUNT_32_BIT; } + if (counts & VK_SAMPLE_COUNT_16_BIT) { return VK_SAMPLE_COUNT_16_BIT; } + if (counts & VK_SAMPLE_COUNT_8_BIT) { return VK_SAMPLE_COUNT_8_BIT; } + if (counts & VK_SAMPLE_COUNT_4_BIT) { return VK_SAMPLE_COUNT_4_BIT; } + if (counts & VK_SAMPLE_COUNT_2_BIT) { return VK_SAMPLE_COUNT_2_BIT; } + return VK_SAMPLE_COUNT_1_BIT; } void vkengine_dump_Infos (VkEngine e){ - printf("max samples = %d\n", getMaxUsableSampleCount(e->gpu_props.limits.framebufferColorSampleCounts)); - printf("max tex2d size = %d\n", e->gpu_props.limits.maxImageDimension2D); - printf("max tex array layers = %d\n", e->gpu_props.limits.maxImageArrayLayers); - printf("max mem alloc count = %d\n", e->gpu_props.limits.maxMemoryAllocationCount); - - for (uint32_t i = 0; i < e->memory_properties.memoryHeapCount; i++) { - printf("Mem Heap %d\n", i); - printf("\tflags= %d\n", e->memory_properties.memoryHeaps[i].flags); - printf("\tsize = %lu Mo\n", e->memory_properties.memoryHeaps[i].size/ (uint32_t)(1024*1024)); - } - for (uint32_t i = 0; i < e->memory_properties.memoryTypeCount; i++) { - printf("Mem type %d\n", i); - printf("\theap %d: ", e->memory_properties.memoryTypes[i].heapIndex); - if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) - printf("VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|"); - if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) - printf("VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|"); - if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) - printf("VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|"); - if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) - printf("VK_MEMORY_PROPERTY_HOST_CACHED_BIT|"); - if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) - printf("VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT|"); - printf("\n"); - } + printf("max samples = %d\n", getMaxUsableSampleCount(e->gpu_props.limits.framebufferColorSampleCounts)); + printf("max tex2d size = %d\n", e->gpu_props.limits.maxImageDimension2D); + printf("max tex array layers = %d\n", e->gpu_props.limits.maxImageArrayLayers); + printf("max mem alloc count = %d\n", e->gpu_props.limits.maxMemoryAllocationCount); + + for (uint32_t i = 0; i < e->memory_properties.memoryHeapCount; i++) { + printf("Mem Heap %d\n", i); + printf("\tflags= %d\n", e->memory_properties.memoryHeaps[i].flags); + printf("\tsize = %lu Mo\n", (unsigned long)e->memory_properties.memoryHeaps[i].size/ (uint32_t)(1024*1024)); + } + for (uint32_t i = 0; i < e->memory_properties.memoryTypeCount; i++) { + printf("Mem type %d\n", i); + printf("\theap %d: ", e->memory_properties.memoryTypes[i].heapIndex); + if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) + printf("VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|"); + if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) + printf("VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|"); + if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) + printf("VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|"); + if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) + printf("VK_MEMORY_PROPERTY_HOST_CACHED_BIT|"); + if (e->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) + printf("VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT|"); + printf("\n"); + } } void vkengine_dump_available_layers () { - uint32_t layerCount; - vkEnumerateInstanceLayerProperties(&layerCount, NULL); - - VkLayerProperties availableLayers [layerCount]; - vkEnumerateInstanceLayerProperties(&layerCount, availableLayers); - - printf("Available Layers:\n"); - printf("-----------------\n"); - for (uint i=0; iapp = vkh_app_create("vkvgTest", enabledLayersCount, enabledLayers, enabledExtsCount, enabledExts); + e->app = vkh_app_create("vkvgTest", enabledLayersCount, enabledLayers, enabledExtsCount, enabledExts); #ifdef DEBUG - vkh_app_enable_debug_messenger(e->app - , VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT - | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT - | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT - , VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT - | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT - //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT - //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT - , NULL); + vkh_app_enable_debug_messenger(e->app + , VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT + , VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT + //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT + //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT + , NULL); #endif - glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); - glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); - glfwWindowHint(GLFW_FLOATING, GLFW_FALSE); - glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); - - e->window = glfwCreateWindow ((int)width, (int)height, "Window Title", NULL, NULL); - - VkSurfaceKHR surf; - VkResult res = glfwCreateWindowSurface(e->app->inst, e->window, NULL, &surf); - - VkhPhyInfo* phys = vkh_app_get_phyinfos (e->app, &phyCount, surf); - - VkhPhyInfo pi = NULL; - for (int i=0; iproperties.deviceType == preferedGPU) - break; - } - - e->memory_properties = pi->memProps; - e->gpu_props = pi->properties; - - uint32_t qCount = 0; - VkDeviceQueueCreateInfo pQueueInfos[3]; - float queue_priorities[] = {0.0}; - - VkDeviceQueueCreateInfo qiG = { .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - .queueCount = 1, - .queueFamilyIndex = pi->gQueue, - .pQueuePriorities = queue_priorities }; - VkDeviceQueueCreateInfo qiC = { .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - .queueCount = 1, - .queueFamilyIndex = pi->cQueue, - .pQueuePriorities = queue_priorities }; - VkDeviceQueueCreateInfo qiT = { .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - .queueCount = 1, - .queueFamilyIndex = pi->tQueue, - .pQueuePriorities = queue_priorities }; - - if (pi->gQueue == pi->cQueue){ - if(pi->gQueue == pi->tQueue){ - qCount=1; - pQueueInfos[0] = qiG; - }else{ - qCount=2; - pQueueInfos[0] = qiG; - pQueueInfos[1] = qiT; - } - }else{ - if((pi->gQueue == pi->tQueue) || (pi->cQueue==pi->tQueue)){ - qCount=2; - pQueueInfos[0] = qiG; - pQueueInfos[1] = qiC; - }else{ - qCount=3; - pQueueInfos[0] = qiG; - pQueueInfos[1] = qiC; - pQueueInfos[2] = qiT; - } - } - - char const * dex [] = {"VK_KHR_swapchain", "VK_KHR_push_descriptor"}; - enabledExtsCount = 2; - - VkPhysicalDeviceFeatures enabledFeatures = { - .fillModeNonSolid = true, - //.sampleRateShading = true - }; - - VkDeviceCreateInfo device_info = { .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, - .queueCreateInfoCount = qCount, - .pQueueCreateInfos = (VkDeviceQueueCreateInfo*)&pQueueInfos, - .enabledExtensionCount = enabledExtsCount, - .ppEnabledExtensionNames = dex, - .pEnabledFeatures = &enabledFeatures - }; - - e->dev = vkh_device_create(e->app, pi, &device_info); - - e->renderer = vkh_presenter_create - (e->dev, (uint32_t) pi->pQueue, surf, width, height, VK_FORMAT_B8G8R8A8_UNORM, presentMode); - - vkh_app_free_phyinfos (phyCount, phys); - - vkeCheckPhyPropBlitSource (e); - - return e; + glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); + glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); + glfwWindowHint(GLFW_FLOATING, GLFW_FALSE); + glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); + + e->window = glfwCreateWindow ((int)width, (int)height, "Window Title", NULL, NULL); + + VkSurfaceKHR surf; + VK_CHECK_RESULT (glfwCreateWindowSurface(e->app->inst, e->window, NULL, &surf)) + + VkhPhyInfo* phys = vkh_app_get_phyinfos (e->app, &phyCount, surf); + + VkhPhyInfo pi = 0; + for (uint32_t i=0; iproperties.deviceType == preferedGPU) + break; + } + + e->memory_properties = pi->memProps; + e->gpu_props = pi->properties; + + uint32_t qCount = 0; + float qPriorities[] = {0.0}; + + VkDeviceQueueCreateInfo pQueueInfos[] = { {0},{0},{0} }; + if (vkh_phyinfo_create_presentable_queues (pi, 1, qPriorities, &pQueueInfos[qCount])) + qCount++; + /*if (vkh_phyinfo_create_compute_queues (pi, 1, qPriorities, &pQueueInfos[qCount])) + qCount++; + if (vkh_phyinfo_create_transfer_queues (pi, 1, qPriorities, &pQueueInfos[qCount])) + qCount++;*/ + + char const * dex [] = {"VK_KHR_swapchain", "VK_KHR_push_descriptor"}; + enabledExtsCount = 2; + + VkPhysicalDeviceFeatures enabledFeatures = { + .fillModeNonSolid = true, + //.sampleRateShading = true + }; + + VkDeviceCreateInfo device_info = { .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + .queueCreateInfoCount = qCount, + .pQueueCreateInfos = (VkDeviceQueueCreateInfo*)&pQueueInfos, + .enabledExtensionCount = enabledExtsCount, + .ppEnabledExtensionNames = dex, + .pEnabledFeatures = &enabledFeatures}; + + e->dev = vkh_device_create(e->app, pi, &device_info); + + e->renderer = vkh_presenter_create + (e->dev, (uint32_t) pi->pQueue, surf, width, height, VK_FORMAT_B8G8R8A8_UNORM, presentMode); + + vkh_app_free_phyinfos (phyCount, phys); + + vkeCheckPhyPropBlitSource (e); + + return e; } void vkengine_destroy (VkEngine e) { - vkDeviceWaitIdle(e->dev->dev); + vkDeviceWaitIdle(e->dev->dev); - VkSurfaceKHR surf = e->renderer->surface; + VkSurfaceKHR surf = e->renderer->surface; - vkh_presenter_destroy (e->renderer); - vkDestroySurfaceKHR (e->app->inst, surf, NULL); + vkh_presenter_destroy (e->renderer); + vkDestroySurfaceKHR (e->app->inst, surf, NULL); - vkh_device_destroy (e->dev); + vkh_device_destroy (e->dev); - glfwDestroyWindow (e->window); - glfwTerminate (); + glfwDestroyWindow (e->window); + glfwTerminate (); - vkh_app_destroy (e->app); + vkh_app_destroy (e->app); - free(e); + free(e); } void vkengine_close (VkEngine e) { - glfwSetWindowShouldClose(e->window, GLFW_TRUE); + glfwSetWindowShouldClose(e->window, GLFW_TRUE); } void vkengine_blitter_run (VkEngine e, VkImage img, uint32_t width, uint32_t height) { - VkhPresenter p = e->renderer; - vkh_presenter_build_blit_cmd (p, img, width, height); - - while (!vkengine_should_close (e)) { - glfwPollEvents(); - if (!vkh_presenter_draw (p)) - vkh_presenter_build_blit_cmd (p, img, width, height); - } + VkhPresenter p = e->renderer; + vkh_presenter_build_blit_cmd (p, img, width, height); + + while (!vkengine_should_close (e)) { + glfwPollEvents(); + if (!vkh_presenter_draw (p)) + vkh_presenter_build_blit_cmd (p, img, width, height); + } } -inline bool vkengine_should_close (VkEngine e) { - return glfwWindowShouldClose (e->window); +bool vkengine_should_close (VkEngine e) { + return glfwWindowShouldClose (e->window); +} +void vkengine_set_title (VkEngine e, const char* title) { + glfwSetWindowTitle(e->window, title); } - VkDevice vkengine_get_device (VkEngine e){ - return e->dev->dev; + return e->dev->dev; } VkPhysicalDevice vkengine_get_physical_device (VkEngine e){ - return e->dev->phy; + return e->dev->phy; } VkQueue vkengine_get_queue (VkEngine e){ - return e->renderer->queue; + return e->renderer->queue; } uint32_t vkengine_get_queue_fam_idx (VkEngine e){ - return e->renderer->qFam; + return e->renderer->qFam; } void vkengine_set_key_callback (VkEngine e, GLFWkeyfun key_callback){ - glfwSetKeyCallback (e->window, key_callback); + glfwSetKeyCallback (e->window, key_callback); } void vkengine_set_mouse_but_callback (VkEngine e, GLFWmousebuttonfun onMouseBut){ - glfwSetMouseButtonCallback(e->window, onMouseBut); + glfwSetMouseButtonCallback(e->window, onMouseBut); } void vkengine_set_cursor_pos_callback (VkEngine e, GLFWcursorposfun onMouseMove){ - glfwSetCursorPosCallback(e->window, onMouseMove); + glfwSetCursorPosCallback(e->window, onMouseMove); } void vkengine_set_scroll_callback (VkEngine e, GLFWscrollfun onScroll){ - glfwSetScrollCallback(e->window, onScroll); + glfwSetScrollCallback(e->window, onScroll); } void vkengine_set_char_callback (VkEngine e, GLFWcharfun onChar){ - glfwSetCharCallback(e->window, onChar); + glfwSetCharCallback(e->window, onChar); } diff --git a/tests/common/vkengine.h b/tests/common/vkengine.h index 056be08..7c4e229 100644 --- a/tests/common/vkengine.h +++ b/tests/common/vkengine.h @@ -28,10 +28,13 @@ #include #include +#undef APIENTRY + #include #include "vkh.h" + #define FENCE_TIMEOUT 100000000 typedef struct _vk_engine_t* VkEngine; @@ -51,6 +54,7 @@ void vkengine_destroy (VkEngine e); bool vkengine_should_close (VkEngine e); void vkengine_close (VkEngine e); void vkengine_dump_Infos (VkEngine e); +void vkengine_set_title (VkEngine e, const char* title); VkDevice vkengine_get_device (VkEngine e); VkPhysicalDevice vkengine_get_physical_device(VkEngine e); VkQueue vkengine_get_queue (VkEngine e); diff --git a/tests/compositing.c b/tests/compositing.c index 56e3d45..df193a7 100644 --- a/tests/compositing.c +++ b/tests/compositing.c @@ -1,24 +1,22 @@ #include "test.h" -void test(){ - vkvg_surface_clear(surf); +void compositing(){ + vkvg_surface_clear(surf); - VkvgContext ctx = vkvg_create(surf); + VkvgContext ctx = vkvg_create(surf); - vkvg_set_source_rgba(ctx, 1,0,0,0.5); - vkvg_rectangle(ctx,100,100,200,200); - vkvg_fill(ctx); + vkvg_set_source_rgba(ctx, 1,0,0,0.5f); + vkvg_rectangle(ctx,100,100,200,200); + vkvg_fill(ctx); - vkvg_set_source_rgba(ctx, 0,0,1,0.5); - vkvg_rectangle(ctx,200,200,200,200); - vkvg_fill(ctx); + vkvg_set_source_rgba(ctx, 0,0,1,0.5f); + vkvg_rectangle(ctx,200,200,200,200); + vkvg_fill(ctx); - vkvg_destroy(ctx); + vkvg_destroy(ctx); } int main(int argc, char *argv[]) { - - perform_test (test, 600, 800); - - return 0; + PERFORM_TEST (compositing, argc, argv); + return 0; } diff --git a/tests/curve.c b/tests/curve.c index dd3d4b5..8ff7cad 100644 --- a/tests/curve.c +++ b/tests/curve.c @@ -1,62 +1,114 @@ #include "test.h" void test(){ - VkvgContext ctx = vkvg_create(surf); + VkvgContext ctx = vkvg_create(surf); + + vkvg_set_fill_rule(ctx, VKVG_FILL_RULE_NON_ZERO); + vkvg_set_line_width(ctx, 20); + + //vkvg_scale(ctx,2,2); + vkvg_set_line_join(ctx, VKVG_LINE_JOIN_BEVEL); + + //vkvg_arc (ctx, 200, 500, 100, 0, M_PI); + + vkvg_set_source_rgb (ctx, 0.5f,0,0); + + + /*vkvg_move_to(ctx,100,100); + vkvg_line_to(ctx,300,100); + vkvg_line_to(ctx,500,300); + vkvg_line_to(ctx,300,500); + //vkvg_arc (ctx, 200, 500, 100, 0, M_PI); + vkvg_line_to(ctx,300,700); + vkvg_line_to(ctx,100,500);*/ + + /*vkvg_arc(ctx, 300, 300, 100, 0, M_PI); + vkvg_line_to(ctx,100,200); + vkvg_line_to(ctx,200,100); + vkvg_arc(ctx, 250, 100, 50, M_PI, M_PI * 1.5f); + vkvg_line_to(ctx,350,50); + vkvg_arc(ctx, 350, 100, 50, M_PI*1.5f, M_PI * 2.0f); + + vkvg_stroke(ctx); + vkvg_translate(ctx,400,30); + + */ + vkvg_translate(ctx,200,30); + vkvg_arc(ctx, 200, 200, 20, 0, M_PIF*2); + vkvg_stroke(ctx); + + vkvg_set_source_rgba (ctx, 0.5f,0.0f,1.0f,0.5f); + vkvg_move_to(ctx,100,100); + vkvg_line_to(ctx,200,100); + vkvg_curve_to(ctx,250,100,300,150,300,200); + vkvg_line_to(ctx,300,300); + vkvg_curve_to(ctx,300,350,250,400,200,400); + vkvg_line_to(ctx,100,400); + vkvg_curve_to(ctx,50,400,10,350,10,300); + vkvg_line_to(ctx,10,200); + vkvg_curve_to(ctx,10,150,50,100,100,100); + //vkvg_close_path(ctx); + vkvg_fill_preserve(ctx); + vkvg_set_source_rgba (ctx, 0.1f,0.3f,0.7f,0.5f); + vkvg_stroke(ctx); + + + vkvg_destroy(ctx); +} - vkvg_set_fill_rule(ctx, VKVG_FILL_RULE_NON_ZERO); - vkvg_set_line_width(ctx, 20); +void curved_rect() { + VkvgContext ctx = vkvg_create(surf); - vkvg_scale(ctx,2,2); - vkvg_set_line_join(ctx, VKVG_LINE_JOIN_BEVEL); + float x = 50, y = 50, width = 150, height = 140, radius = 30; - //vkvg_arc (ctx, 200, 500, 100, 0, M_PI); + vkvg_scale(ctx, 2, 2); + //vkvg_rotate(ctx,0.5f); - vkvg_set_source_rgb (ctx, 0.5,0,0); + vkvg_set_line_width(ctx, 15); + vkvg_set_source_rgba(ctx, 0, 0.5f, 0.4f, 1); - /*vkvg_move_to(ctx,100,100); - vkvg_line_to(ctx,300,100); - vkvg_line_to(ctx,500,300); - vkvg_line_to(ctx,300,500); - //vkvg_arc (ctx, 200, 500, 100, 0, M_PI); - vkvg_line_to(ctx,300,700); - vkvg_line_to(ctx,100,500);*/ + if ((radius > height / 2) || (radius > width / 2)) + radius = MIN(height / 2, width / 2); - /*vkvg_arc(ctx, 300, 300, 100, 0, M_PI); - vkvg_line_to(ctx,100,200); - vkvg_line_to(ctx,200,100); - vkvg_arc(ctx, 250, 100, 50, M_PI, M_PI * 1.5f); - vkvg_line_to(ctx,350,50); - vkvg_arc(ctx, 350, 100, 50, M_PI*1.5f, M_PI * 2.0f); + vkvg_move_to(ctx, x, y + radius); + vkvg_arc(ctx, x + radius, y + radius, radius, M_PIF, (float)-M_PI_2); + vkvg_line_to(ctx, x + width - radius, y); + vkvg_arc(ctx, x + width - radius, y + radius, radius, (float)-M_PI_2, 0); + vkvg_line_to(ctx, x + width, y + height - radius); + vkvg_arc(ctx, x + width - radius, y + height - radius, radius, 0, (float)M_PI_2); + vkvg_line_to(ctx, x + radius, y + height); + vkvg_arc(ctx, x + radius, y + height - radius, radius, (float)M_PI_2, M_PIF); + vkvg_line_to(ctx, x, y + radius); + vkvg_close_path(ctx); + vkvg_fill_preserve(ctx); + vkvg_set_source_rgba(ctx, 0.5f, 0, 0, 0.5f); + vkvg_stroke(ctx); - vkvg_stroke(ctx); - vkvg_translate(ctx,400,30); + vkvg_destroy(ctx); +} - */ - vkvg_translate(ctx,200,30); - vkvg_arc(ctx, 200, 200, 20, 0, M_PI*2); - //vkvg_stroke(ctx); +void test2() { + VkvgContext ctx = vkvg_create(surf); - vkvg_set_source_rgba (ctx, 0.5,0.0,1.0,0.5); - vkvg_move_to(ctx,200,100); - vkvg_curve_to(ctx,250,100,300,150,300,200); - vkvg_line_to(ctx,300,300); - vkvg_curve_to(ctx,300,350,250,400,200,400); - vkvg_line_to(ctx,100,400); - vkvg_curve_to(ctx,50,400,10,350,10,300); - vkvg_line_to(ctx,10,200); - vkvg_curve_to(ctx,10,150,50,100,100,100); - vkvg_fill_preserve(ctx); - vkvg_set_source_rgba (ctx, 0.1f,0.3,0.7,0.5); - vkvg_stroke(ctx); + vkvg_move_to(ctx, 100, 400); + vkvg_curve_to(ctx, 100, 100, 600, 700, 600, 400); + vkvg_curve_to(ctx, 1000, 100, 100, 800, 1000, 800); + vkvg_curve_to(ctx, 1000, 500, 700, 500, 700, 100); + vkvg_close_path(ctx); + //vkvg_set_source_rgba (ctx, 0.5,0.0,1.0,0.5); + //vkvg_fill_preserve(ctx); - vkvg_destroy(ctx); -} + vkvg_set_source_rgba(ctx, 1, 0, 0, 1); + vkvg_set_line_width(ctx, 40); + vkvg_stroke(ctx); + vkvg_destroy(ctx); +} int main(int argc, char *argv[]) { - - perform_test (test, 1024, 768); - - return 0; + PERFORM_TEST(test, argc, argv); + PERFORM_TEST(test2, argc, argv); + PERFORM_TEST(curved_rect, argc, argv); + return 0; } diff --git a/tests/curve2.c b/tests/curve2.c deleted file mode 100644 index 76a115d..0000000 --- a/tests/curve2.c +++ /dev/null @@ -1,29 +0,0 @@ -#include "test.h" - -void test(){ - VkvgContext ctx = vkvg_create(surf); - - vkvg_move_to (ctx, 100, 400); - vkvg_curve_to (ctx, 100, 100, 600,700,600,400); - vkvg_curve_to (ctx, 1000, 100, 100, 800, 1000, 800); - vkvg_curve_to (ctx, 1000, 500, 700, 500, 700, 100); - vkvg_close_path(ctx); - - //vkvg_set_source_rgba (ctx, 0.5,0.0,1.0,0.5); - //vkvg_fill_preserve(ctx); - - vkvg_set_source_rgba (ctx, 1,0,0,1); - vkvg_set_line_width(ctx, 40); - vkvg_stroke_preserve(ctx); - vkvg_set_source_rgba (ctx, 1,1,0,1); - vkvg_fill(ctx); - - vkvg_destroy(ctx); -} - -int main(int argc, char *argv[]) { - - perform_test (test, 1024, 768); - - return 0; -} diff --git a/tests/curved_rect.c b/tests/curved_rect.c deleted file mode 100644 index 34e739f..0000000 --- a/tests/curved_rect.c +++ /dev/null @@ -1,40 +0,0 @@ -#include "test.h" - -void test(){ - VkvgContext ctx = vkvg_create(surf); - - float x = 50, y = 50, width = 150, height = 140, radius = 30; - - vkvg_scale(ctx,2,2); - //vkvg_rotate(ctx,0.5f); - - vkvg_set_line_width(ctx,15); - vkvg_set_source_rgba(ctx, 0, 0.5f, 0.4f, 1); - - - if ((radius > height / 2) || (radius > width / 2)) - radius = MIN(height / 2, width / 2); - - vkvg_move_to(ctx, x, y + radius); - vkvg_arc(ctx, x + radius, y + radius, radius, M_PIF, (float)-M_PI_2); - vkvg_line_to(ctx, x + width - radius, y); - vkvg_arc(ctx, x + width - radius, y + radius, radius, (float)-M_PI_2, 0); - vkvg_line_to(ctx, x + width, y + height - radius); - vkvg_arc(ctx, x + width - radius, y + height - radius, radius, 0, (float)M_PI_2); - vkvg_line_to(ctx, x + radius, y + height); - vkvg_arc(ctx, x + radius, y + height - radius, radius, (float)M_PI_2, M_PIF); - vkvg_line_to(ctx, x, y + radius); - vkvg_close_path(ctx); - vkvg_fill_preserve(ctx); - vkvg_set_source_rgba(ctx,0.5,0,0,0.5); - vkvg_stroke(ctx); - - vkvg_destroy(ctx); -} - -int main(int argc, char *argv[]) { - - perform_test (test, 1024, 768); - - return 0; -} diff --git a/tests/fill.c b/tests/fill.c index 612afc5..5d49946 100644 --- a/tests/fill.c +++ b/tests/fill.c @@ -1,25 +1,26 @@ #include "test.h" void test(){ - VkvgContext ctx = vkvg_create(surf); + VkvgContext ctx = vkvg_create(surf); + vkvg_set_line_width(ctx,30); + vkvg_set_line_join(ctx,VKVG_LINE_JOIN_ROUND); - vkvg_set_source_rgba(ctx,0.1,0.9,0.1,1.0); - vkvg_move_to(ctx,100,100); - vkvg_rel_line_to(ctx,100,100); - vkvg_rel_line_to(ctx,100,-100); - vkvg_rel_line_to(ctx,100,200); - vkvg_rel_line_to(ctx,-100,100); - vkvg_rel_line_to(ctx,-100,-100); - vkvg_rel_line_to(ctx,-100,-50); - //vkvg_close_path(ctx); - vkvg_fill(ctx); + vkvg_set_source_rgba(ctx,0.1f,0.9f,0.1f,1.0f); + vkvg_move_to(ctx,100,100); + vkvg_rel_line_to(ctx,50,200); + vkvg_rel_line_to(ctx,150,-100); + vkvg_rel_line_to(ctx,100,200); + vkvg_rel_line_to(ctx,-100,100); + vkvg_rel_line_to(ctx,-10,-100); + vkvg_rel_line_to(ctx,-190,-50); + vkvg_close_path(ctx); - vkvg_destroy(ctx); + vkvg_stroke(ctx); + + vkvg_destroy(ctx); } int main(int argc, char *argv[]) { - - perform_test (test, 1024, 768); - - return 0; + PERFORM_TEST (test, argc, argv); + return 0; } diff --git a/tests/fill_and_stroke.c b/tests/fill_and_stroke.c index b431c8e..1e2931f 100644 --- a/tests/fill_and_stroke.c +++ b/tests/fill_and_stroke.c @@ -1,33 +1,29 @@ #include "test.h" void test(){ - VkvgContext ctx = vkvg_create(surf); - - vkvg_translate(ctx,250,150); - - vkvg_move_to (ctx, 100, 100); - vkvg_rel_line_to (ctx, 50, -80); - vkvg_rel_line_to (ctx, 50, 80); - //vkvg_close_path (ctx); - - vkvg_move_to (ctx, 300, 100); - vkvg_rel_line_to (ctx, 50, -80); - vkvg_rel_line_to (ctx, 50, 80); - vkvg_close_path (ctx); - - vkvg_set_line_width (ctx, 10.0); - vkvg_set_source_rgb (ctx, 0, 0, 1); - vkvg_fill_preserve (ctx); - //vkvg_fill(ctx); - vkvg_set_source_rgb (ctx, 1, 0, 0); - vkvg_stroke (ctx); - - vkvg_destroy(ctx); + VkvgContext ctx = vkvg_create(surf); + + vkvg_move_to (ctx, 100, 100); + vkvg_rel_line_to (ctx, 50, -80); + vkvg_rel_line_to (ctx, 50, 80); + //vkvg_close_path (ctx); + + vkvg_move_to (ctx, 300, 100); + vkvg_rel_line_to (ctx, 50, -80); + vkvg_rel_line_to (ctx, 50, 80); + vkvg_close_path (ctx); + + vkvg_set_line_width (ctx, 10.0); + vkvg_set_source_rgb (ctx, 0, 0, 1); + vkvg_fill_preserve (ctx); + //vkvg_fill(ctx); + vkvg_set_source_rgb (ctx, 1, 0, 0); + vkvg_stroke (ctx); + + vkvg_destroy(ctx); } int main(int argc, char *argv[]) { - - perform_test (test, 1024, 768); - - return 0; + PERFORM_TEST (test, argc, argv); + return 0; } diff --git a/tests/fillnstroke.c b/tests/fillnstroke.c deleted file mode 100644 index 7d35b29..0000000 --- a/tests/fillnstroke.c +++ /dev/null @@ -1,40 +0,0 @@ -#include "test.h" - -void test(){ - VkvgContext ctx = vkvg_create(surf); - - float x = 50, y = 150, dx = 150, dy = 140; - - vkvg_scale(ctx,2,2); - - vkvg_set_line_width(ctx,40); - vkvg_set_source_rgba(ctx,0,1,0,1); - - - vkvg_set_line_join(ctx,VKVG_LINE_JOIN_ROUND); - //vkvg_rectangle(ctx,x,y,dx,dy); - - - vkvg_move_to(ctx,x,y); - vkvg_rel_line_to(ctx,50,-30); - vkvg_rel_line_to(ctx,50,0); - vkvg_rel_line_to(ctx,50,30); - vkvg_rel_line_to(ctx,0,60); - vkvg_rel_line_to(ctx,-50,70); - vkvg_rel_line_to(ctx,-50,0); - vkvg_rel_line_to(ctx,-50,-70); - vkvg_line_to(ctx,x,y); - //vkvg_close_path(ctx); - vkvg_fill_preserve(ctx); - vkvg_set_source_rgba(ctx,0.5,0,0,0.5); - vkvg_stroke(ctx); - - vkvg_destroy(ctx); -} - -int main(int argc, char *argv[]) { - - perform_test (test, 1024, 768); - - return 0; -} diff --git a/tests/gradient.c b/tests/gradient.c index c11a6dc..151a9a4 100644 --- a/tests/gradient.c +++ b/tests/gradient.c @@ -1,43 +1,94 @@ #include "test.h" +VkvgPattern create_grad (VkvgContext ctx) { + VkvgPattern pat = vkvg_pattern_create_linear(0,0,300,0); + vkvg_pattern_add_color_stop(pat, 0, 1, 0, 0, 1); + vkvg_pattern_add_color_stop(pat, 0.5f, 0, 1, 0, 1); + vkvg_pattern_add_color_stop(pat, 1, 0, 0, 1, 1); + return pat; +} + +void paint(){ + VkvgContext ctx = vkvg_create(surf); + VkvgPattern pat = create_grad(ctx); + vkvg_pattern_set_extend(pat,VKVG_EXTEND_NONE); + vkvg_set_source (ctx, pat); + vkvg_paint(ctx); + + vkvg_pattern_destroy (pat); + vkvg_destroy(ctx); +} +void paint_repeat(){ + VkvgContext ctx = vkvg_create(surf); + VkvgPattern pat = create_grad(ctx); + vkvg_pattern_set_extend(pat,VKVG_EXTEND_REPEAT); + vkvg_set_source (ctx, pat); + vkvg_paint(ctx); + + vkvg_pattern_destroy (pat); + vkvg_destroy(ctx); +} + void test(){ - VkvgContext ctx = vkvg_create(surf); - - VkvgPattern pat = vkvg_pattern_create_linear(0,0,300,300); - vkvg_set_line_width(ctx, 20); - vkvg_pattern_add_color_stop(pat, 0, 1, 0, 0, 1); - vkvg_pattern_add_color_stop(pat, 0.5, 0, 1, 0, 1); - vkvg_pattern_add_color_stop(pat, 1, 0, 0, 1, 1); - vkvg_set_source (ctx, pat); - vkvg_rectangle(ctx,100,100,200,200); - //vkvg_fill (ctx); - //vkvg_paint(ctx); - vkvg_stroke (ctx); - vkvg_pattern_destroy (pat); - - vkvg_destroy(ctx); + VkvgContext ctx = vkvg_create(surf); + VkvgPattern pat = create_grad(ctx); + vkvg_set_source (ctx, pat); + vkvg_rectangle(ctx,100,100,200,200); + vkvg_set_line_width(ctx, 20); + //vkvg_fill (ctx); + //vkvg_paint(ctx); + vkvg_stroke (ctx); + vkvg_pattern_destroy (pat); + + vkvg_destroy(ctx); } void test2(){ - VkvgContext ctx = vkvg_create(surf); - - vkvg_set_source_rgb(ctx,1,0,0); - vkvg_paint(ctx); - - VkvgPattern pat = vkvg_pattern_create_linear(100,0,300,0); - vkvg_set_line_width(ctx, 20); - vkvg_pattern_add_color_stop(pat, 0, 1, 1, 1, 1); - vkvg_pattern_add_color_stop(pat, 1, 1, 1, 0, 0); - vkvg_set_source (ctx, pat); - vkvg_rectangle(ctx,100,100,200,200); - vkvg_fill (ctx); - //vkvg_stroke (ctx); - vkvg_pattern_destroy (pat); - - vkvg_destroy(ctx); + VkvgContext ctx = vkvg_create(surf); + + vkvg_set_source_rgb(ctx,1,0,0); + vkvg_paint(ctx); + + VkvgPattern pat = vkvg_pattern_create_linear(100,0,300,0); + vkvg_set_line_width(ctx, 20); + vkvg_pattern_add_color_stop(pat, 0, 1, 1, 1, 1); + vkvg_pattern_add_color_stop(pat, 1, 1, 1, 0, 0); + vkvg_set_source (ctx, pat); + vkvg_rectangle(ctx,100,100,200,200); + vkvg_fill (ctx); + //vkvg_stroke (ctx); + vkvg_pattern_destroy (pat); + + vkvg_destroy(ctx); } -int main(int argc, char *argv[]) { - perform_test (test, 1024, 768); +void gradient_transform() { + VkvgContext ctx = vkvg_create(surf); + + //vkvg_translate(ctx,-100,-100); + + vkvg_translate(ctx, 200, 100); + vkvg_rotate(ctx, 0.5f); - return 0; + //vkvg_scale(ctx,2,2); + VkvgPattern pat = vkvg_pattern_create_linear(0, 0, 400, 0); + vkvg_pattern_set_extend(pat, VKVG_EXTEND_NONE); + vkvg_set_line_width(ctx, 20); + vkvg_pattern_add_color_stop(pat, 0, 1, 0, 0, 1); + vkvg_pattern_add_color_stop(pat, 0.5f, 0, 1, 0, 1); + vkvg_pattern_add_color_stop(pat, 1, 0, 0, 1, 1); + vkvg_set_source(ctx, pat); + vkvg_rectangle(ctx, 0, 0, 400, 200); + //vkvg_fill (ctx); + vkvg_stroke(ctx); + //vkvg_paint(ctx); + vkvg_pattern_destroy(pat); + + vkvg_destroy(ctx); +} + +int main(int argc, char *argv[]) { + PERFORM_TEST(paint, argc, argv); + PERFORM_TEST(paint_repeat, argc, argv); + PERFORM_TEST(gradient_transform, argc, argv); + return 0; } diff --git a/tests/gradient_transform.c b/tests/gradient_transform.c deleted file mode 100644 index a9d51b8..0000000 --- a/tests/gradient_transform.c +++ /dev/null @@ -1,33 +0,0 @@ -#include "test.h" - -void test(){ - VkvgContext ctx = vkvg_create(surf); - - //vkvg_translate(ctx,-100,-100); - - vkvg_translate(ctx,100,100); - vkvg_rotate(ctx,0.5); - - //vkvg_scale(ctx,2,2); - VkvgPattern pat = vkvg_pattern_create_linear(0,0,200,0); - //vkvg_pattern_set_extend(pat, VKVG_EXTEND_REPEAT); - vkvg_set_line_width(ctx, 20); - vkvg_pattern_add_color_stop(pat, 0, 1, 0, 0, 1); - vkvg_pattern_add_color_stop(pat, 0.5, 0, 1, 0, 1); - vkvg_pattern_add_color_stop(pat, 1, 0, 0, 1, 1); - vkvg_set_source (ctx, pat); - vkvg_rectangle(ctx,0,0,200,200); - vkvg_fill (ctx); - //vkvg_stroke (ctx); - //vkvg_paint(ctx); - vkvg_pattern_destroy (pat); - - vkvg_destroy(ctx); -} - -int main(int argc, char *argv[]) { - - perform_test (test, 1024, 768); - - return 0; -} diff --git a/tests/hlines.c b/tests/hlines.c index 90d0451..25322f5 100644 --- a/tests/hlines.c +++ b/tests/hlines.c @@ -1,35 +1,35 @@ #include "test.h" void test(){ - vkvg_surface_clear(surf); - struct timeval currentTime; - gettimeofday(¤tTime, NULL); - - srand((unsigned) currentTime.tv_usec); - const float w = 1024.f; - const float h = 800.f; - - VkvgContext ctx = vkvg_create(surf); - //vkvg_set_fill_rule(ctx, VKVG_FILL_RULE_EVEN_ODD); - vkvg_set_line_width(ctx,1); - //vkvg_set_line_join(ctx,VKVG_LINE_JOIN_BEVEL); - - for (uint i=0; ishapes; shape != NULL; shape = shape->next) { - vkvg_new_path(ctx); + vkvg_destroy(ctx); - float o = shape->opacity; - - vkvg_set_line_width(ctx, shape->strokeWidth); - - for (path = shape->paths; path != NULL; path = path->next) { - float* p = path->pts; - vkvg_move_to(ctx, p[0],p[1]); - for (int i = 1; i < path->npts-2; i += 3) { - p = &path->pts[i*2]; - vkvg_curve_to(ctx, p[0],p[1], p[2],p[3], p[4],p[5]); - } - if (path->closed) - vkvg_close_path(ctx); - } - - if (shape->fill.type == NSVG_PAINT_COLOR) - _svg_set_color(ctx, shape->fill.color, o); - else if (shape->fill.type == NSVG_PAINT_LINEAR_GRADIENT){ - NSVGgradient* g = shape->fill.gradient; - _svg_set_color(ctx, g->stops[0].color, o); - } - - if (shape->fill.type != NSVG_PAINT_NONE){ - if (shape->stroke.type == NSVG_PAINT_NONE){ - vkvg_fill(ctx); - continue; - } - vkvg_fill_preserve (ctx); - } - - if (shape->stroke.type == NSVG_PAINT_COLOR) - _svg_set_color(ctx, shape->stroke.color, o); - else if (shape->stroke.type == NSVG_PAINT_LINEAR_GRADIENT){ - NSVGgradient* g = shape->stroke.gradient; - _svg_set_color(ctx, g->stops[0].color, o); - } - - vkvg_stroke(ctx); - } - - nsvgDelete(svg); - vkvg_destroy(ctx); + nsvg_destroy(svg); } int main(int argc, char *argv[]) { - - perform_test (test_nsvg, 1024, 800); - return 0; + PERFORM_TEST (test_nsvg, argc, argv); + return 0; } diff --git a/tests/test1.c b/tests/test1.c index baa1f9b..5fb17bf 100644 --- a/tests/test1.c +++ b/tests/test1.c @@ -23,331 +23,355 @@ #include "test.h" void cairo_test_fill_rule (VkvgContext cr){ - vkvg_set_line_width (cr, 6); + vkvg_set_line_width (cr, 6); - //vkvg_scale(cr,3,3); - vkvg_set_source_rgba(cr,1,0,0,1); - vkvg_move_to(cr,50,150); - vkvg_rel_line_to(cr,50,70); - vkvg_rel_line_to(cr,50,0); - vkvg_rel_line_to(cr,50,-70); - vkvg_rel_line_to(cr,0,-60); - vkvg_rel_line_to(cr,-50,-30); - vkvg_rel_line_to(cr,-50,0); - vkvg_rel_line_to(cr,-50,30); - vkvg_close_path(cr); + //vkvg_scale(cr,3,3); + vkvg_set_source_rgba(cr,1,0,0,1); + vkvg_move_to(cr,50,150); + vkvg_rel_line_to(cr,50,70); + vkvg_rel_line_to(cr,50,0); + vkvg_rel_line_to(cr,50,-70); + vkvg_rel_line_to(cr,0,-60); + vkvg_rel_line_to(cr,-50,-30); + vkvg_rel_line_to(cr,-50,0); + vkvg_rel_line_to(cr,-50,30); + vkvg_close_path(cr); // vkvg_set_line_join(cr,VKVG_LINE_JOIN_ROUND); - vkvg_set_source_rgb (cr, 0, 0.7, 0); - vkvg_rectangle (cr, 12, 12, 232, 70); - //vkvg_stroke (cr); + vkvg_set_source_rgb (cr, 0, 0.7f, 0); + vkvg_rectangle (cr, 12, 12, 232, 70); + //vkvg_stroke (cr); // vkvg_new_sub_path (cr); - vkvg_arc (cr, 64, 64, 40, 0, (float)M_PI*2.f); - //vkvg_close_path(cr); + vkvg_arc (cr, 64, 64, 40, 0, M_PIF*2.f); + //vkvg_close_path(cr); - vkvg_new_sub_path (cr); - vkvg_arc_negative (cr, 192, 64, 40, (float)M_PI*2.f, 0); - //vkvg_close_path(cr); + vkvg_new_sub_path (cr); + vkvg_arc_negative (cr, 192, 64, 40, M_PIF*2.f, 0); + //vkvg_close_path(cr); - //vkvg_rectangle (cr, 30, 30, 20, 200); - //vkvg_rectangle (cr, 130, 30, 20, 200); - //vkvg_set_fill_rule (cr, vkvg_FILL_RULE_EVEN_ODD); + //vkvg_rectangle (cr, 30, 30, 20, 200); + //vkvg_rectangle (cr, 130, 30, 20, 200); + //vkvg_set_fill_rule (cr, vkvg_FILL_RULE_EVEN_ODD); - vkvg_fill_preserve(cr); + vkvg_fill_preserve(cr); - vkvg_set_source_rgb (cr, 0, 0, 0); - vkvg_stroke (cr); + vkvg_set_source_rgb (cr, 0, 0, 0); + vkvg_stroke (cr); } void cairo_test_text (VkvgContext cr) { - vkvg_text_extents_t extents; - - const char *utf8 = "vkvg"; - float x,y; - - vkvg_select_font_face (cr, "times"); - vkvg_set_font_size (cr, 100.0); - vkvg_text_extents (cr, utf8, &extents); - vkvg_set_source_rgb(cr,0,0,0); - - x=25.0; - y=150.0; - - vkvg_move_to (cr, x,y); - vkvg_show_text (cr, utf8); - - /* draw helping lines */ - vkvg_set_source_rgba (cr, 1, 0.2, 0.2, 0.6); - vkvg_set_line_width (cr, 6.0); - vkvg_new_path(cr); - vkvg_arc (cr, x, y, 10.0, 0, 2*M_PI); - vkvg_fill (cr); - vkvg_move_to (cr, x,y); - vkvg_rel_line_to (cr, 0, -extents.height); - vkvg_rel_line_to (cr, extents.width, 0); - vkvg_rel_line_to (cr, extents.x_bearing, -extents.y_bearing); - vkvg_stroke (cr); + vkvg_text_extents_t extents; + vkvg_font_extents_t ft; + + //vkvg_set_fill_rule(cr, VKVG_FILL_RULE_NON_ZERO); + const char *utf8 = "vkvg|Ãp"; + float x,y; + + //vkvg_select_font_face (cr, "times"); + vkvg_select_font_face (cr, "linux biolinum keyboard"); + vkvg_set_font_size (cr, 50); + vkvg_font_extents(cr, &ft); + vkvg_text_extents (cr, utf8, &extents); + vkvg_set_source_rgb(cr,0,0,0); + + x=25.0f; + y=150.0f; + + vkvg_move_to (cr, x,y); + vkvg_show_text (cr, utf8); + + /* draw helping lines */ + vkvg_set_source_rgba (cr, 0, 0.2f, 0.2f, 0.6f); + vkvg_set_line_width (cr, 1.0f); + vkvg_new_path(cr); + vkvg_arc (cr, x, y, 10.0f, 0, 2.f*M_PIF); + vkvg_fill (cr); + vkvg_move_to (cr, x,y); + //vkvg_rel_line_to (cr, 0, -30); + vkvg_rel_line_to (cr, 0, -ft.ascent); + vkvg_rel_line_to (cr, extents.width, 0); + vkvg_rel_line_to (cr, extents.x_bearing, -extents.y_bearing); + + vkvg_stroke (cr); + + vkvg_move_to (cr, x,y); + vkvg_rel_line_to (cr, extents.width, 0); + vkvg_set_source_rgba (cr, 0.0, 0.0, 0.9f, 0.6f); + + vkvg_stroke (cr); + + vkvg_move_to (cr, x,y); + vkvg_rel_line_to (cr, 0, -ft.descent); + vkvg_rel_line_to (cr, extents.width, 0); + vkvg_set_source_rgba (cr, 0.9f, 0.0, 0.0, 0.6f); + + vkvg_stroke (cr); + + vkvg_move_to (cr, x-10,y-ft.ascent); + vkvg_rel_line_to (cr, 0, ft.height); + vkvg_set_source_rgba (cr, 0.0, 0.1f, 0.0, 0.6f); + + vkvg_stroke (cr); } void cairo_test_clip (VkvgContext cr){ - vkvg_arc (cr, 128.0, 128.0, 76.8, 0, 2 * M_PI); - vkvg_clip (cr); - //vkvg_new_path (cr); /* current path is not - // consumed by vkvg_clip() */ - vkvg_set_source_rgba(cr, 0, 0, 0, 1); - vkvg_rectangle (cr, 0, 0, 256, 256); - vkvg_fill (cr); - vkvg_set_source_rgba (cr, 0, 1, 0, 1); - vkvg_move_to (cr, -100, -100); - vkvg_line_to (cr, 256, 256); - vkvg_move_to (cr, 356, -100); - vkvg_line_to (cr, 0, 256); - vkvg_set_line_width (cr, 10.0); - vkvg_stroke (cr); + vkvg_arc (cr, 128.0f, 128.0f, 76.8f, 0, 2.f * M_PIF); + vkvg_clip (cr); + //vkvg_new_path (cr); /* current path is not + // consumed by vkvg_clip() */ + vkvg_set_source_rgba(cr, 0, 0, 0, 1); + vkvg_rectangle (cr, 0, 0, 256, 256); + vkvg_fill (cr); + vkvg_set_source_rgba (cr, 0, 1, 0, 1); + vkvg_move_to (cr, -100, -100); + vkvg_line_to (cr, 256, 256); + vkvg_move_to (cr, 356, -100); + vkvg_line_to (cr, 0, 256); + vkvg_set_line_width (cr, 10.0f); + vkvg_stroke (cr); } void cairo_test_curves (VkvgContext cr){ - float x=25.6, y=128.0; - float x1=102.4, y1=230.4, - x2=153.6, y2=25.6, - x3=230.4, y3=128.0; - - vkvg_set_source_rgb (cr, 0, 0, 0); - vkvg_move_to (cr, x, y); - vkvg_curve_to (cr, x1, y1, x2, y2, x3, y3); - - vkvg_set_line_width (cr, 10.0); - vkvg_stroke (cr); - - vkvg_set_source_rgba (cr, 1, 0.2, 0.2, 0.6); - vkvg_set_line_width (cr, 6.0); - vkvg_move_to (cr,x,y); vkvg_line_to (cr,x1,y1); - vkvg_move_to (cr,x2,y2); vkvg_line_to (cr,x3,y3); - vkvg_stroke (cr); + float x=25.6f, y=128.0f; + float x1=102.4f, y1=230.4f, + x2=153.6f, y2=25.6f, + x3=230.4f, y3=128.0f; + + vkvg_set_source_rgb (cr, 0, 0, 0); + vkvg_move_to (cr, x, y); + vkvg_curve_to (cr, x1, y1, x2, y2, x3, y3); + + vkvg_set_line_width (cr, 10.0f); + vkvg_stroke (cr); + + vkvg_set_source_rgba (cr, 1, 0.2f, 0.2f, 0.6f); + vkvg_set_line_width (cr, 6.0f); + vkvg_move_to (cr,x,y); vkvg_line_to (cr,x1,y1); + vkvg_move_to (cr,x2,y2); vkvg_line_to (cr,x3,y3); + vkvg_stroke (cr); } void cairo_test_rounded_rect (VkvgContext cr) { - /* a custom shape that could be wrapped in a function */ - float x0 = 25.6, /* parameters like vkvg_rectangle */ - y0 = 25.6, - rect_width = 204.8, - rect_height = 204.8, - radius = 102.4; /* and an approximate curvature radius */ - - float x1,y1; - - x1=x0+rect_width; - y1=y0+rect_height; - if (!rect_width || !rect_height) - return; - if (rect_width/2