PROJECT(vkvg VERSION 0.1.0 DESCRIPTION "Vulkan Vector Graphic")
SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-SET(CMAKE_CXX_FLAGS "-W -Wall")
+SET(CMAKE_CXX_FLAGS "-W -Wall -Wno-extra")
SET(CMAKE_EXE_LINKER_FLAGS "-lm")
IF(NOT CMAKE_BUILD_TYPE)
VkvgContext vkvg_create(VkvgSurface surf)
{
- LOG(LOG_INFO, "CREATE Context: surf = %lu\n", surf);
+ LOG(LOG_INFO, "CREATE Context: surf = %lu\n", (ulong)surf);
VkvgDevice dev = surf->dev;
VkvgContext ctx = (vkvg_context*)calloc(1, sizeof(vkvg_context));
ctx->curOperator = VKVG_OPERATOR_OVER;
push_constants pc = {
- {0,0,0,1},
+ {.height=1},
{(float)ctx->pSurf->width,(float)ctx->pSurf->height},
VKVG_PATTERN_TYPE_SOLID,
0,
ctx->selectedFont.fontFile = (char*)calloc(FONT_FILE_NAME_MAX_SIZE,sizeof(char));
- ctx->flushFence = vkh_fence_create(dev);
+ ctx->flushFence = vkh_fence_create((VkhDevice)dev);
ctx->points = (vec2*) malloc (VKVG_VBO_SIZE*sizeof(vec2));
ctx->pathes = (uint32_t*) malloc (VKVG_PATHES_SIZE*sizeof(uint32_t));
- ctx->cmdPool = vkh_cmd_pool_create (dev, dev->gQueue->familyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
+ ctx->cmdPool = vkh_cmd_pool_create ((VkhDevice)dev, dev->gQueue->familyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
_create_vertices_buff (ctx);
_create_gradient_buff (ctx);
void vkvg_save (VkvgContext ctx){
ctx->status = VKVG_STATUS_SUCCESS;
- LOG(LOG_INFO, "SAVE CONTEXT: ctx = %lu\n", ctx);
+ LOG(LOG_INFO, "SAVE CONTEXT: ctx = %lu\n", (ulong)ctx);
_flush_cmd_buff(ctx);
VkvgDevice dev = ctx->pSurf->dev;
vkvg_context_save_t* sav = (vkvg_context_save_t*)calloc(1,sizeof(vkvg_context_save_t));
- sav->stencilMS = vkh_image_ms_create (dev,VK_FORMAT_S8_UINT, dev->samples, ctx->pSurf->width, ctx->pSurf->height,
+ sav->stencilMS = vkh_image_ms_create ((VkhDevice)dev,VK_FORMAT_S8_UINT, dev->samples, ctx->pSurf->width, ctx->pSurf->height,
VMA_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
void _create_cmd_buff (VkvgContext ctx){
- ctx->cmd = vkh_cmd_buff_create(ctx->pSurf->dev, ctx->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+ ctx->cmd = vkh_cmd_buff_create((VkhDevice)ctx->pSurf->dev, ctx->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
}
void _record_draw_cmd (VkvgContext ctx){
- LOG(LOG_INFO, "RECORD DRAW CMD: ctx = %lu; vert cpt = %d; ind cpt = %d; ind drawn = %d\n", ctx, ctx->vertCount - 4, ctx->indCount - 6, ctx->indCount - ctx->curIndStart);
+ LOG(LOG_INFO, "RECORD DRAW CMD: ctx = %lu; vert cpt = %d; ind cpt = %d; ind drawn = %d\n", (ulong)ctx, ctx->vertCount - 4, ctx->indCount - 6, ctx->indCount - ctx->curIndStart);
if (ctx->indCount == ctx->curIndStart)
return;
_check_cmd_buff_state(ctx);
void _add_point (VkvgContext ctx, float x, float y);
void _add_point_vec2 (VkvgContext ctx, vec2 v);
+void _create_gradient_buff (VkvgContext ctx);
void _create_vertices_buff (VkvgContext ctx);
void _add_vertex (VkvgContext ctx, Vertex v);
void _add_vertexf (VkvgContext ctx, float x, float y);
void _update_push_constants (VkvgContext ctx);
void _update_cur_pattern (VkvgContext ctx, VkvgPattern pat);
void _set_mat_inv_and_vkCmdPush (VkvgContext ctx);
+void _start_cmd_for_render_pass (VkvgContext ctx);
void _createDescriptorPool (VkvgContext ctx);
void _init_descriptor_sets (VkvgContext ctx);
dev->vkDev = vkdev;
dev->phy = phy;
- CmdBindPipeline = vkGetInstanceProcAddr(inst, "vkCmdBindPipeline");
- CmdBindDescriptorSets = vkGetInstanceProcAddr(inst, "vkCmdBindDescriptorSets");
- CmdBindIndexBuffer = vkGetInstanceProcAddr(inst, "vkCmdBindIndexBuffer");
- CmdBindVertexBuffers = vkGetInstanceProcAddr(inst, "vkCmdBindVertexBuffers");
- CmdDrawIndexed = vkGetInstanceProcAddr(inst, "vkCmdDrawIndexed");
- CmdDraw = vkGetInstanceProcAddr(inst, "vkCmdDraw");
- CmdSetStencilCompareMask= vkGetInstanceProcAddr(inst, "vkCmdSetStencilCompareMask");
- CmdBeginRenderPass = vkGetInstanceProcAddr(inst, "vkCmdBeginRenderPass");
- CmdEndRenderPass = vkGetInstanceProcAddr(inst, "vkCmdEndRenderPass");
- CmdSetViewport = vkGetInstanceProcAddr(inst, "vkCmdSetViewport");
- CmdSetScissor = vkGetInstanceProcAddr(inst, "vkCmdSetScissor");
- CmdPushConstants = vkGetInstanceProcAddr(inst, "vkCmdPushConstants");
- CmdPushDescriptorSet = vkGetInstanceProcAddr(inst, "vkCmdDescriptorSet");
+ _init_function_pointers (dev);
VkhPhyInfo phyInfos = vkh_phyinfo_create (dev->phy, NULL);
dev->phyMemProps = phyInfos->memProps;
- dev->gQueue = vkh_queue_create (dev, qFamIdx, qIndex, phyInfos->queues[qFamIdx].queueFlags);
+ dev->gQueue = vkh_queue_create ((VkhDevice)dev, qFamIdx, qIndex, phyInfos->queues[qFamIdx].queueFlags);
MUTEX_INIT (&dev->gQMutex);
vkh_phyinfo_destroy (phyInfos);
dev->lastCtx= NULL;
- dev->cmdPool= vkh_cmd_pool_create (dev, dev->gQueue->familyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
- dev->cmd = vkh_cmd_buff_create (dev, dev->cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- dev->fence = vkh_fence_create_signaled (dev);
+ dev->cmdPool= vkh_cmd_pool_create ((VkhDevice)dev, dev->gQueue->familyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
+ dev->cmd = vkh_cmd_buff_create ((VkhDevice)dev, dev->cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+ dev->fence = vkh_fence_create_signaled ((VkhDevice)dev);
_create_pipeline_cache (dev);
_init_fonts_cache (dev);
_createDescriptorSetLayout (dev);
_setupPipelines (dev);
- //create empty image to bind to source descriptor when not in use
- dev->emptyImg = vkh_image_create(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);
- vkh_image_set_layout (dev->cmd, dev->emptyImg, VK_IMAGE_ASPECT_COLOR_BIT,
- VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
- VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
- vkh_cmd_end (dev->cmd);
- _submit_cmd (dev, &dev->cmd, dev->fence);
+ _create_empty_texture (dev);
dev->references = 1;
* THE SOFTWARE.
*/
+#define GetInstProcAddress(inst, func)(PFN_##func)vkGetInstanceProcAddr(inst, #func);
+
#include "vkvg_device_internal.h"
#include "vkvg_context_internal.h"
#include "shaders.h"
VkShaderModule modVert, modFrag, modFragWired;
VkShaderModuleCreateInfo createInfo = { .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
- .pCode = vkvg_main_vert_spv,
+ .pCode = (uint32_t*)vkvg_main_vert_spv,
.codeSize = vkvg_main_vert_spv_len };
VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modVert));
- createInfo.pCode = vkvg_main_frag_spv;
+ createInfo.pCode = (uint32_t*)vkvg_main_frag_spv;
createInfo.codeSize = vkvg_main_frag_spv_len;
VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modFrag));
- createInfo.pCode = wired_frag_spv;
+ createInfo.pCode = (uint32_t*)wired_frag_spv;
createInfo.codeSize = wired_frag_spv_len;
VK_CHECK_RESULT(vkCreateShaderModule(dev->vkDev, &createInfo, NULL, &modFragWired));
void _createDescriptorSetLayout (VkvgDevice dev) {
VkDescriptorSetLayoutBinding dsLayoutBinding =
- {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,VK_SHADER_STAGE_FRAGMENT_BIT};
+ {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,VK_SHADER_STAGE_FRAGMENT_BIT, NULL};
VkDescriptorSetLayoutCreateInfo dsLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.bindingCount = 1,
.pBindings = &dsLayoutBinding };
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.pushConstantRangeCount = 1,
- .pPushConstantRanges = &pushConstantRange,
+ .pPushConstantRanges = (VkPushConstantRange*)&pushConstantRange,
.setLayoutCount = 3,
.pSetLayouts = dsls };
VK_CHECK_RESULT(vkCreatePipelineLayout(dev->vkDev, &pipelineLayoutCreateInfo, NULL, &dev->pipelineLayout));
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);
+ 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, "vkCmdDescriptorSet");
+}
+
+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);
+
+ _wait_and_reset_device_fence (dev);
+
+ vkh_cmd_begin (dev->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
+ vkh_image_set_layout (dev->cmd, dev->emptyImg, VK_IMAGE_ASPECT_COLOR_BIT,
+ VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+ vkh_cmd_end (dev->cmd);
+ _submit_cmd (dev, &dev->cmd, dev->fence);
+}
VkvgContext lastCtx; //double linked list last elmt
}vkvg_device;
+void _init_function_pointers (VkvgDevice dev);
+void _create_empty_texture (VkvgDevice dev);
void _create_pipeline_cache (VkvgDevice dev);
void _setupRenderPass (VkvgDevice dev);
void _setupPipelines (VkvgDevice dev);
assert(!FT_Init_FreeType(&cache->library));
cache->cacheTexLength = FONT_CACHE_INIT_LAYERS;
- cache->cacheTex = vkh_tex2d_array_create (dev, VK_FORMAT_R8_UNORM, FONT_PAGE_SIZE, FONT_PAGE_SIZE,
- cache->cacheTexLength ,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+ cache->cacheTex = vkh_tex2d_array_create ((VkhDevice)dev, VK_FORMAT_R8_UNORM, FONT_PAGE_SIZE, FONT_PAGE_SIZE,
+ cache->cacheTexLength ,VMA_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
vkh_image_create_descriptor (cache->cacheTex, VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_IMAGE_ASPECT_COLOR_BIT,
VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER);
- cache->uploadFence = vkh_fence_create_signaled(dev);
+ cache->uploadFence = vkh_fence_create_signaled((VkhDevice)dev);
uint32_t buffLength = FONT_PAGE_SIZE*FONT_PAGE_SIZE*sizeof(uint8_t);
VMA_MEMORY_USAGE_CPU_TO_GPU,
buffLength, &cache->buff);
- cache->cmd = vkh_cmd_buff_create(dev,dev->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+ cache->cmd = vkh_cmd_buff_create((VkhDevice)dev,dev->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
cache->hostBuff = (uint8_t*)malloc(FONT_PAGE_SIZE*FONT_PAGE_SIZE*sizeof(uint8_t));
cache->pensY = (int*)calloc(cache->cacheTexLength, sizeof(int));
_font_cache_t* cache = dev->fontCache;
vkWaitForFences (dev->vkDev, 1, &cache->uploadFence, VK_TRUE, UINT64_MAX);
- vkResetCommandBuffer(cache->cmd, NULL);
+ vkResetCommandBuffer(cache->cmd, 0);
vkResetFences (dev->vkDev, 1, &cache->uploadFence);
uint8_t newSize = cache->cacheTexLength + FONT_CACHE_INIT_LAYERS;
- VkhImage newImg = vkh_tex2d_array_create (dev, VK_FORMAT_R8_UNORM, FONT_PAGE_SIZE, FONT_PAGE_SIZE,
- newSize ,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+ VkhImage newImg = vkh_tex2d_array_create ((VkhDevice)dev, VK_FORMAT_R8_UNORM, FONT_PAGE_SIZE, FONT_PAGE_SIZE,
+ newSize ,VMA_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
vkh_image_create_descriptor (newImg, VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_IMAGE_ASPECT_COLOR_BIT,
VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST,VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER);
for (i = 0; i < cache->cacheTexLength; ++i) {
if (cache->pensY[i] + f->curLine.height >= FONT_PAGE_SIZE)
continue;
- f->curLine.pageIdx = i;
+ f->curLine.pageIdx = (unsigned char)i;
f->curLine.penX = 0;
f->curLine.penY = cache->pensY[i];
cache->pensY[i] += f->curLine.height;
return;
vkWaitForFences (dev->vkDev,1,&cache->uploadFence,VK_TRUE,UINT64_MAX);
- vkResetCommandBuffer(cache->cmd,NULL);
+ vkResetCommandBuffer(cache->cmd,0);
vkResetFences (dev->vkDev,1,&cache->uploadFence);
memcpy(cache->buff.allocInfo.pMappedData, cache->hostBuff, f->curLine.height * FONT_PAGE_SIZE);
hb_glyph_position_t *glyph_pos;
} vkvg_text_run_t;
-void _init_fonts_cache (VkvgDevice dev);
+void _init_fonts_cache (VkvgDevice dev);
void _destroy_font_cache (VkvgDevice dev);
void _select_font_face (VkvgContext ctx, const char* name);
void _set_font_size (VkvgContext ctx, uint32_t size);
void _show_text (VkvgContext ctx, const char* text);
-void _text_extents (VkvgContext ctx, const char* text, vkvg_text_extents_t *extents);
-void _font_extents (VkvgContext ctx, vkvg_font_extents_t* extents);
+void _text_extents (VkvgContext ctx, const char* text, vkvg_text_extents_t *extents);
+void _font_extents (VkvgContext ctx, vkvg_font_extents_t* extents);
-void _create_text_run (VkvgContext ctx, const char* text, VkvgText textRun);
-void _destroy_text_run (VkvgText textRun);
-void _show_text_run (VkvgContext ctx, VkvgText tr);
+void _create_text_run (VkvgContext ctx, const char* text, VkvgText textRun);
+void _destroy_text_run (VkvgText textRun);
+void _show_text_run (VkvgContext ctx, VkvgText tr);
+void _flush_chars_to_tex (VkvgDevice dev, _vkvg_font_t* f);
#endif
vkh_cmd_begin (cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
if (aspect & VK_IMAGE_ASPECT_COLOR_BIT) {
- VkClearColorValue cclr = {0,0,0,0};
+ VkClearColorValue cclr = {{0,0,0,0}};
VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT,0,1,0,1};
vkh_image_set_layout (cmd, surf->imgMS, VK_IMAGE_ASPECT_COLOR_BIT,
void _init_surface (VkvgSurface surf) {
surf->format = FB_COLOR_FORMAT;//force bgra internally
- surf->img = vkh_image_create(surf->dev,surf->format,surf->width,surf->height,VKVG_TILING,VMA_MEMORY_USAGE_GPU_ONLY,
+ surf->img = vkh_image_create((VkhDevice)surf->dev,surf->format,surf->width,surf->height,VKVG_TILING,VMA_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
- surf->imgMS = vkh_image_ms_create(surf->dev,surf->format,surf->dev->samples,surf->width,surf->height,VMA_MEMORY_USAGE_GPU_ONLY,
+ surf->imgMS = vkh_image_ms_create((VkhDevice)surf->dev,surf->format,surf->dev->samples,surf->width,surf->height,VMA_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
- surf->stencilMS = vkh_image_ms_create(surf->dev,VK_FORMAT_S8_UINT,surf->dev->samples,surf->width,surf->height,VMA_MEMORY_USAGE_GPU_ONLY,
+ surf->stencilMS = vkh_image_ms_create((VkhDevice)surf->dev,VK_FORMAT_S8_UINT,surf->dev->samples,surf->width,surf->height,VMA_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
vkh_image_create_descriptor(surf->img, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST,VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
uint32_t imgSize = width * height * 4;
VkImageSubresourceLayers imgSubResLayers = {VK_IMAGE_ASPECT_COLOR_BIT,0,0,1};
//original format image
- VkhImage stagImg= vkh_image_create (surf->dev,VK_FORMAT_R8G8B8A8_UNORM,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
+ VkhImage stagImg= vkh_image_create ((VkhDevice)surf->dev,VK_FORMAT_R8G8B8A8_UNORM,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
VMA_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
//bgra bliting target
- VkhImage tmpImg = vkh_image_create (surf->dev,surf->format,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
+ VkhImage tmpImg = vkh_image_create ((VkhDevice)surf->dev,surf->format,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
VMA_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
vkh_image_create_descriptor (tmpImg, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT,
VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER);
//staging buffer
- vkvg_buff buff = {};
+ vkvg_buff buff = {0};
vkvg_buffer_create(dev, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU, imgSize, &buff);
memcpy (buff.allocInfo.pMappedData, img, imgSize);
VkImageBlit blit = {
.srcSubresource = imgSubResLayers,
- .srcOffsets[1] = {surf->width, surf->height, 1},
+ .srcOffsets[1] = {(int32_t)surf->width, (int32_t)surf->height, 1},
.dstSubresource = imgSubResLayers,
- .dstOffsets[1] = {surf->width, surf->height, 1},
+ .dstOffsets[1] = {(int32_t)surf->width, (int32_t)surf->height, 1},
};
vkCmdBlitImage (cmd,
vkh_image_get_vkimage (stagImg), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VkClearRect cr = {{{0,0},{surf->width,surf->height}},0,1};
vkCmdClearAttachments(ctx->cmd, 1, &ca, 1, &cr);*/
- vec4 srcRect = {0,0,surf->width,surf->height};
+ vec4 srcRect = {.x=0,.y=0,.width=surf->width,.height=surf->height};
ctx->pushConsts.source = srcRect;
ctx->pushConsts.patternType = VKVG_PATTERN_TYPE_SURFACE;
return NULL;
}
- VkvgSurface surf = vkvg_surface_create_from_bitmap(dev, img, w, h);
+ VkvgSurface surf = vkvg_surface_create_from_bitmap(dev, img, (uint32_t)w, (uint32_t)h);
stbi_image_free (img);
VkvgDevice dev = surf->dev;
//RGBA to blit to, surf img is bgra
- VkhImage stagImg= vkh_image_create (surf->dev,VK_FORMAT_R8G8B8A8_UNORM,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
+ VkhImage stagImg= vkh_image_create ((VkhDevice)surf->dev,VK_FORMAT_R8G8B8A8_UNORM,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
VMA_MEMORY_USAGE_GPU_TO_CPU,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
VkImageBlit blit = {
.srcSubresource = imgSubResLayers,
- .srcOffsets[1] = {surf->width, surf->height, 1},
+ .srcOffsets[1] = {(int32_t)surf->width, (int32_t)surf->height, 1},
.dstSubresource = imgSubResLayers,
- .dstOffsets[1] = {surf->width, surf->height, 1},
+ .dstOffsets[1] = {(int32_t)surf->width, (int32_t)surf->height, 1},
};
vkCmdBlitImage (cmd,
vkh_image_get_vkimage (surf->img), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
void* img = vkh_image_map (stagImg);
- stbi_write_png (path, surf->width, surf->height, 4, img, stride);
+ stbi_write_png (path, (int32_t)surf->width, (int32_t)surf->height, 4, img, (int32_t)stride);
vkh_image_unmap (stagImg);
vkh_image_destroy (stagImg);
#include "vkh_device.h"
#include "vkh_presenter.h"
+#ifdef _WIN32 // MSC_VER
+ #define WIN32_LEAN_AND_MEAN
+ #define NOMINMAX
+ #include <Windows.h> // 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;
+ }
+#else
+ #include <sys/time.h>
+#endif // _WIN32
+
VkvgDevice device;
VkvgSurface surf = NULL;
VkvgSurface surf2 = vkvg_surface_create (device,800,800);;
VkvgContext ctx = vkvg_create (surf2);
- vkvg_set_source_rgba(ctx,0.1,0.1,0.3,1.0);
+ vkvg_set_source_rgba(ctx,0.1,0.1,0.3,1);
vkvg_paint(ctx);
vkvg_test_fill(ctx);
VkvgPattern pat = vkvg_pattern_create_for_surface(surf2);
vkvg_pattern_set_extend(pat, VKVG_EXTEND_REFLECT);
- vkvg_pattern_set_filter(pat, VKVG_FILTER_BILINEAR);
+ vkvg_pattern_set_filter(pat, VKVG_FILTER_BEST);
vkvg_set_source (ctx, pat);
//vkvg_rectangle(ctx,100,100,400,400);
//vkvg_fill(ctx);
}
void simple_rectangle_stroke () {
VkvgContext ctx = vkvg_create(surf);
+ vkvg_clear(ctx);
+ vkvg_line_to(ctx,100,100);
vkvg_set_source_rgba(ctx,0,0,1,1);
- vkvg_set_line_width(ctx,10.f);
+ vkvg_set_line_width(ctx,50.f);
+ vkvg_set_line_join(ctx,VKVG_LINE_JOIN_ROUND);
vkvg_rectangle(ctx,100,100,200,200);
vkvg_stroke(ctx);
vkvg_destroy(ctx);
VkDeviceCreateInfo device_info = { .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.queueCreateInfoCount = qCount,
- .pQueueCreateInfos = &pQueueInfos,
+ .pQueueCreateInfos = (VkDeviceQueueCreateInfo*)&pQueueInfos,
.enabledLayerCount = dlayCpt,
.ppEnabledLayerNames = dlay,
.enabledExtensionCount = 1,
-Subproject commit 012ca283a29bca6dd6b828406fe490ff356484f1
+Subproject commit 311dac1b50ea5506a239f8b39450a2761d101fa2
home / projects / jp / vkvg.git / commitdiff