SET(CMAKE_BUILD_TYPE Release)
ENDIF()
-# IF (UNIX)
-# SET(LINKER_FLAGS "-lm")
-# SET(CMAKE_EXE_LINKER_FLAGS ${LINKER_FLAGS})
-# SET(CMAKE_SHARED_LINKER_FLAGS ${LINKER_FLAGS})
-# ENDIF()
+IF (UNIX)
+ ADD_COMPILE_OPTIONS(-lm)
+ENDIF()
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
ADD_DEFINITIONS (-DDEBUG)
OPTION(ENABLE_VALIDATION "enable vulkan validation layer" ON)
OPTION(VKVG_USE_MESA_OVERLAY "enable VK_LAYER_MESA_overlay if present." OFF)
IF (VKVG_USE_MESA_OVERLAY)
- ADD_DEFINITIONS (-DVKVG_USE_MESA_OVERLAY)
+ ADD_DEFINITIONS (-DVKVG_USE_MESA_OVERLAY)
ENDIF ()
OPTION(ENABLE_DBG_UTILS "enable VK_EXT_debug_utils extension" ON)
- OPTION(ENABLE_WIRED_FILL "enable wired polygon draw to check vertices and primitives" OFF)
+ OPTION(VKVG_WIRED_FILL "enable wired polygon draw to check vertices and primitives" OFF)
IF (UNIX)
- SET(CMAKE_${LANG}_FLAGS "-rdynamic -Wall -Wno-extra -Wno-unknown-pragmas -Wno-missing-braces -Wno-unused-variable -Wno-switch")
+ ADD_COMPILE_OPTIONS(-Wall -Wno-extra -Wno-unknown-pragmas -Wno-missing-braces -Wno-unused-variable -Wno-switch -Wno-unused-value)
ELSEIF(MSVC)
- SET(CMAKE_${LANG}_FLAGS "/TC /W4 /wd4201 /wd4204 /wd4221 /wd4100") # c11 compliant
+ ADD_COMPILE_OPTIONS(/TC /W4 /wd4201 /wd4204 /wd4221 /wd4100) # c11 compliant
ENDIF()
ELSE()
UNSET(ENABLE_VALIDATION CACHE)
UNSET(ENABLE_DBG_UTILS CACHE)
- UNSET(ENABLE_WIRED_FILL CACHE)
+ UNSET(VKVG_WIRED_FILL CACHE)
UNSET(VKVG_USE_MESA_OVERLAY CACHE)
IF (ANDROID)
- SET(CMAKE_${LANG}_FLAGS "${CMAKE_CXX_FLAGS} -O3 -w -ansi -pedantic")
- ELSEIF (UNIX)
- SET(CMAKE_${LANG}_FLAGS "${CMAKE_CXX_FLAGS} -O3 -w -ansi -pedantic")
+ ADD_COMPILE_OPTIONS(-O3 -w -ansi -pedantic)
+ ELSEIF (UNIX)
+ ADD_COMPILE_OPTIONS(-O3 -w -ansi -pedantic -fvisibility=hidden -flto -fno-rtti)
+ #ADD_COMPILE_OPTIONS("-Wl,--exclude-libs,ALL")
ELSEIF(MSVC)
- SET(CMAKE_${LANG}_FLAGS "${CMAKE_CXX_FLAGS} /O2 /TC /W0")
+ ADD_COMPILE_OPTIONS(/O2 /TC /W0)
ENDIF()
ENDIF()
ADD_SUBDIRECTORY (vkh)
ENDIF()
+#use c++ vulkan memory allocator library (https://gpuopen.com/vulkan-memory-allocator/)
+IF (VKH_USE_VMA)
+ ADD_DEFINITIONS (-DVKH_USE_VMA)
+ENDIF()
+
IF (ENABLE_VALIDATION)
ADD_DEFINITIONS (-DVKVG_USE_VALIDATION)
OPTION(ENABLE_RENDERDOC "enable renderdoc" OFF)
ADD_DEFINITIONS (-DVKVG_USE_RENDERDOC)
ENDIF ()
ENDIF ()
-IF (ENABLE_WIRED_FILL)
+IF (VKVG_WIRED_FILL)
ADD_DEFINITIONS (-DVKVG_WIRED_DEBUG)
ENDIF ()
# todo if cmake vers >= 3.23: make dependent option on Vulkan_VERSION >= 1_2:
OPTION(VKVG_ENABLE_VK_SCALAR_BLOCK_LAYOUT "Enable scalar block layout support." ON)
IF (VKVG_ENABLE_VK_SCALAR_BLOCK_LAYOUT)
- ADD_DEFINITIONS (-DVKVG_ENABLE_VK_SCALAR_BLOCK_LAYOUT)
+ ADD_DEFINITIONS (-DVKVG_ENABLE_VK_SCALAR_BLOCK_LAYOUT)
SET(GLSLDEFS "-DVKVG_ENABLE_VK_SCALAR_BLOCK_LAYOUT")
ENDIF ()
OPTION(VKVG_ENABLE_VK_TIMELINE_SEMAPHORE "Enable vulkan TimelineSemaphore support." OFF)
IF (VKVG_ENABLE_VK_TIMELINE_SEMAPHORE)
- ADD_DEFINITIONS (-DVKVG_ENABLE_VK_TIMELINE_SEMAPHORE)
+ ADD_DEFINITIONS (-DVKVG_ENABLE_VK_TIMELINE_SEMAPHORE)
ENDIF ()
)
get_target_property(libtype "${LibName}" TYPE)
-
- IF (UNIX AND ($libtype STREQUAL "SHARED_LIBRARY"))
- TARGET_LINK_LIBRARIES("${LibName}" PUBLIC "-lm")
+
+ IF (UNIX)# AND ($libtype STREQUAL "SHARED_LIBRARY"))
+ TARGET_LINK_LIBRARIES("${LibName}" PUBLIC m)
ENDIF()
IF(VKVG_USE_FREETYPE)
- #TARGET_INCLUDE_DIRECTORIES("${LibName}" PRIVATE ${FREETYPE_INCLUDE_DIRS})
TARGET_LINK_LIBRARIES("${LibName}" PRIVATE ${FREETYPE_LIBRARIES})
ENDIF()
IF(VKVG_USE_FONTCONFIG)
- #TARGET_INCLUDE_DIRECTORIES("${LibName}" PRIVATE ${Fontconfig_INCLUDE_DIRS})
TARGET_LINK_LIBRARIES("${LibName}" PRIVATE ${Fontconfig_LIBRARIES})
ENDIF()
IF(VKVG_USE_HARFBUZZ)
- #TARGET_INCLUDE_DIRECTORIES("${LibName}" PRIVATE ${HarfBuzz_INCLUDE_DIRS})
TARGET_LINK_LIBRARIES("${LibName}" PRIVATE ${HarfBuzz_LIBRARIES})
ENDIF()
IF(VKVG_USE_GLUTESS)
IF (SHADERS_H)
ADD_DEPENDENCIES("${PROJECT_NAME}_obj" BuildShadersHeader)
-ENDIF ()
-
-IF (BUILD_SHARED_LIBS)
- MESSAGE(STATUS "Library type\t\t= Shared.")
-ELSE ()
- MESSAGE(STATUS "Library type\t\t= Static.")
-ENDIF ()
-
-MESSAGE(STATUS "VKVG version\t\t= ${vkvg_VERSION_MAJOR}.${vkvg_VERSION_MINOR}.${vkvg_VERSION_PATCH}")
-MESSAGE(STATUS "comp flags\t\t= ${CMAKE_${LANG}_FLAGS}")
-IF (VKVG_BUILD_TESTS)
- MESSAGE(STATUS "Build tests\t\t= true.")
-ELSE ()
- MESSAGE(STATUS "Build tests\t\t= false.")
-ENDIF ()
-IF (VKVG_SVG)
- MESSAGE(STATUS "SVG rendering\t= vkvg-svg (experimental).")
-ELSE ()
- MESSAGE(STATUS "SVG rendering\t= nanosvg")
-ENDIF ()
-IF (VKVG_RECORDING)
- MESSAGE(STATUS "Recording features\t= true (experimental).")
-ELSE ()
- MESSAGE(STATUS "Recording features\t= false.")
-ENDIF ()
-IF (VKVG_DBG_STATS)
- MESSAGE(STATUS "Debug statistics\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Debug statistics\t= disabled.")
-ENDIF ()
-IF (ENABLE_DBG_UTILS)
- MESSAGE(STATUS "Debug utils\t\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Debug utils\t\t= disabled.")
-ENDIF ()
-IF (ENABLE_VALIDATION)
- MESSAGE(STATUS "Validation\t\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Validation\t\t= disabled.")
-ENDIF ()
-IF (ENABLE_RENDERDOC)
- MESSAGE(STATUS "Renderdoc\t\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Renderdoc\t\t= disabled.")
-ENDIF ()
-IF (VKVG_DBG_STATS)
- MESSAGE(STATUS "Dbg Stats\t\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Dbg Stats\t\t= disabled.")
-ENDIF ()
-IF (VKVG_PREMULT_ALPHA)
- MESSAGE(STATUS "Premult Alpha\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Premult Alpha\t= disabled.")
-ENDIF ()
-IF (VKVG_USE_FREETYPE)
- MESSAGE(STATUS "Freetype\t\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Freetype\t\t= disabled.")
-ENDIF ()
-IF (VKVG_USE_FONTCONFIG)
- MESSAGE(STATUS "Fontconfig\t\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Fontconfig\t\t= disabled.")
-ENDIF ()
-IF (VKVG_USE_HARFBUZZ)
- MESSAGE(STATUS "Harfbuzz\t\t= enabled.")
-ELSE ()
- MESSAGE(STATUS "Harfbuzz\t\t= disabled.")
-ENDIF ()
-IF (VKVG_LCD_FONT_FILTER)
- MESSAGE(STATUS "Font filtering\t= LCD.")
-ELSE ()
- MESSAGE(STATUS "Font filtering\t= Grayscale.")
-ENDIF ()
-IF (VKVG_USE_GLUTESS)
- MESSAGE(STATUS "Fill NON ZERO\t= glu tessellator.")
-ELSE ()
- MESSAGE(STATUS "Fill NON ZERO\t= ear clipping.")
-ENDIF ()
-IF (VKVG_BUILD_DOCS)
- MESSAGE(STATUS "Build documentation\t= enabled.")
- IF (Sphinx_FOUND)
- MESSAGE(STATUS "Sphinx documentation\t= enabled.")
- ELSE ()
- MESSAGE(STATUS "Sphinx documentation\t= disabled.")
- ENDIF ()
-ELSE ()
- MESSAGE(STATUS "Build documentation\t= disabled.")
-ENDIF ()
+ENDIF()
#include <stdbool.h>
#ifndef vkvg_public
- #ifdef VKVG_SHARED_BUILD
+ //#ifdef VKVG_SHARED_BUILD
#if (defined(_WIN32) || defined(_WIN64))
#define vkvg_public __declspec(dllimport)
#else
#define vkvg_public __attribute__((visibility("default")))
#endif
- #else
+ /*#else
#define vkvg_public
- #endif
+ #endif*/
#endif
+++ /dev/null
-/*
- * Copyright (c) 2018-2022 Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of
- * this software and associated documentation files (the "Software"), to deal in
- * the Software without restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
- * Software, and to permit persons to whom the Software is furnished to do so, subject
- * to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "vkvg_buff.h"
-#include "vkvg_device_internal.h"
-
-void vkvg_buffer_create(VkvgDevice pDev, VkBufferUsageFlags usage, VmaMemoryUsage memoryPropertyFlags, VkDeviceSize size, vkvg_buff *buff){
- buff->pDev = pDev;
- VkBufferCreateInfo bufCreateInfo = {
- .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
- .usage = usage, .size = size, .sharingMode = VK_SHARING_MODE_EXCLUSIVE};
- VmaAllocationCreateInfo allocInfo = { .usage = memoryPropertyFlags, .flags = VMA_ALLOCATION_CREATE_MAPPED_BIT };
-
- VK_CHECK_RESULT(vmaCreateBuffer (pDev->allocator, &bufCreateInfo, &allocInfo, &buff->buffer, &buff->alloc, &buff->allocInfo));
-}
-
-void vkvg_buffer_destroy(vkvg_buff *buff){
- vmaDestroyBuffer (buff->pDev->allocator, buff->buffer, buff->alloc);
-}
-void vkvg_buffer_flush (vkvg_buff* buff){
- vmaFlushAllocation (buff->pDev->allocator, buff->alloc, buff->allocInfo.offset, buff->allocInfo.size);
-}
+++ /dev/null
-/*
- * Copyright (c) 2018-2022 Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of
- * this software and associated documentation files (the "Software"), to deal in
- * the Software without restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
- * Software, and to permit persons to whom the Software is furnished to do so, subject
- * to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#ifndef VKVG_BUFF_H
-#define VKVG_BUFF_H
-
-#include <vulkan/vulkan.h>
-#include "vkvg.h"
-#include "vk_mem_alloc.h"
-
-typedef struct vkvg_buff_t {
- VkvgDevice pDev;
- VkBuffer buffer;
- VmaAllocation alloc;
- VmaAllocationInfo allocInfo;
- VkDescriptorBufferInfo descriptor;
-}vkvg_buff;
-
-void vkvg_buffer_create (VkvgDevice pDev, VkBufferUsageFlags usage,
- VmaMemoryUsage memoryPropertyFlags, VkDeviceSize size, vkvg_buff *buff);
-void vkvg_buffer_destroy (vkvg_buff* buff);
-
-void vkvg_buffer_flush (vkvg_buff* buff);
-#endif
}
ctx->savedStencils = savedStencilsPtr;
VkhImage savStencil = vkh_image_ms_create ((VkhDevice)dev, dev->stencilFormat, 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);
+ VKH_MEMORY_USAGE_GPU_ONLY, VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
ctx->savedStencils[curSaveStencil-1] = savStencil;
vkh_cmd_begin (ctx->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
return fminf(M_PIF / 3.f,M_PIF / (r * 0.4f));
}
void _create_gradient_buff (VkvgContext ctx){
- vkvg_buffer_create (ctx->dev,
+ vkh_buffer_init ((VkhDevice)ctx->dev,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
- VMA_MEMORY_USAGE_CPU_TO_GPU,
- sizeof(vkvg_gradient_t), &ctx->uboGrad);
+ VKH_MEMORY_USAGE_CPU_TO_GPU,
+ sizeof(vkvg_gradient_t), &ctx->uboGrad, true);
}
void _create_vertices_buff (VkvgContext ctx){
- vkvg_buffer_create (ctx->dev,
+ vkh_buffer_init ((VkhDevice)ctx->dev,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
- VMA_MEMORY_USAGE_CPU_TO_GPU,
- ctx->sizeVBO * sizeof(Vertex), &ctx->vertices);
- vkvg_buffer_create (ctx->dev,
+ VKH_MEMORY_USAGE_CPU_TO_GPU,
+ ctx->sizeVBO * sizeof(Vertex), &ctx->vertices, true);
+ vkh_buffer_init ((VkhDevice)ctx->dev,
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
- VMA_MEMORY_USAGE_CPU_TO_GPU,
- ctx->sizeIBO * sizeof(VKVG_IBO_INDEX_TYPE), &ctx->indices);
+ VKH_MEMORY_USAGE_CPU_TO_GPU,
+ ctx->sizeIBO * sizeof(VKVG_IBO_INDEX_TYPE), &ctx->indices, true);
}
void _resize_vbo (VkvgContext ctx, uint32_t new_size) {
if (!_wait_ctx_flush_end (ctx))//wait previous cmd if not completed
if (mod > 0)
ctx->sizeVBO += VKVG_VBO_SIZE - mod;
LOG(VKVG_LOG_DBG_ARRAYS, "%d\n", ctx->sizeVBO);
- vkvg_buffer_destroy (&ctx->vertices);
- vkvg_buffer_create (ctx->dev,
- VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
- VMA_MEMORY_USAGE_CPU_TO_GPU,
- ctx->sizeVBO * sizeof(Vertex), &ctx->vertices);
+ vkh_buffer_resize (&ctx->vertices, ctx->sizeVBO * sizeof(Vertex), true);
}
void _resize_ibo (VkvgContext ctx, size_t new_size) {
if (!_wait_ctx_flush_end (ctx))//wait previous cmd if not completed
uint32_t mod = ctx->sizeIBO % VKVG_IBO_SIZE;
if (mod > 0)
ctx->sizeIBO += VKVG_IBO_SIZE - mod;
- LOG(VKVG_LOG_DBG_ARRAYS, "resize IBO: new size: %d\n", ctx->sizeIBO);
- vkvg_buffer_destroy (&ctx->indices);
- vkvg_buffer_create (ctx->dev,
- VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
- VMA_MEMORY_USAGE_CPU_TO_GPU,
- ctx->sizeIBO * sizeof(VKVG_IBO_INDEX_TYPE), &ctx->indices);
+ LOG(VKVG_LOG_DBG_ARRAYS, "resize IBO: new size: %d\n", ctx->sizeIBO);
+ vkh_buffer_resize (&ctx->indices, ctx->sizeIBO * sizeof(VKVG_IBO_INDEX_TYPE), true);
}
void _add_vertexf (VkvgContext ctx, float x, float y){
Vertex* pVert = &ctx->vertexCache[ctx->vertCount];
void _flush_vertices_caches_until_vertex_base (VkvgContext ctx) {
_wait_ctx_flush_end (ctx);
- memcpy(ctx->vertices.allocInfo.pMappedData, ctx->vertexCache, ctx->curVertOffset * sizeof (Vertex));
- memcpy(ctx->indices.allocInfo.pMappedData, ctx->indexCache, ctx->curIndStart * sizeof (VKVG_IBO_INDEX_TYPE));
+ memcpy(vkh_buffer_get_mapped_pointer(&ctx->vertices), ctx->vertexCache, ctx->curVertOffset * sizeof (Vertex));
+ memcpy(vkh_buffer_get_mapped_pointer(&ctx->indices), ctx->indexCache, ctx->curIndStart * sizeof (VKVG_IBO_INDEX_TYPE));
//copy remaining vertices and indices to caches starts
//this could be optimized at the cost of additional offsets.
if (!_wait_ctx_flush_end (ctx))
return;
- memcpy(ctx->vertices.allocInfo.pMappedData, ctx->vertexCache, ctx->vertCount * sizeof (Vertex));
- memcpy(ctx->indices.allocInfo.pMappedData, ctx->indexCache, ctx->indCount * sizeof (VKVG_IBO_INDEX_TYPE));
+ memcpy(vkh_buffer_get_mapped_pointer(&ctx->vertices), ctx->vertexCache, ctx->vertCount * sizeof (Vertex));
+ memcpy(vkh_buffer_get_mapped_pointer(&ctx->indices), ctx->indexCache, ctx->indCount * sizeof (VKVG_IBO_INDEX_TYPE));
ctx->vertCount = ctx->indCount = ctx->curIndStart = ctx->curVertOffset = 0;
}
vkvg_matrix_transform_distance (&ctx->pushConsts.mat, &grad.cp[1].z, &grad.cp[0].w);
}
- memcpy (ctx->uboGrad.allocInfo.pMappedData , &grad, sizeof(vkvg_gradient_t));
- vkvg_buffer_flush(&ctx->uboGrad);
+ memcpy (vkh_buffer_get_mapped_pointer(&ctx->uboGrad) , &grad, sizeof(vkvg_gradient_t));
+ vkh_buffer_flush(&ctx->uboGrad);
break;
}
ctx->pushConsts.fsq_patternType = (ctx->pushConsts.fsq_patternType & FULLSCREEN_BIT) + newPatternType;
vkDestroyDescriptorPool (dev, ctx->descriptorPool,NULL);
- vkvg_buffer_destroy (&ctx->uboGrad);
- vkvg_buffer_destroy (&ctx->indices);
- vkvg_buffer_destroy (&ctx->vertices);
+ vkh_buffer_reset (&ctx->uboGrad);
+ vkh_buffer_reset (&ctx->indices);
+ vkh_buffer_reset (&ctx->vertices);
free(ctx->vertexCache);
free(ctx->indexCache);
#include "vkvg_internal.h"
#include "vkvg.h"
-#include "vkvg_buff.h"
#include "vkh.h"
#include "vkvg_fonts.h"
vkvg_recording_t* recording;
#endif
- vkvg_buff uboGrad; //uniform buff obj holdings gradient infos
+ vkh_buffer_t uboGrad; //uniform buff obj holdings gradient infos
//vk buffers, holds data until flush
- vkvg_buff indices; //index buffer with persistent map memory
+ vkh_buffer_t indices; //index buffer with persistent map memory
uint32_t sizeIBO; //size of vk ibo
uint32_t sizeIndices; //reserved size
uint32_t indCount; //current indice count
uint32_t curIndStart; //last index recorded in cmd buff
VKVG_IBO_INDEX_TYPE curVertOffset; //vertex offset in draw indexed command
- vkvg_buff vertices; //vertex buffer with persistent mapped memory
+ vkh_buffer_t vertices; //vertex buffer with persistent mapped memory
uint32_t sizeVBO; //size of vk vbo size
uint32_t sizeVertices; //reserved size
uint32_t vertCount; //effective vertices count
dev->cachedContextLast = cur;
}
void _device_init (VkvgDevice dev, VkInstance inst, VkPhysicalDevice phy, VkDevice vkdev, uint32_t qFamIdx, uint32_t qIndex, VkSampleCountFlags samples, bool deferredResolve) {
+ dev->vkDev = vkdev;
+ dev->phy = phy;
dev->instance = inst;
dev->hdpi = 72;
dev->vdpi = 72;
dev->deferredResolve = false;
else
dev->deferredResolve = deferredResolve;
- dev->vkDev = vkdev;
- dev->phy = phy;
dev->cachedContextMaxCount = VKVG_MAX_CACHED_CONTEXT_COUNT;
vkh_phyinfo_destroy (phyInfos);
+#ifdef VKH_USE_VMA
VmaAllocatorCreateInfo allocatorInfo = {
.physicalDevice = phy,
.device = vkdev
};
vmaCreateAllocator(&allocatorInfo, &dev->allocator);
+#endif
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);
_font_cache_destroy(dev);
+#ifdef VKH_USE_VMA
vmaDestroyAllocator (dev->allocator);
+#endif
if (dev->threadAware)
mtx_destroy (&dev->mutex);
void _device_create_empty_texture (VkvgDevice dev, VkFormat format, VkImageTiling tiling) {
//create empty image to bind to context source descriptor when not in use
- dev->emptyImg = vkh_image_create((VkhDevice)dev,format,16,16,tiling,VMA_MEMORY_USAGE_GPU_ONLY,
+ dev->emptyImg = vkh_image_create((VkhDevice)dev,format,16,16,tiling,VKH_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);
VkDevice vkDev; /**< Vulkan Logical Device */
VkPhysicalDeviceMemoryProperties phyMemProps; /**< Vulkan Physical device memory properties */
VkPhysicalDevice phy; /**< Vulkan Physical device */
- VmaAllocator allocator; /**< Vulkan Memory allocator */
VkInstance instance; /**< Vulkan instance */
+#ifdef VKH_USE_VMA
+ void* allocator; /**< Vulkan Memory allocator */
+#endif
VkImageTiling supportedTiling; /**< Supported image tiling for surface, 0xFF=no support */
VkFormat stencilFormat; /**< Supported vulkan image format for stencil */
cache->texLength = FONT_CACHE_INIT_LAYERS;
cache->texture = vkh_tex2d_array_create ((VkhDevice)dev, cache->texFormat, FONT_PAGE_SIZE, FONT_PAGE_SIZE,
- cache->texLength ,VMA_MEMORY_USAGE_GPU_ONLY,
+ cache->texLength ,VKH_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->texture, 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);
uint32_t buffLength = FONT_PAGE_SIZE*FONT_PAGE_SIZE*cache->texPixelSize;
- vkvg_buffer_create (dev,
+ vkh_buffer_init ((VkhDevice)dev,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
- VMA_MEMORY_USAGE_CPU_TO_GPU,
- buffLength, &cache->buff);
+ VKH_MEMORY_USAGE_CPU_TO_GPU,
+ buffLength, &cache->buff, true);
cache->cmd = vkh_cmd_buff_create((VkhDevice)dev,dev->cmdPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY);
uint8_t newSize = cache->texLength + FONT_CACHE_INIT_LAYERS;
VkhImage newImg = vkh_tex2d_array_create ((VkhDevice)dev, cache->texFormat, FONT_PAGE_SIZE, FONT_PAGE_SIZE,
- newSize ,VMA_MEMORY_USAGE_GPU_ONLY,
+ newSize ,VKH_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);
vkResetCommandBuffer(cache->cmd,0);
- memcpy(cache->buff.allocInfo.pMappedData, cache->hostBuff, (uint64_t)f->curLine.height * FONT_PAGE_SIZE * cache->texPixelSize);
+ memcpy(vkh_buffer_get_mapped_pointer (&cache->buff), cache->hostBuff, (uint64_t)f->curLine.height * FONT_PAGE_SIZE * cache->texPixelSize);
vkh_cmd_begin (cache->cmd,VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
free(cache->fonts);
free(cache->pensY);
- vkvg_buffer_destroy (&cache->buff);
+ vkh_buffer_reset (&cache->buff);
vkh_image_destroy (cache->texture);
//vkFreeCommandBuffers(dev->vkDev,dev->cmdPool, 1, &cache->cmd);
vkDestroyFence (dev->vkDev,cache->uploadFence,NULL);
#define FONT_NAME_MAX_SIZE 128
#include "vkvg_internal.h"
+#include "vkh_buffer.h"
//texture coordinates of one character in font cache array texture.
typedef struct {
uint8_t* hostBuff; /* host memory where bitmaps are first loaded */
VkCommandBuffer cmd; /* vulkan command buffer for font textures upload */
- vkvg_buff buff; /* stagin buffer */
+ vkh_buffer_t buff; /* stagin buffer */
VkhImage texture; /* 2d array texture used by contexts to draw characteres */
VkFormat texFormat; /* Format of the fonts texture array */
uint8_t texPixelSize; /* Size in byte of a single pixel in a font texture */
//#define VKVG_FENCE_TIMEOUT 10000
#include "vkvg.h"
-#include "vkvg_buff.h"
#include "vkh.h"
#include "vectors.h"
VkImageSubresourceLayers imgSubResLayers = {VK_IMAGE_ASPECT_COLOR_BIT,0,0,1};
//original format image
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,
+ VKH_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
//bgra bliting target
VkhImage tmpImg = vkh_image_create ((VkhDevice)surf->dev,surf->format,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
- VMA_MEMORY_USAGE_GPU_ONLY,
+ VKH_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 = {0};
- vkvg_buffer_create(dev, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU, imgSize, &buff);
+ vkh_buffer_t buff = {0};
+ vkh_buffer_init((VkhDevice)dev,
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+ VKH_MEMORY_USAGE_CPU_TO_GPU,
+ imgSize, &buff, true);
- memcpy (buff.allocInfo.pMappedData, img, imgSize);
+ memcpy (vkh_buffer_get_mapped_pointer (&buff), img, imgSize);
VkCommandBuffer cmd = surf->cmd;
_surface_submit_cmd (surf);//lock surface?
- vkvg_buffer_destroy (&buff);
+ vkh_buffer_reset (&buff);
vkh_image_destroy (stagImg);
surf->newSurf = false;
if (dev->pngStagTiling == VK_IMAGE_TILING_LINEAR)
stagImg = vkh_image_create ((VkhDevice)surf->dev, dev->pngStagFormat, surf->width, surf->height, dev->pngStagTiling,
- VMA_MEMORY_USAGE_GPU_TO_CPU,
+ VKH_MEMORY_USAGE_GPU_TO_CPU,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
else
stagImg = vkh_image_create ((VkhDevice)surf->dev, dev->pngStagFormat, surf->width,surf->height, dev->pngStagTiling,
- VMA_MEMORY_USAGE_GPU_ONLY,
+ VKH_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
VkCommandBuffer cmd = surf->cmd;
if (dev->pngStagTiling == VK_IMAGE_TILING_OPTIMAL) {
stagImgLinear = vkh_image_create ((VkhDevice)surf->dev, dev->pngStagFormat, surf->width, surf->height, VK_IMAGE_TILING_LINEAR,
- VMA_MEMORY_USAGE_GPU_TO_CPU,
+ VKH_MEMORY_USAGE_GPU_TO_CPU,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
VkImageCopy cpy = {
.srcSubresource = imgSubResLayers,
//RGBA to blit to, surf img is bgra
VkhImage stagImg= vkh_image_create ((VkhDevice)surf->dev,VK_FORMAT_B8G8R8A8_UNORM ,surf->width,surf->height,VK_IMAGE_TILING_LINEAR,
- VMA_MEMORY_USAGE_GPU_TO_CPU,
+ VKH_MEMORY_USAGE_GPU_TO_CPU,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
VkCommandBuffer cmd = surf->cmd;
}
void _create_surface_main_image (VkvgSurface surf){
- surf->img = vkh_image_create((VkhDevice)surf->dev,surf->format,surf->width,surf->height,surf->dev->supportedTiling,VMA_MEMORY_USAGE_GPU_ONLY,
+ surf->img = vkh_image_create((VkhDevice)surf->dev,surf->format,surf->width,surf->height,surf->dev->supportedTiling,VKH_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);
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);
#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
//create multisample color img if sample count > 1 and the stencil buffer multisampled or not
void _create_surface_secondary_images (VkvgSurface surf) {
if (surf->dev->samples > VK_SAMPLE_COUNT_1_BIT){
- surf->imgMS = vkh_image_ms_create((VkhDevice)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,VKH_MEMORY_USAGE_GPU_ONLY,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
vkh_image_create_descriptor(surf->imgMS, 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);
vkh_device_set_object_name((VkhDevice)surf->dev, VK_OBJECT_TYPE_SAMPLER, (uint64_t)vkh_image_get_sampler(surf->imgMS), "SURF MS color SAMPLER");
#endif
}
- surf->stencil = vkh_image_ms_create((VkhDevice)surf->dev,surf->dev->stencilFormat,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);
+ surf->stencil = vkh_image_ms_create((VkhDevice)surf->dev,surf->dev->stencilFormat,surf->dev->samples,surf->width,surf->height,VKH_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->stencil, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_STENCIL_BIT, VK_FILTER_NEAREST,
VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST,VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
-Subproject commit bb8882772bd5a00c6dfd4e33ec005d333f277898
+Subproject commit 75e8dc3c818ea9ed8d52c840b46c3a4c2c8f2fb4
home / projects / jp / vkvg.git / commitdiff