path: root/CMakeLists.txt

CMAKE_MINIMUM_REQUIRED(VERSION 3.12)

SET(LANG "CXX")

#PROJECT(vkvg VERSION 0.1.1 DESCRIPTION "Vulkan Vector Graphic" LANGUAGES ${LANG})
PROJECT(vkvg VERSION 0.1.1 DESCRIPTION "Vulkan Vector Graphic")

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

IF (UNIX)
	SET(LINKER_FLAGS "-lm")
	SET(CMAKE_EXE_LINKER_FLAGS ${LINKER_FLAGS})
	SET(CMAKE_SHARED_LINKER_FLAGS ${LINKER_FLAGS})
ENDIF()

if (CMAKE_BUILD_TYPE STREQUAL "Debug")
	ADD_DEFINITIONS (-DDEBUG)
	OPTION(ENABLE_VALIDATION "enable vulkan validation layer" ON)
	OPTION(ENABLE_WIRED_FILL "enable wired polygon draw to check vertices and primitives" OFF)
	IF (UNIX)
		SET(CMAKE_${LANG}_FLAGS "-Wall -Wno-extra -Wno-unknown-pragmas -Wno-missing-braces -Wno-unused-variable")
	ELSEIF(MSVC)
		SET(CMAKE_${LANG}_FLAGS "/TC /W4 /wd4201 /wd4204 /wd4221 /wd4100")#c11 complient
	ENDIF()
ELSE()
	UNSET(ENABLE_VALIDATION CACHE)
	UNSET(ENABLE_WIRED_FILL CACHE)
	IF (UNIX)
		SET(CMAKE_${LANG}_FLAGS "-w")
	ELSEIF(MSVC)
		SET(CMAKE_${LANG}_FLAGS "/TC /W0")
	ENDIF()
ENDIF()
OPTION(VKVG_TEST_DIRECT_DRAW "(Experimental)Draw directly on backend surface, if off surface is blitted." OFF)
IF (VKVG_TEST_DIRECT_DRAW)
	ADD_DEFINITIONS (-DVKVG_TEST_DIRECT_DRAW)
ENDIF ()
OPTION(VKVG_PREMULT_ALPHA "use premultiplied alpha for internal rendering" ON)
IF (VKVG_PREMULT_ALPHA)
	ADD_DEFINITIONS (-DVKVG_PREMULT_ALPHA)
ENDIF ()

OPTION(VKVG_TILING_OPTIMAL "use VK_IMAGE_TILING_OPTIMAL for surface backend texture" OFF)
IF (VKVG_TILING_OPTIMAL)
	ADD_DEFINITIONS (-DVKVG_TILING_OPTIMAL)
ENDIF ()

set(VULKAN_SDK "$ENV{VULKAN_SDK}" CACHE STRING "LunarG Vulkan SDK path")
if (VULKAN_SDK)
	set(ENV{VULKAN_SDK} ${VULKAN_SDK})
	SET(vulkanSdkLayerPath "${VULKAN_SDK}/etc/vulkan/explicit_layer.d")
	IF (NOT EXISTS "${vulkanSdkLayerPath}")
		SET(vulkanSdkLayerPath "${VULKAN_SDK}/etc/explicit_layer.d")
	endif ()
	SET(ENV{VK_LAYER_PATH} "${vulkanSdkLayerPath}")
endif ()

if (NOT TARGET vkh_static)
	add_subdirectory (vkh)
endif()

#SET(ENABLE_VALIDATION OFF CACHE BOOL "Enable vulkan validation layer")

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 REQUIRED)
FIND_PACKAGE(Fontconfig REQUIRED)
FIND_PACKAGE(HarfBuzz REQUIRED)

FIND_PACKAGE(GLFW3)

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

#Freetype lcd font filtering
#CHECK_SYMBOL_EXISTS (FT_CONFIG_OPTION_SUBPIXEL_RENDERING "${FREETYPE_INCLUDE_DIR_freetype2}/freetype/config/ftoption.h" FT_HAS_SUBPIXEL_RENDERING)
#IF (FT_HAS_SUBPIXEL_RENDERING)
	IF (UNIX)
		OPTION(VKVG_LCD_FONT_FILTER "enable freetype lcd font filtering" ON)
	ELSEIF(MSVC)
		OPTION(VKVG_LCD_FONT_FILTER "enable freetype lcd font filtering" OFF)
	ENDIF()
	IF (VKVG_LCD_FONT_FILTER)
		ADD_DEFINITIONS (-DVKVG_LCD_FONT_FILTER)
	ENDIF ()
#ENDIF()

# Find glslc shader compiler.
# On Android, the NDK includes the binary, so no external dependency.
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} ${shader-input} -o ${shader-output}
		  COMMENT "Compiling ${shader-input}"
		  DEPENDS ${SHADER}
		  VERBATIM
		)
		SET(SHADER_OUTPUTS ${SHADER_OUTPUTS} ${shader-output})
	ENDFOREACH()

	ADD_CUSTOM_TARGET(BuildShaderHeader ALL DEPENDS ${SHADER_OUTPUTS})

	ADD_CUSTOM_COMMAND (TARGET BuildShaderHeader
		POST_BUILD
		COMMAND ${CMAKE_COMMAND} -E remove ${SHADERS_H}
		VERBATIM
	)

	FOREACH(shad_spv ${SHADER_OUTPUTS})
		GET_FILENAME_COMPONENT(SPV ${shad_spv} NAME)
		ADD_CUSTOM_COMMAND (TARGET BuildShaderHeader
			POST_BUILD
			WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${SHADER_DIR}
			COMMAND ${XXD} -i ${SPV} >> ${SHADERS_H}
			DEPENDS ${SHADERS_H}
		)
	ENDFOREACH()
	SET_SOURCE_FILES_PROPERTIES(${SHADERS_H} PROPERTIES GENERATED 1)
	#add_definitions( -DDEBUG_VK_PERF=true )
endif()

if (BuildShaderHeader)
	add_dependencies(${PROJECT_NAME} BuildShaderHeader)
endif ()

FILE(GLOB VKVG_SRC src/*.c)

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)
	SET_TARGET_PROPERTIES(${LibName} PROPERTIES
			OUTPUT_NAME ${PROJECT_NAME}
			VERSION ${PROJECT_VERSION}
			SOVERSION 1
			PUBLIC_HEADER include/vkvg.h
	)
	TARGET_INCLUDE_DIRECTORIES(${LibName} PRIVATE
		${Vulkan_INCLUDE_DIRS}
		${FREETYPE_INCLUDE_DIRS}
		${HarfBuzz_INCLUDE_DIRS}
		${Fontconfig_INCLUDE_DIRS}
		${CMAKE_CURRENT_SOURCE_DIR}/include
		${CMAKE_CURRENT_SOURCE_DIR}/src
		${CMAKE_CURRENT_SOURCE_DIR}/vkh/include
		${CMAKE_CURRENT_SOURCE_DIR}/vkh/src
	)
	TARGET_LINK_LIBRARIES(${LibName}
		${Vulkan_LIBRARIES}
		${FREETYPE_LIBRARIES}
		${HarfBuzz_LIBRARIES}
		${Fontconfig_LIBRARIES}
		vkh_static
	)
	INSTALL(TARGETS ${LibName}
		LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
		ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
		PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
ENDFUNCTION ()

ADD_LIBRARY("${PROJECT_NAME}_static" STATIC ${VKVG_SRC} ${SHADERS})
SET_PROPERTY(TARGET "${PROJECT_NAME}_static" PROPERTY POSITION_INDEPENDENT_CODE OFF)
setup_lib ("${PROJECT_NAME}_static")

ADD_LIBRARY("${PROJECT_NAME}_shared" SHARED ${VKVG_SRC} ${SHADERS})
SET_PROPERTY(TARGET "${PROJECT_NAME}_static" PROPERTY POSITION_INDEPENDENT_CODE ON)
setup_lib ("${PROJECT_NAME}_shared")

FUNCTION (buildtest TEST_NAME)
	ADD_EXECUTABLE(test_${TEST_NAME} "tests/${TEST_NAME}.c" )
	TARGET_INCLUDE_DIRECTORIES(test_${TEST_NAME} PRIVATE
		${Vulkan_INCLUDE_DIRS}
		${GLFW3_INCLUDE_DIR}
		${CMAKE_CURRENT_SOURCE_DIR}/include
		${CMAKE_CURRENT_SOURCE_DIR}/src
		${CMAKE_CURRENT_SOURCE_DIR}/tests/common
		${CMAKE_CURRENT_SOURCE_DIR}/vkh/include
		${CMAKE_CURRENT_SOURCE_DIR}/vkh/src
	)
	TARGET_LINK_LIBRARIES(test_${TEST_NAME}
		tests_common
	)
ENDFUNCTION (buildtest)

if (VKVG_BUILD_TESTS)
    ADD_LIBRARY("tests_common" STATIC tests/common/vkengine.c tests/common/test.c)
	TARGET_INCLUDE_DIRECTORIES(tests_common PRIVATE
		${Vulkan_INCLUDE_DIRS}
		${GLFW3_INCLUDE_DIR}
		${CMAKE_CURRENT_SOURCE_DIR}/include
		${CMAKE_CURRENT_SOURCE_DIR}/src
		${CMAKE_CURRENT_SOURCE_DIR}/tests/common
		${CMAKE_CURRENT_SOURCE_DIR}/vkh/include
		${CMAKE_CURRENT_SOURCE_DIR}/vkh/src
	)
    TARGET_LINK_LIBRARIES(tests_common
        ${Vulkan_LIBRARIES}
        ${GLFW3_LIBRARY}
        #vkh_static
        vkvg_static
    )

	file(GLOB_RECURSE DATAS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/tests" "tests/data/*")
	FOREACH(DATA_FILE ${DATAS})
		GET_FILENAME_COMPONENT(copy-dest-dir ${CMAKE_CURRENT_BINARY_DIR}/${DATA_FILE} DIRECTORY)
		SET(copy-output ${CMAKE_CURRENT_BINARY_DIR}/${DATA_FILE})
		ADD_CUSTOM_COMMAND(
		   OUTPUT  ${copy-output}
		   COMMAND ${CMAKE_COMMAND} -E make_directory ${copy-dest-dir}
		   COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_CURRENT_SOURCE_DIR}/tests/${DATA_FILE}" "${copy-output}"
		   COMMENT "Copying ${DATA_FILE} to ${copy-output}"
		   #DEPENDS ${DATA_FILE}
		   VERBATIM
		)
	ENDFOREACH()
	add_custom_target("${PROJECT_NAME}_DataCopy" ALL DEPENDS ${DATAS})

	#build test apps
	file(GLOB TESTS "tests/*.c")
	FOREACH(TEST ${TESTS})
		GET_FILENAME_COMPONENT(testname ${TEST} NAME_WE)
		buildtest(${testname})
	ENDFOREACH()
endif ()

MESSAGE(STATUS "HarfBuzz_INCLUDE_DIRS = ${HarfBuzz_INCLUDE_DIRS}")

MESSAGE(STATUS "\n\n--------------------------------------------------------------------------")
MESSAGE(STATUS "Build type\t\t= ${CMAKE_BUILD_TYPE}")
MESSAGE(STATUS "VULKAN_SDK\t\t= $ENV{VULKAN_SDK}")
MESSAGE(STATUS "VK_LAYER_PATH\t= $ENV{VK_LAYER_PATH}")
IF (VKVG_BUILD_TESTS)
MESSAGE(STATUS "Build tests\t\t= true.")
ELSE ()
MESSAGE(STATUS "Build tests\t\t= false.")
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_PREMULT_ALPHA)
MESSAGE(STATUS "Premult Alpha\t= enabled.")
ELSE ()
MESSAGE(STATUS "Premult Alpha\t= disabled.")
ENDIF ()
IF (VKVG_LCD_FONT_FILTER)
MESSAGE(STATUS "Font filtering\t= LCD.")
ELSE ()
MESSAGE(STATUS "Font filtering\t= Grayscale.")
ENDIF ()
MESSAGE(STATUS "---------------------------------------------------------------------------\n\n")

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

SET(CPACK_SET_DESTDIR "on")
SET(CPACK_PACKAGING_INSTALL_PREFIX "/tmp")
SET(CPACK_GENERATOR "DEB")

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}")

#dependencies for this service menu
SET(CPACK_DEBIAN_PACKAGE_DEPENDS " libharfbuzz-gobject0 , libfontconfig1 , libfreetype6 ")

SET(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
SET(CPACK_DEBIAN_PACKAGE_SECTION "libraries")
SET(CPACK_DEBIAN_ARCHITECTURE ${CMAKE_SYSTEM_PROCESSOR})

SET(CPACK_COMPONENTS_ALL Libraries ApplicationData)

INCLUDE(CPack)

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