CMAKE_MINIMUM_REQUIRED(VERSION 3.16)

SET(LANG "CXX")

SET(CMAKE_C_STANDARD 11)

SET(CMAKE_CXX_STANDARD 11)

OPTION (VKVG_BUILD_SHARED_LIB "Build using shared libraries" ON)

PROJECT(vkvg VERSION 0.3.0 DESCRIPTION "Vulkan Vector Graphic")

ADD_COMPILE_DEFINITIONS(

"VKVG_VERSION_MAJOR=${vkvg_VERSION_MAJOR}"

"VKVG_VERSION_MINOR=${vkvg_VERSION_MINOR}"

"VKVG_VERSION_REVISION=${vkvg_VERSION_PATCH}"

)

INCLUDE(CheckSymbolExists)

INCLUDE(CheckIncludeFile)

INCLUDE(GNUInstallDirs)

INCLUDE(CMakeDependentOption)

SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")

IF(NOT CMAKE_BUILD_TYPE)

SET(CMAKE_BUILD_TYPE Release)

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)

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)

IF (UNIX)

SET(CMAKE_${LANG}_FLAGS "-rdynamic -Wall -Wno-extra -Wno-unknown-pragmas -Wno-missing-braces -Wno-unused-variable -Wno-switch")

ELSEIF(MSVC)

SET(CMAKE_${LANG}_FLAGS "/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_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")

ELSEIF(MSVC)

SET(CMAKE_${LANG}_FLAGS "${CMAKE_CXX_FLAGS} /O2 /TC /W0")

ENDIF()

ENDIF()

OPTION(ENABLE_PROFILING "compile with the -pg options..." OFF)

IF (ENABLE_PROFILING)

ADD_COMPILE_OPTIONS(

-pg -fno-reorder-functions -fno-inline

-O1

-fthread-jumps

-falign-functions -falign-jumps

-falign-loops -falign-labels)

ENDIF()

OPTION(VKVG_RECORDING "enable experimental recording functions" ON)

OPTION(VKVG_PREMULT_ALPHA "use premultiplied alpha for internal rendering" ON)

IF (VKVG_PREMULT_ALPHA)

ADD_DEFINITIONS (-DVKVG_PREMULT_ALPHA)

ENDIF ()

OPTION(VKVG_DBG_STATS "record contexts statistics in the device" OFF)

IF (VKVG_DBG_STATS)

ADD_DEFINITIONS (-DVKVG_DBG_STATS)

ENDIF ()

OPTION(VKVG_USE_GLUTESS "Fill non-zero with glu tesselator" ON)

CMAKE_DEPENDENT_OPTION(VKVG_SVG "render svg with vkvg-svg library" ON "UNIX" OFF)

INCLUDE ("${CMAKE_CURRENT_SOURCE_DIR}/cmake/GitSubmoduleUpdate.cmake")

IF(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")

OPTION(GIT_SUBMODULE "Check submodules during build" OFF)

IF(GIT_SUBMODULE)

updateGitSubmodule(vkh)

IF (VKVG_USE_GLUTESS)

updateGitSubmodule(external/glutess)

ENDIF ()

IF (VKVG_SVG)

updateGitSubmodule(external/vkvg-svg)

ENDIF ()

endif()

ENDIF ()

IF (NOT TARGET vkh)

ADD_SUBDIRECTORY (vkh)

ENDIF()

IF (ENABLE_VALIDATION)

ADD_DEFINITIONS (-DVKVG_USE_VALIDATION)

OPTION(ENABLE_RENDERDOC "enable renderdoc" OFF)

IF (ENABLE_RENDERDOC)

ADD_DEFINITIONS (-DVKVG_USE_RENDERDOC)

ENDIF ()

ENDIF ()

IF (ENABLE_WIRED_FILL)

ADD_DEFINITIONS (-DVKVG_WIRED_DEBUG)

ENDIF ()

FIND_PACKAGE(Vulkan REQUIRED)

FIND_PACKAGE(Freetype QUIET)

FIND_PACKAGE(Fontconfig QUIET)

FIND_PACKAGE(HarfBuzz QUIET)

FIND_PACKAGE(GLFW3 QUIET)

FIND_PACKAGE(Doxygen QUIET)

CMAKE_DEPENDENT_OPTION(VKVG_USE_FREETYPE "use freetype to load and render font glyphs" ON "Freetype_FOUND" OFF)

CMAKE_DEPENDENT_OPTION(VKVG_USE_FONTCONFIG "use FontConfig to resolve font names" ON "Fontconfig_FOUND" OFF)

CMAKE_DEPENDENT_OPTION(VKVG_USE_HARFBUZZ "use Harbuzz for text layouting" ON "HarfBuzz_FOUND" OFF)

CMAKE_DEPENDENT_OPTION(VKVG_BUILD_TESTS "build tests with glfw" ON "GLFW3_FOUND" OFF)

CMAKE_DEPENDENT_OPTION(VKVG_BUILD_DOCS "build documentation" OFF "DOXYGEN_FOUND" OFF)

CMAKE_DEPENDENT_OPTION(VKVG_LCD_FONT_FILTER "enable freetype lcd font filtering" OFF "VKVG_USE_FONTCONFIG" OFF)

OPTION(VKVG_VK_SCALAR_BLOCK_SUPPORTED "Enable scalar block layout support." ON)

IF (VKVG_VK_SCALAR_BLOCK_SUPPORTED)

ADD_DEFINITIONS (-DVKVG_VK_SCALAR_BLOCK_SUPPORTED)

SET(GLSLDEFS "-DVKVG_VK_SCALAR_BLOCK_SUPPORTED")

ENDIF ()

IF (ENABLE_DBG_UTILS)

ADD_DEFINITIONS (-DVKVG_DBG_UTILS)

ENDIF ()

IF (VKVG_USE_FREETYPE)

ADD_DEFINITIONS (-DVKVG_USE_FREETYPE)

ENDIF ()

IF (VKVG_USE_FONTCONFIG)

ADD_DEFINITIONS (-DVKVG_USE_FONTCONFIG)

ENDIF ()

IF (VKVG_USE_HARFBUZZ)

ADD_DEFINITIONS (-DVKVG_USE_HARFBUZZ)

ENDIF ()

IF (VKVG_LCD_FONT_FILTER)

ADD_DEFINITIONS (-DVKVG_LCD_FONT_FILTER)

ENDIF ()

IF(ANDROID)

FILE(GLOB glslc-folders ${ANDROID_NDK}/shader-tools/*)

ELSE()

FILE(GLOB glslc-folders ${VULKAN_SDK}/bin)

ENDIF()

FIND_PROGRAM(GLSLC glslc HINTS ${glslc-folders})

FIND_PROGRAM(XXD xxd)

IF(GLSLC AND XXD)

SET(SHADERS_H "${CMAKE_CURRENT_SOURCE_DIR}/src/shaders.h")

SET(SHADER_DIR "shaders")

SET(SHADER_FILES ${SHADER_DIR}/*.frag ${SHADER_DIR}/*.vert ${SHADER_DIR}/*.geom ${SHADER_DIR}/*.comp)

FILE(GLOB_RECURSE SHADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${SHADER_FILES})

FOREACH(SHADER ${SHADERS})

SET(shader-input ${CMAKE_CURRENT_SOURCE_DIR}/${SHADER})

SET(shader-output ${CMAKE_CURRENT_BINARY_DIR}/${SHADER}.spv)

ADD_CUSTOM_COMMAND (

OUTPUT ${shader-output}

COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/${SHADER_DIR}"

COMMAND ${GLSLC} ${GLSLDEFS} ${shader-input} -o ${shader-output}# --target-env=vulkan1.2

COMMENT "Compiling ${shader-input}"

DEPENDS ${SHADER}

VERBATIM

)

SET(SHADER_OUTPUTS ${SHADER_OUTPUTS} ${shader-output})

ENDFOREACH()

ADD_CUSTOM_TARGET(BuildShaders ALL DEPENDS ${SHADER_OUTPUTS})

ADD_CUSTOM_TARGET(ClearShadersHeader

COMMAND ${CMAKE_COMMAND} -E rm -f ${SHADERS_H}

)

ADD_CUSTOM_TARGET(BuildShadersHeader

DEPENDS ClearShadersHeader ${SHADER_OUTPUTS}

)

FOREACH(shad_spv ${SHADER_OUTPUTS})

GET_FILENAME_COMPONENT(SPV ${shad_spv} NAME)

ADD_CUSTOM_COMMAND (

TARGET BuildShadersHeader

WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${SHADER_DIR}

COMMAND ${XXD} -i ${SPV} >> ${SHADERS_H}

)

ENDFOREACH()

SET_SOURCE_FILES_PROPERTIES(${SHADERS_H} PROPERTIES GENERATED 1)

#add_definitions( -DDEBUG_VK_PERF=true )

ENDIF()

IF (VKVG_USE_GLUTESS)

ADD_DEFINITIONS (-DVKVG_FILL_NZ_GLUTESS)

ADD_SUBDIRECTORY (external/glutess)

ENDIF ()

FILE(GLOB VKVG_OBJ_SRC src/*.c src/deps/*.c)

SET (VKVG_PUBLIC_HEADERS "include/vkvg.h")

IF (VKVG_SVG)

ADD_DEFINITIONS (-DVKVG_SVG)

ADD_SUBDIRECTORY (external/vkvg-svg)

LIST (APPEND VKVG_SRC $<TARGET_OBJECTS:vkvg-svg>)

ELSE()

SET (VKVG_PUBLIC_HEADERS "${VKVG_PUBLIC_HEADERS};include/vkvg-svg.h")

FILE(GLOB NSVG_SRC src/nsvg/*.c)

LIST (APPEND VKVG_OBJ_SRC ${NSVG_SRC})

ENDIF()

IF (VKVG_RECORDING)

ADD_DEFINITIONS (-DVKVG_RECORDING)

FILE(GLOB RECORDING_SRC src/recording/*.c)

LIST (APPEND VKVG_OBJ_SRC ${RECORDING_SRC})

ENDIF()

CONFIGURE_FILE(vkvg.pc.in vkvg.pc @ONLY)

INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/vkvg.pc DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig)

FUNCTION (setup_lib LibName)

LIST (APPEND VKVG_TARGETS ${LibName})

SET_TARGET_PROPERTIES(${LibName} PROPERTIES

OUTPUT_NAME ${PROJECT_NAME}

VERSION ${vkvg_VERSION_MAJOR}.${vkvg_VERSION_MINOR}

SOVERSION ${vkvg_VERSION_MAJOR}

C_STANDARD 11

PUBLIC_HEADER "${VKVG_PUBLIC_HEADERS}"

)

TARGET_INCLUDE_DIRECTORIES("${LibName}"

PRIVATE

${CMAKE_CURRENT_SOURCE_DIR}/src

${CMAKE_CURRENT_SOURCE_DIR}/vkh/src

$<$<BOOL:${VKVG_USE_FREETYPE}>:${FREETYPE_INCLUDE_DIRS}>

$<$<BOOL:${VKVG_USE_HARFBUZZ}>:${HarfBuzz_INCLUDE_DIRS}>

$<$<BOOL:${VKVG_USE_FONTCONFIG}>:${Fontconfig_INCLUDE_DIRS}>

$<$<NOT:$<BOOL:${VKVG_SVG}>>:${CMAKE_CURRENT_SOURCE_DIR}/src/nsvg>

PUBLIC

${Vulkan_INCLUDE_DIRS}

${CMAKE_CURRENT_SOURCE_DIR}/include

${CMAKE_CURRENT_SOURCE_DIR}/vkh/include

)

get_target_property(libtype "${LibName}" TYPE)

IF (UNIX AND ($libtype STREQUAL "SHARED_LIBRARY"))

TARGET_LINK_LIBRARIES("${LibName}" PUBLIC "-lm")

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)

TARGET_LINK_LIBRARIES("${LibName}" PRIVATE glutess)

ENDIF()

TARGET_LINK_LIBRARIES("${LibName}"

PUBLIC

${Vulkan_LIBRARIES}

vkh

)

ENDFUNCTION(setup_lib)

GET_DIRECTORY_PROPERTY (vkvg_has_root_project PARENT_DIRECTORY)

ADD_LIBRARY("${PROJECT_NAME}_obj" OBJECT ${VKVG_OBJ_SRC} ${SHADERS} ${SHADERS_H})

TARGET_INCLUDE_DIRECTORIES("${PROJECT_NAME}_obj"

PRIVATE

${CMAKE_CURRENT_SOURCE_DIR}/src

${CMAKE_CURRENT_SOURCE_DIR}/vkh/src

$<$<BOOL:${VKVG_USE_FREETYPE}>:${FREETYPE_INCLUDE_DIRS}>

$<$<BOOL:${VKVG_USE_HARFBUZZ}>:${HarfBuzz_INCLUDE_DIRS}>

$<$<BOOL:${VKVG_USE_FONTCONFIG}>:${Fontconfig_INCLUDE_DIRS}>

$<$<NOT:$<BOOL:${VKVG_SVG}>>:${CMAKE_CURRENT_SOURCE_DIR}/src/nsvg>

$<$<BOOL:${VKVG_USE_GLUTESS}>:${CMAKE_CURRENT_SOURCE_DIR}/external/glutess/include>

PUBLIC

${Vulkan_INCLUDE_DIRS}

${CMAKE_CURRENT_SOURCE_DIR}/include

${CMAKE_CURRENT_SOURCE_DIR}/vkh/include

)

SET_PROPERTY(TARGET "${PROJECT_NAME}_obj" PROPERTY POSITION_INDEPENDENT_CODE ON)

IF (vkvg_has_root_project)

IF (VKVG_BUILD_SHARED_LIBS)

ADD_LIBRARY("${PROJECT_NAME}" SHARED ${VKVG_SRC} $<TARGET_OBJECTS:${PROJECT_NAME}_obj>)

SET_PROPERTY(TARGET "${PROJECT_NAME}" PROPERTY POSITION_INDEPENDENT_CODE ON)

SET_PROPERTY(TARGET vkh PROPERTY POSITION_INDEPENDENT_CODE ON)

TARGET_COMPILE_DEFINITIONS("${PROJECT_NAME}" PUBLIC -DVKVG_SHARED_BUILD)

IF (TARGET glutess)

SET_PROPERTY(TARGET glutess PROPERTY POSITION_INDEPENDENT_CODE ON)

ENDIF()

setup_lib ("${PROJECT_NAME}")

ELSE()

ADD_LIBRARY("${PROJECT_NAME}" STATIC ${VKVG_SRC} $<TARGET_OBJECTS:${PROJECT_NAME}_obj>)

SET_PROPERTY(TARGET "${PROJECT_NAME}" PROPERTY POSITION_INDEPENDENT_CODE OFF)

SET_PROPERTY(TARGET vkh PROPERTY POSITION_INDEPENDENT_CODE OFF)

IF (TARGET glutess)

SET_PROPERTY(TARGET glutess PROPERTY POSITION_INDEPENDENT_CODE OFF)

ENDIF()

setup_lib ("${PROJECT_NAME}")

ENDIF()

ELSE()

SET_PROPERTY(TARGET vkh PROPERTY POSITION_INDEPENDENT_CODE ON)

IF (TARGET glutess)

SET_PROPERTY(TARGET glutess PROPERTY POSITION_INDEPENDENT_CODE ON)

ENDIF()

ADD_LIBRARY("${PROJECT_NAME}_shared" SHARED ${VKVG_SRC} $<TARGET_OBJECTS:${PROJECT_NAME}_obj>)

SET_PROPERTY(TARGET "${PROJECT_NAME}_shared" PROPERTY POSITION_INDEPENDENT_CODE ON)

TARGET_COMPILE_DEFINITIONS("${PROJECT_NAME}_shared" PUBLIC -DVKVG_SHARED_BUILD)

setup_lib ("${PROJECT_NAME}_shared")

ADD_LIBRARY("${PROJECT_NAME}_static" STATIC ${VKVG_SRC} $<TARGET_OBJECTS:${PROJECT_NAME}_obj>)

target_compile_definitions("${PROJECT_NAME}_static" PUBLIC -DVKVG_STATIC_BUILD)

SET_PROPERTY(TARGET "${PROJECT_NAME}_static" PROPERTY POSITION_INDEPENDENT_CODE OFF)

setup_lib ("${PROJECT_NAME}_static")

INSTALL(TARGETS "${PROJECT_NAME}_shared" "${PROJECT_NAME}_static"

LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}

RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}

ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}

PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

IF (VKVG_BUILD_TESTS)

ADD_SUBDIRECTORY(tests)

ELSEIF (VKVG_BUILD_OFFSCREEN_TEST)

ADD_EXECUTABLE(test_offscreen "${CMAKE_CURRENT_SOURCE_DIR}/tests/offscreen.c")

TARGET_INCLUDE_DIRECTORIES(test_offscreen PRIVATE

${Vulkan_INCLUDE_DIRS}

${CMAKE_CURRENT_SOURCE_DIR}/include

)

TARGET_LINK_LIBRARIES(test_offscreen

${Vulkan_LIBRARIES}

)

IF (TARGET vkvg_static)

TARGET_LINK_LIBRARIES(${TEST_NAME} PUBLIC vkvg_static)

ELSEIF (TARGET vkvg_shared)

TARGET_LINK_LIBRARIES(${TEST_NAME} PUBLIC vkvg_shared)

ELSEIF (TARGET vkvg)

TARGET_LINK_LIBRARIES(${TEST_NAME} PUBLIC vkvg)

ENDIF()

ENDIF (VKVG_BUILD_TESTS)

IF (VKVG_BUILD_DOCS)

set(DOXYGEN_DIR ${CMAKE_CURRENT_SOURCE_DIR}/doc)

set(DOXYGEN_INPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")

set(DOXYGEN_IMAGE_DIR "${DOXYGEN_DIR}/images")

set(DOXYGEN_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/doc)

set(DOXYGEN_INDEX_FILE ${DOXYGEN_OUTPUT_DIR}/html/index.html)

set(DOXYFILE_IN ${DOXYGEN_DIR}/Doxygen.in)

set(DOXYFILE_OUT ${DOXYGEN_OUTPUT_DIR}/Doxyfile)

#configure_file(${DOXYGEN_DIR}/dox_layout.xml ${DOXYGEN_OUTPUT_DIR}/dox_layout.xml @ONLY)

configure_file(${DOXYFILE_IN} ${DOXYFILE_OUT} @ONLY)

add_custom_target(copy-doc-files ALL

COMMAND ${CMAKE_COMMAND} -E copy_directory "${DOXYGEN_DIR}/doxy_theme" ${DOXYGEN_OUTPUT_DIR})

add_custom_command(OUTPUT ${DOXYGEN_INDEX_FILE}

DEPENDS "${VKVG_PUBLIC_HEADERS}" copy-doc-files

COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYFILE_OUT}

MAIN_DEPENDENCY ${DOXYFILE_OUT} ${DOXYFILE_IN}

COMMENT "Generating docs")

add_custom_target(doxygen ALL DEPENDS ${DOXYGEN_INDEX_FILE})

find_package(Sphinx)

IF (Sphinx_FOUND)

set(SPHINX_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/doc)

set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR}/doc/sphinx)

set(SPHINX_INDEX_FILE ${SPHINX_BUILD}/index.html)

add_custom_command(OUTPUT ${SPHINX_INDEX_FILE}

COMMAND

${SPHINX_EXECUTABLE} -b html

-Dbreathe_projects.VKVG=${DOXYGEN_OUTPUT_DIR}/xml

${SPHINX_SOURCE} ${SPHINX_BUILD}

WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

DEPENDS

doxygen

# Other docs files you want to track should go here (or in some variable)

${SPHINX_SOURCE}/index.rst

${DOXYGEN_INDEX_FILE}

MAIN_DEPENDENCY ${SPHINX_SOURCE}/conf.py

COMMENT "Generating documentation with Sphinx")

add_custom_target(sphinx ALL DEPENDS ${SPHINX_INDEX_FILE})

ENDIF ()

ENDIF (VKVG_BUILD_DOCS)

IF(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")

SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})

SET(CPACK_PACKAGE_DESCRIPTION "Vulkan vector graphic library")

SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "2d vector drawing library using vulkan")

SET(CPACK_PACKAGE_VENDOR "jp Bruyere")

SET(CPACK_PACKAGE_CONTACT "jp_bruyere@hotmail.com")

SET(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")

SET(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")

SET(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")

SET(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")

SET(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")

SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md")

INCLUDE(InstallRequiredSystemLibraries)

#SET(CPACK_COMPONENTS_ALL Libraries ApplicationData)

#dependencies for this service menu

IF(UNIX)

SET(CPACK_PACKAGING_INSTALL_PREFIX "/tmp")

SET(CPACK_SET_DESTDIR "on")

SET(CPACK_ADD_LDCONFIG_CALL 1)

SET(CPACK_DEBIAN_PACKAGE_DEPENDS " libharfbuzz-gobject0 , libfontconfig1 , libfreetype6 ")

SET(CPACK_GENERATOR "DEB")

SET(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")

SET(CPACK_DEBIAN_PACKAGE_SECTION "libraries")

SET(CPACK_DEBIAN_ARCHITECTURE ${CMAKE_SYSTEM_PROCESSOR})

ELSEIF (MSVC)

SET(CPACK_GENERATOR NSIS)

SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY ${PROJECT_NAME})

SET(CPACK_NSIS_MODIFY_PATH "ON")

ENDIF ()

INCLUDE(CPack)

ENDIF(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")

ENDIF()

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 ()