Pantyhose-X
/
vengi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

CMAKE: split cmake scripts into own files

master
Martin Gerhardy 2018-10-20 21:37:19 +02:00
parent 6757fc386c
commit 42bdc762d4
19 changed files with 1143 additions and 849 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
CMakeLists.txt
View File

@ -1,12 +1,42 @@
cmake_minimum_required(VERSION 3.1)
project(vengi VERSION "0.0.1")
set(ROOT_PROJECT_VERSION 0.0.1)
set(ROOT_PROJECT_NAME vengi)
project(${ROOT_PROJECT_NAME} VERSION ${ROOT_PROJECT_VERSION})
set(ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE STRING "Root dir")
set(SCRIPTS_CMAKE_DIR ${PROJECT_SOURCE_DIR}/cmake)
set(GENERATE_DIR ${CMAKE_BINARY_DIR}/generated CACHE STRING "Generated code dir")
add_custom_target(codegen)
add_custom_target(update-libs)
include(CMakeParseArguments)
include(CheckCXXCompilerFlag)
include(CheckCCompilerFlag)
include(GNUInstallDirs)
if (CMAKE_COMPILER_IS_GNUCC)
set(USE_GCC TRUE)
elseif (CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID MATCHES "AppleClang" OR CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
set(USE_CLANG TRUE)
elseif (MSVC)
set(USE_MSVC TRUE)
endif()
include(${SCRIPTS_CMAKE_DIR}/common.cmake)
include(${SCRIPTS_CMAKE_DIR}/util.cmake)
include(${SCRIPTS_CMAKE_DIR}/genunity.cmake)
include(${SCRIPTS_CMAKE_DIR}/genshader.cmake)
include(${SCRIPTS_CMAKE_DIR}/gencomputeshader.cmake)
include(${SCRIPTS_CMAKE_DIR}/gendbmodel.cmake)
include(${SCRIPTS_CMAKE_DIR}/genprotocol.cmake)
include(${SCRIPTS_CMAKE_DIR}/externallib.cmake)
include(${SCRIPTS_CMAKE_DIR}/valgrind.cmake)
include(${SCRIPTS_CMAKE_DIR}/perf.cmake)
include(${SCRIPTS_CMAKE_DIR}/vogl.cmake)
include(${SCRIPTS_CMAKE_DIR}/debug.cmake)
include(${SCRIPTS_CMAKE_DIR}/googletest.cmake)
include(${SCRIPTS_CMAKE_DIR}/manifests.cmake)
include(${SCRIPTS_CMAKE_DIR}/lua.cmake)
include(${SCRIPTS_CMAKE_DIR}/ui.cmake)
include(${SCRIPTS_CMAKE_DIR}/macros.cmake)
include(${SCRIPTS_CMAKE_DIR}/pack.cmake)
include(CPack)

2
README.md
View File

@ -27,7 +27,7 @@ Voxel MMO RPG engine.
Some of these dependencies might not be available as packages in your toolchain - most of them are also bundled with the application. But local installed headers always have the higher priority.
## Debian
apt-get install libglm-dev libassimp-dev lua5.3 liblua5.3-dev libsdl2-dev postgresql-server-dev-10 libpq-dev libenet-dev libgtk-3-dev qt5-default qttools5-dev qttools5-dev-tools opencl-c-headers wayland-protocols
apt-get install libglm-dev libassimp-dev lua5.3 liblua5.3-dev libsdl2-dev postgresql-server-dev-10 libpq-dev libenet-dev libgtk-3-dev qt5-default qttools5-dev qttools5-dev-tools opencl-c-headers wayland-protocols pkg-config
If you want to run the database server locally, you have to install the postgres server package:

273
cmake/FindTensorFlow.cmake Normal file
View File

@ -0,0 +1,273 @@
# Patrick Wieschollek, <mail@patwie.com>
# FindTENSORFLOW.cmake
# https://github.com/PatWie/tensorflow-cmake/blob/master/cmake/modules/FindTensorFlow.cmake
# -------------
#
# Find TensorFlow library and includes
#
# Automatically set variables have prefix "TensorFlow",
# while variables you need to specify have prefix "TENSORFLOW"
# This module will set the following variables in your project:
#
# ``TensorFlow_VERSION``
# exact TensorFlow version obtained from runtime
# ``TensorFlow_ABI``
# ABI specification of TensorFlow library obtained from runtime
# ``TensorFlow_INCLUDE_DIR``
# where to find tensorflow header files obtained from runtime
# ``TensorFlow_LIBRARY``
# the libraries to link against to use TENSORFLOW obtained from runtime
# ``TensorFlow_FOUND TRUE``
# If false, do not try to use TENSORFLOW.
#
# for some examples, you will need to specify on of the following paths
# ``TensorFlow_SOURCE_DIR``
# Path to source of TensorFlow, when env-var 'TENSORFLOW_SOURCE_DIR' is set and path exists
# ``TensorFlow_C_LIBRARY``
# Path to libtensorflow_cc.so (require env-var 'TENSORFLOW_BUILD_DIR')
#
#
# USAGE
# ------
# add "list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}../../path/to/this/file)" to your project
#
# "add_tensorflow_gpu_operation" is a macro to compile a custom operation
#
# add_tensorflow_gpu_operation("<op-name>") expects the following files to exists:
# - kernels/<op-name>_kernel.cc
# - kernels/<op-name>_kernel_gpu.cu.cc (kernels/<op-name>_kernel.cu is supported as well)
# - kernels/<op-name>_op.cc
# - kernels/<op-name>_op.h
# - ops/<op-name>.cc
if(APPLE)
message(WARNING "This FindTensorflow.cmake is not tested on APPLE\n"
"Please report if this works\n"
"https://github.com/PatWie/tensorflow-cmake")
endif(APPLE)
if(WIN32)
message(WARNING "This FindTensorflow.cmake is not tested on WIN32\n"
"Please report if this works\n"
"https://github.com/PatWie/tensorflow-cmake")
endif(WIN32)
set(PYTHON_EXECUTABLE "python3" CACHE STRING "specify the python version TensorFlow is installed on.")
if(TensorFlow_FOUND)
# reuse cached variables
message(STATUS "Reuse cached information from TensorFlow ${TensorFlow_VERSION} ")
else()
message(STATUS "Detecting TensorFlow using ${PYTHON_EXECUTABLE}"
" (use -DPYTHON_EXECUTABLE=... otherwise)")
execute_process(
COMMAND ${PYTHON_EXECUTABLE} -c "import tensorflow as tf; print(tf.__version__); print(tf.__cxx11_abi_flag__); print(tf.sysconfig.get_include()); print(tf.sysconfig.get_lib() + '/libtensorflow_framework.so')"
OUTPUT_VARIABLE TF_INFORMATION_STRING
OUTPUT_STRIP_TRAILING_WHITESPACE
RESULT_VARIABLE retcode)
if(NOT "${retcode}" STREQUAL "0")
message(FATAL_ERROR "Detecting TensorFlow info - failed \n Did you installed TensorFlow?")
else()
message(STATUS "Detecting TensorFlow info - done")
endif()
string(REPLACE "\n" ";" TF_INFORMATION_LIST ${TF_INFORMATION_STRING})
list(GET TF_INFORMATION_LIST 0 TF_DETECTED_VERSION)
list(GET TF_INFORMATION_LIST 1 TF_DETECTED_ABI)
list(GET TF_INFORMATION_LIST 2 TF_DETECTED_INCLUDE_DIR)
list(GET TF_INFORMATION_LIST 3 TF_DETECTED_LIBRARY)
# set(TF_DETECTED_VERSION 1.8)
set(_packageName "TF")
if (DEFINED TF_DETECTED_VERSION)
string (REGEX MATCHALL "[0-9]+" _versionComponents "${TF_DETECTED_VERSION}")
list (LENGTH _versionComponents _len)
if (${_len} GREATER 0)
list(GET _versionComponents 0 TF_DETECTED_VERSION_MAJOR)
endif()
if (${_len} GREATER 1)
list(GET _versionComponents 1 TF_DETECTED_VERSION_MINOR)
endif()
if (${_len} GREATER 2)
list(GET _versionComponents 2 TF_DETECTED_VERSION_PATCH)
endif()
if (${_len} GREATER 3)
list(GET _versionComponents 3 TF_DETECTED_VERSION_TWEAK)
endif()
set (TF_DETECTED_VERSION_COUNT ${_len})
else()
set (TF_DETECTED_VERSION_COUNT 0)
endif()
# -- prevent pre 1.9 versions
# Note: TensorFlow 1.7 supported custom ops and all header files.
# TensorFlow 1.8 broke that promise and 1.9, 1.10 are fine again.
# This cmake-file is only tested against 1.9+.
if("${TF_DETECTED_VERSION}" VERSION_LESS "1.9")
message(FATAL_ERROR "Your installed TensorFlow version ${TF_DETECTED_VERSION} is too old.")
endif()
if(TF_FIND_VERSION_EXACT)
# User requested exact match of TensorFlow.
# TensorFlow release cycles are currently just depending on (major, minor)
# But we test against both.
set(_TensorFlow_TEST_VERSIONS
"${TF_FIND_VERSION_MAJOR}.${TF_FIND_VERSION_MINOR}.${TF_FIND_VERSION_PATCH}"
"${TF_FIND_VERSION_MAJOR}.${TF_FIND_VERSION_MINOR}")
else(TF_FIND_VERSION_EXACT)
# User requested not an exact TensorFlow version.
# However, only TensorFlow versions 1.9, 1.10 support all header files
# for custom ops.
set(_TensorFlow_KNOWN_VERSIONS ${TensorFlow_ADDITIONAL_VERSIONS}
"1.9" "1.9.0" "1.10" "1.10.0" "1.11" "1.11.0")
set(_TensorFlow_TEST_VERSIONS)
if(TF_FIND_VERSION)
set(_TF_FIND_VERSION_SHORT "${TF_FIND_VERSION_MAJOR}.${TF_FIND_VERSION_MINOR}")
# Select acceptable versions.
foreach(version ${_TensorFlow_KNOWN_VERSIONS})
if(NOT "${version}" VERSION_LESS "${TF_FIND_VERSION}")
# This version is high enough.
list(APPEND _TensorFlow_TEST_VERSIONS "${version}")
endif()
endforeach(version)
else(TF_FIND_VERSION)
# Any version is acceptable.
set(_TensorFlow_TEST_VERSIONS "${_TensorFlow_KNOWN_VERSIONS}")
endif(TF_FIND_VERSION)
endif()
# test all given versions
set(TensorFlow_FOUND FALSE)
FOREACH(_TensorFlow_VER ${_TensorFlow_TEST_VERSIONS})
if("${TF_DETECTED_VERSION_MAJOR}.${TF_DETECTED_VERSION_MINOR}" STREQUAL "${_TensorFlow_VER}")
# found appropriate version
set(TensorFlow_VERSION ${TF_DETECTED_VERSION})
set(TensorFlow_ABI ${TF_DETECTED_ABI})
set(TensorFlow_INCLUDE_DIR ${TF_DETECTED_INCLUDE_DIR})
set(TensorFlow_LIBRARY ${TF_DETECTED_LIBRARY})
set(TensorFlow_FOUND TRUE)
message(STATUS "Found TensorFlow: (found appropriate version \"${TensorFlow_VERSION}\")")
message(STATUS "TensorFlow-ABI is ${TensorFlow_ABI}")
message(STATUS "TensorFlow-INCLUDE_DIR is ${TensorFlow_INCLUDE_DIR}")
message(STATUS "TensorFlow-LIBRARY is ${TensorFlow_LIBRARY}")
add_definitions("-DTENSORFLOW_ABI=${TensorFlow_ABI}")
add_definitions("-DTENSORFLOW_VERSION=${TensorFlow_VERSION}")
break()
endif()
ENDFOREACH(_TensorFlow_VER)
if(NOT TensorFlow_FOUND)
message(FATAL_ERROR "Your installed TensorFlow version ${TF_DETECTED_VERSION_MAJOR}.${TF_DETECTED_VERSION_MINOR} is not supported\n"
"We tested against ${_TensorFlow_TEST_VERSIONS}")
endif(NOT TensorFlow_FOUND)
endif()
find_library(TensorFlow_C_LIBRARY
NAMES libtensorflow_cc.so
PATHS $ENV{TENSORFLOW_BUILD_DIR}
DOC "TensorFlow CC library." )
if(TensorFlow_C_LIBRARY)
message(STATUS "TensorFlow-CC-LIBRARY is ${TensorFlow_C_LIBRARY}")
else()
message(STATUS "No TensorFlow-CC-LIBRARY detected")
endif()
find_path(TensorFlow_SOURCE_DIR
NAMES
tensorflow/c
tensorflow/cc
tensorflow/core
tensorflow/core/framework
tensorflow/core/platform
tensorflow/python
third_party
PATHS $ENV{TENSORFLOW_SOURCE_DIR})
if(TensorFlow_SOURCE_DIR)
message(STATUS "TensorFlow-SOURCE-DIRECTORY is ${TensorFlow_SOURCE_DIR}")
else()
message(STATUS "No TensorFlow source repository detected")
endif()
macro(TensorFlow_REQUIRE_C_LIBRARY)
if(TensorFlow_C_LIBRARY)
else()
message(FATAL_ERROR "Project requires libtensorflow_cc.so, please specify the path in ENV-VAR 'TENSORFLOW_BUILD_DIR'")
endif()
endmacro()
macro(TensorFlow_REQUIRE_SOURCE)
if(TensorFlow_SOURCE_DIR)
else()
message(FATAL_ERROR "Project requires TensorFlow source directory, please specify the path in ENV-VAR 'TENSORFLOW_SOURCE_DIR'")
endif()
endmacro()
macro(add_tensorflow_cpu_operation op_name)
# Compiles a CPU-only operation without invoking NVCC
message(STATUS "will build custom TensorFlow operation \"${op_name}\" (CPU only)")
add_library(${op_name}_op SHARED kernels/${op_name}_op.cc kernels/${op_name}_kernel.cc ops/${op_name}.cc )
set_target_properties(${op_name}_op PROPERTIES PREFIX "")
target_link_libraries(${op_name}_op LINK_PUBLIC ${TensorFlow_LIBRARY})
endmacro()
macro(add_tensorflow_gpu_operation op_name)
# Compiles a CPU + GPU operation with invoking NVCC
message(STATUS "will build custom TensorFlow operation \"${op_name}\" (CPU+GPU)")
set(kernel_file "")
if(EXISTS "kernels/${op_name}_kernel.cu")
message(WARNING "you should rename your file ${op_name}_kernel.cu to ${op_name}_kernel_gpu.cu.cc")
set(kernel_file kernels/${op_name}_kernel.cu)
else()
set_source_files_properties(kernels/${op_name}_kernel_gpu.cu.cc PROPERTIES CUDA_SOURCE_PROPERTY_FORMAT OBJ)
set(kernel_file kernels/${op_name}_kernel_gpu.cu.cc)
endif()
cuda_add_library(${op_name}_op_cu SHARED ${kernel_file})
set_target_properties(${op_name}_op_cu PROPERTIES PREFIX "")
add_library(${op_name}_op SHARED kernels/${op_name}_op.cc kernels/${op_name}_kernel.cc ops/${op_name}.cc )
set_target_properties(${op_name}_op PROPERTIES PREFIX "")
set_target_properties(${op_name}_op PROPERTIES COMPILE_FLAGS "-DGOOGLE_CUDA")
target_link_libraries(${op_name}_op LINK_PUBLIC ${op_name}_op_cu ${TensorFlow_LIBRARY})
endmacro()
# simplify TensorFlow dependencies
add_library(TensorFlow_DEP INTERFACE)
TARGET_INCLUDE_DIRECTORIES(TensorFlow_DEP INTERFACE ${TensorFlow_SOURCE_DIR})
TARGET_INCLUDE_DIRECTORIES(TensorFlow_DEP INTERFACE ${TensorFlow_INCLUDE_DIR})
TARGET_LINK_LIBRARIES(TensorFlow_DEP INTERFACE -Wl,--allow-multiple-definition -Wl,--whole-archive ${TensorFlow_C_LIBRARY} -Wl,--no-whole-archive)
TARGET_LINK_LIBRARIES(TensorFlow_DEP INTERFACE -Wl,--allow-multiple-definition -Wl,--whole-archive ${TensorFlow_LIBRARY} -Wl,--no-whole-archive)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(
TENSORFLOW
FOUND_VAR TENSORFLOW_FOUND
REQUIRED_VARS
TensorFlow_LIBRARY
TensorFlow_INCLUDE_DIR
VERSION_VAR
TensorFlow_VERSION
)
mark_as_advanced(TF_INFORMATION_STRING TF_DETECTED_VERSION TF_DETECTED_VERSION_MAJOR TF_DETECTED_VERSION_MINOR TF_DETECTED_VERSION TF_DETECTED_ABI
TF_DETECTED_INCLUDE_DIR TF_DETECTED_LIBRARY
TensorFlow_C_LIBRARY TensorFlow_LIBRARY TensorFlow_SOURCE_DIR TensorFlow_INCLUDE_DIR TensorFlow_ABI)
SET(TensorFlow_INCLUDE_DIR ${TensorFlow_INCLUDE_DIR} CACHE PATH "path to tensorflow header files")
SET(TensorFlow_VERSION ${TensorFlow_VERSION} CACHE INTERNAL "The Python executable Version")
SET(TensorFlow_ABI ${TensorFlow_ABI} CACHE STRING "The Python executable Version")
SET(TensorFlow_LIBRARY ${TensorFlow_LIBRARY} CACHE PATH "The Python executable Version")
SET(TensorFlow_FOUND ${TensorFlow_FOUND} CACHE BOOL "The Python executable Version")

20
cmake/debug.cmake Normal file
View File

@ -0,0 +1,20 @@
macro(engine_add_debuggger TARGET)
add_custom_target(${TARGET}-debug)
if (${DEBUGGER} STREQUAL "gdb")
add_custom_command(TARGET ${TARGET}-debug
COMMAND ${GDB_EXECUTABLE} -ex run --args $<TARGET_FILE:${TARGET}>
COMMENT "Starting debugger session for ${TARGET}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
elseif (${DEBUGGER} STREQUAL "lldb")
add_custom_command(TARGET ${TARGET}-debug
COMMAND ${LLDB_EXECUTABLE} -b -o run $<TARGET_FILE:${TARGET}>
COMMENT "Starting debugger session for ${TARGET}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
else()
message(WARN "Unknown DEBUGGER value - set to gdb or lldb")
endif()
endmacro()

213
cmake/externallib.cmake Normal file
View File

@ -0,0 +1,213 @@
set(LIBS_DIR ${PROJECT_SOURCE_DIR}/contrib/libs)
macro(var_global VARIABLES)
foreach(VAR ${VARIABLES})
set(${VAR} ${${VAR}} CACHE STRING "" FORCE)
mark_as_advanced(${VAR})
endforeach()
endmacro()
#
# macro for the FindLibName.cmake files.
#
# parameters:
# LIB: the library we are trying to find
# HEADER: the header we are trying to find
# SUFFIX: suffix for the include dir
# VERSION: the operator and version that is given to the pkg-config call (e.g. ">=1.0")
# (this only works for pkg-config)
#
# Example: engine_find(SDL2_image SDL_image.h SDL2 "")
#
macro(engine_find LIB HEADER SUFFIX VERSION)
string(TOUPPER ${LIB} PREFIX)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(_PROCESSOR_ARCH "x64")
else()
set(_PROCESSOR_ARCH "x86")
endif()
set(_SEARCH_PATHS
~/Library/Frameworks
/Library/Frameworks
/usr/local
/usr
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
$ENV{VCPKG_ROOT}/installed/${_PROCESSOR_ARCH}-windows
C:/Tools/vcpkg/installed/${_PROCESSOR_ARCH}-windows
C:/vcpkg/installed/${_PROCESSOR_ARCH}-windows
)
find_package(PkgConfig QUIET)
if (PKG_CONFIG_FOUND)
pkg_check_modules(_${PREFIX} "${LIB}${VERSION}")
endif()
find_path(${PREFIX}_INCLUDE_DIRS
NAMES ${HEADER}
HINTS ENV ${PREFIX}DIR
PATH_SUFFIXES include include/${SUFFIX} ${SUFFIX}
PATHS
${_${PREFIX}_INCLUDE_DIRS}
${_SEARCH_PATHS}
)
find_library(${PREFIX}_LIBRARIES
NAMES ${LIB} ${PREFIX} ${_${PREFIX}_LIBRARIES}
HINTS ENV ${PREFIX}DIR
PATH_SUFFIXES lib64 lib lib/${_PROCESSOR_ARCH}
PATHS
${_${PREFIX}_LIBRARY_DIRS}
${_SEARCH_PATHS}
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(${LIB} FOUND_VAR ${PREFIX}_FOUND REQUIRED_VARS ${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARIES)
mark_as_advanced(${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARIES ${PREFIX}_FOUND)
var_global(${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARIES ${PREFIX}_FOUND)
unset(PREFIX)
unset(_SEARCH_PATHS)
unset(_PROCESSOR_ARCH)
endmacro()
macro(engine_find_header_only LIB HEADER SUFFIX VERSION)
string(TOUPPER ${LIB} PREFIX)
set(_SEARCH_PATHS
~/Library/Frameworks
/Library/Frameworks
/usr/local
/usr
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
)
find_package(PkgConfig QUIET)
if (PKG_CONFIG_FOUND)
pkg_check_modules(_${PREFIX} "${LIB}${VERSION}")
endif()
find_path(${PREFIX}_INCLUDE_DIRS
NAMES ${HEADER}
HINTS ENV ${PREFIX}DIR
PATH_SUFFIXES include include/${SUFFIX} ${SUFFIX}
PATHS
${_${PREFIX}_INCLUDE_DIRS}
${_SEARCH_PATHS}
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(${LIB} FOUND_VAR ${PREFIX}_FOUND REQUIRED_VARS ${PREFIX}_INCLUDE_DIRS)
mark_as_advanced(${PREFIX}_INCLUDE_DIRS ${PREFIX}_FOUND)
var_global(${PREFIX}_INCLUDE_DIRS ${PREFIX}_FOUND)
unset(PREFIX)
unset(_SEARCH_PATHS)
endmacro()
#
# Add external dependency. It will trigger a find_package and use the system wide install if found
#
# parameters:
# PUBLICHEADER: optional
# LIB: the name of the lib. Must match the FindXXX.cmake module and the pkg-config name of the lib
# GCCCFLAGS: optional
# GCCLINKERFLAGS: optional
# SRCS: the list of source files for the bundled lib
# DEFINES: a list of defines (without -D or /D)
#
macro(engine_add_library)
set(_OPTIONS_ARGS UNITY)
set(_ONE_VALUE_ARGS LIB PACKAGE GCCCFLAGS LINKERFLAGS PUBLICHEADER)
set(_MULTI_VALUE_ARGS SRCS DEFINES)
cmake_parse_arguments(_ADDLIB "${_OPTIONS_ARGS}" "${_ONE_VALUE_ARGS}" "${_MULTI_VALUE_ARGS}" ${ARGN} )
if (NOT _ADDLIB_LIB)
message(FATAL_ERROR "engine_add_library requires the LIB argument")
endif()
if (NOT _ADDLIB_SRCS)
message(FATAL_ERROR "engine_add_library requires the SRCS argument")
endif()
if (NOT _ADDLIB_PUBLICHEADER)
set(_ADDLIB_PUBLICHEADER PUBLIC)
endif()
if (_ADDLIB_FIND_PACKAGE)
set(FIND_PACKAGE_NAME ${_ADDLIB_FIND_PACKAGE})
else()
set(FIND_PACKAGE_NAME ${_ADDLIB_LIB})
endif()
string(TOUPPER ${_ADDLIB_LIB} PREFIX)
if (NOT ${PREFIX}_LOCAL)
find_package(${FIND_PACKAGE_NAME})
endif()
# now convert it again - looks like find_package exports PREFIX in some versions of cmake, too
string(TOUPPER ${_ADDLIB_LIB} PREFIX)
string(TOUPPER ${FIND_PACKAGE_NAME} PKG_PREFIX)
if (NOT ${PREFIX} STREQUAL ${PKG_PREFIX})
if (${PKG_PREFIX}_INCLUDE_DIRS)
set(${PREFIX}_INCLUDE_DIRS ${PKG_PREFIX}_INCLUDE_DIRS)
else()
set(${PREFIX}_INCLUDE_DIRS ${PKG_PREFIX}_INCLUDE_DIR)
endif()
if (${PREFIX}_LIBRARIES ${PKG_PREFIX}_LIBRARIES)
set(${PREFIX}_LIBRARIES ${PKG_PREFIX}_LIBRARIES)
else()
set(${PREFIX}_LIBRARIES ${PKG_PREFIX}_LIBRARY)
endif()
set(${PREFIX}_FOUND ${PKG_PREFIX}_FOUND)
message(STATUS "find_package ${FIND_PACKAGE_NAME} for ${_ADDLIB_LIB}")
endif()
var_global(${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARIES ${PREFIX}_FOUND)
if (${PREFIX}_FOUND)
add_library(${_ADDLIB_LIB} INTERFACE)
set(LIBS ${${PREFIX}_LIBRARIES})
if (LIBS)
# Remove leading spaces
string(REGEX REPLACE "^[ \t\r\n]+" "" LIBS "${LIBS}" )
# Remove trailing spaces
string(REGEX REPLACE "(\ )+$" "" LIBS ${LIBS})
target_link_libraries(${_ADDLIB_LIB} INTERFACE ${LIBS})
endif()
if (${PREFIX}_INCLUDE_DIRS)
set_property(TARGET ${_ADDLIB_LIB} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${${PREFIX}_INCLUDE_DIRS})
endif()
else()
message(STATUS "Use the bundled lib ${_ADDLIB_LIB}")
if (_ADDLIB_UNITY)
set(UNITY_SRC_CPP ${CMAKE_CURRENT_BINARY_DIR}/${_ADDLIB_LIB}_unity.cpp)
file(WRITE ${UNITY_SRC_CPP}.in "/** autogenerated */\n")
set(UNITY_SRC_C ${CMAKE_CURRENT_BINARY_DIR}/${_ADDLIB_LIB}_unity.c)
file(WRITE ${UNITY_SRC_C}.in "/** autogenerated */\n")
set(unity_srcs)
list(APPEND unity_srcs ${UNITY_SRC_CPP} ${UNITY_SRC_C})
foreach(SRC ${_ADDLIB_SRCS})
get_filename_component(extension ${SRC} EXT)
if ("${extension}" STREQUAL ".cpp")
file(APPEND ${UNITY_SRC_CPP}.in "#include \"${SRC}\"\n")
continue()
endif()
if ("${extension}" STREQUAL ".c")
file(APPEND ${UNITY_SRC_C}.in "#include \"${SRC}\"\n")
continue()
endif()
list(APPEND unity_srcs ${SRC})
endforeach()
configure_file(${UNITY_SRC_CPP}.in ${UNITY_SRC_CPP})
configure_file(${UNITY_SRC_C}.in ${UNITY_SRC_C})
add_library(${_ADDLIB_LIB} STATIC ${unity_srcs})
else()
add_library(${_ADDLIB_LIB} STATIC ${_ADDLIB_SRCS})
endif()
target_include_directories(${_ADDLIB_LIB} ${_ADDLIB_PUBLICHEADER} ${LIBS_DIR}/${_ADDLIB_LIB})
set_target_properties(${_ADDLIB_LIB} PROPERTIES COMPILE_DEFINITIONS "${_ADDLIB_DEFINES}")
if (USE_GCC OR USE_CLANG)
message(STATUS "additional lib cflags: ${_ADDLIB_GCCCFLAGS}")
if(UNIX)
set_target_properties(${_ADDLIB_LIB} PROPERTIES COMPILE_FLAGS "${_ADDLIB_GCCCFLAGS} -fPIC")
else()
set_target_properties(${_ADDLIB_LIB} PROPERTIES COMPILE_FLAGS "${_ADDLIB_GCCCFLAGS}")
endif()
set_target_properties(${_ADDLIB_LIB} PROPERTIES LINK_FLAGS "${_ADDLIB_GCCLINKERFLAGS}")
endif()
set_target_properties(${_ADDLIB_LIB} PROPERTIES FOLDER ${_ADDLIB_LIB})
endif()
endmacro()

77
cmake/gencomputeshader.cmake Normal file
View File

@ -0,0 +1,77 @@
macro(generate_compute_shaders TARGET)
set(files ${ARGV})
list(REMOVE_AT files 0)
set(GEN_DIR ${GENERATE_DIR}/compute-shaders/${TARGET}/)
set(_template ${ROOT_DIR}/src/tools/computeshadertool/ComputeShaderTemplate.h.in)
file(MAKE_DIRECTORY ${GEN_DIR})
target_include_directories(${TARGET} PUBLIC ${GEN_DIR})
set(_headers)
add_custom_target(UpdateComputeShaders${TARGET})
file(WRITE ${CMAKE_BINARY_DIR}/GenerateComputeShaderHeader${TARGET}.cmake "configure_file(\${SRC} \${DST} @ONLY)")
if (NOT DEFINED compute_SOURCE_DIR)
message(FATAL_ERROR "compute project not found")
endif()
set(SHADERTOOL_INCLUDE_DIRS)
list(APPEND SHADERTOOL_INCLUDE_DIRS "${compute_SOURCE_DIR}/shaders")
get_property(DEPENDENCIES GLOBAL PROPERTY ${TARGET}_DEPENDENCIES)
foreach (D ${DEPENDENCIES})
if (NOT DEFINED ${D}_SOURCE_DIR)
continue()
endif()
if (EXISTS ${${D}_SOURCE_DIR}/shaders)
list(APPEND SHADERTOOL_INCLUDE_DIRS "${${D}_SOURCE_DIR}/shaders")
endif()
endforeach()
list(REMOVE_DUPLICATES SHADERTOOL_INCLUDE_DIRS)
set(SHADERTOOL_INCLUDE_DIRS_PARAM)
foreach (IDIR ${SHADERTOOL_INCLUDE_DIRS})
list(APPEND SHADERTOOL_INCLUDE_DIRS_PARAM "-I")
list(APPEND SHADERTOOL_INCLUDE_DIRS_PARAM "${IDIR}")
endforeach()
foreach (_file ${files})
set(_shaders)
set(_dir ${CMAKE_CURRENT_SOURCE_DIR}/shaders)
if (EXISTS ${_dir}/${_file}.cl)
list(APPEND _shaders ${_dir}/${_file}.cl)
endif()
if (_shaders)
convert_to_camel_case(${_file} _f)
set(_shaderfile "${_f}Shader.h")
set(_shader "${GEN_DIR}${_shaderfile}")
# TODO We have to add the shader/ dirs of all dependencies to the include path
add_custom_command(
OUTPUT ${_shader}.in
IMPLICIT_DEPENDS C ${_shaders}
COMMENT "Validate ${_file} and generate ${_shaderfile}"
COMMAND $<TARGET_FILE:computeshadertool> --shader ${_dir}/${_file} -I ${_dir} ${SHADERTOOL_INCLUDE_DIRS_PARAM} --postfix .in --shadertemplate ${_template} --sourcedir ${GEN_DIR}
DEPENDS computeshadertool ${_shaders} ${_template}
VERBATIM
)
list(APPEND _headers ${_shader})
add_custom_command(
OUTPUT ${_shader}
COMMAND ${CMAKE_COMMAND} -D SRC=${_shader}.in -D DST=${_shader} -P ${CMAKE_BINARY_DIR}/GenerateComputeShaderHeader${TARGET}.cmake
DEPENDS ${_shader}.in
)
else()
message(FATAL_ERROR "Could not find any shader files for ${_file} and target '${TARGET}'")
endif()
endforeach()
convert_to_camel_case(${TARGET} _filetarget)
set(_h ${GEN_DIR}/${_filetarget}ComputeShaders.h)
file(WRITE ${_h}.in "#pragma once\n")
foreach (header_path ${_headers})
string(REPLACE "${GEN_DIR}" "" header "${header_path}")
file(APPEND ${_h}.in "#include \"${header}\"\n")
endforeach()
add_custom_target(GenerateComputeShaderBindings${TARGET}
DEPENDS ${_headers}
COMMENT "Generate shader bindings for ${TARGET} in ${GEN_DIR}"
)
engine_mark_as_generated(${_headers} ${_h})
add_custom_target(GenerateComputeShaderHeader${TARGET} ${CMAKE_COMMAND} -D SRC=${_h}.in -D DST=${_h} -P ${CMAKE_BINARY_DIR}/GenerateComputeShaderHeader${TARGET}.cmake)
add_dependencies(${TARGET} GenerateComputeShaderHeader${TARGET} UpdateComputeShaders${TARGET})
add_dependencies(GenerateComputeShaderHeader${TARGET} GenerateComputeShaderBindings${TARGET})
add_dependencies(codegen GenerateComputeShaderHeader${TARGET} UpdateComputeShaders${TARGET})
endmacro()

19
cmake/gendbmodel.cmake Normal file
View File

@ -0,0 +1,19 @@
macro(generate_db_models TARGET INPUT OUTPUT)
set(GEN_DIR ${GENERATE_DIR}/dbmodels/${TARGET}/)
file(MAKE_DIRECTORY ${GEN_DIR})
target_include_directories(${TARGET} PUBLIC ${GEN_DIR})
add_custom_command(
OUTPUT ${GEN_DIR}${OUTPUT}
COMMENT "Generate ${OUTPUT}"
COMMAND $<TARGET_FILE:databasetool> --tablefile ${INPUT} --outfile ${GEN_DIR}${OUTPUT}
DEPENDS databasetool ${INPUT}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
add_custom_target(GenerateDatabaseModelBindings${TARGET}
DEPENDS ${GEN_DIR}${OUTPUT}
COMMENT "Generate database model bindings for ${TARGET} in ${GEN_DIR}"
)
engine_mark_as_generated(${GEN_DIR}${OUTPUT})
add_dependencies(${TARGET} GenerateDatabaseModelBindings${TARGET})
add_dependencies(codegen GenerateDatabaseModelBindings${TARGET})
endmacro()

29
cmake/genprotocol.cmake Normal file
View File

@ -0,0 +1,29 @@
macro(generate_protocol TARGET)
set(files ${ARGV})
list(REMOVE_AT files 0)
set(GEN_DIR ${GENERATE_DIR}/protocol/${TARGET}/)
file(MAKE_DIRECTORY ${GEN_DIR})
target_include_directories(${TARGET} PUBLIC ${GEN_DIR})
set(_headers)
foreach (_file ${files})
get_filename_component(_basefilename ${_file} NAME_WE)
set(HEADER "${_basefilename}_generated.h")
set(DEFINITION ${_file})
list(APPEND _headers ${GEN_DIR}${HEADER})
add_custom_command(
OUTPUT ${GEN_DIR}${HEADER}
COMMAND $<TARGET_FILE:flatc> -c -I ${CMAKE_CURRENT_SOURCE_DIR}/../attrib/definitions --scoped-enums -o ${GEN_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/definitions/${DEFINITION}
DEPENDS flatc ${CMAKE_CURRENT_SOURCE_DIR}/definitions/${DEFINITION}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Generating source code for ${DEFINITION}"
)
engine_mark_as_generated(${GEN_DIR}/${HEADER})
endforeach()
add_custom_target(GenerateNetworkMessages${TARGET}
DEPENDS ${_headers}
COMMENT "Generate network messages in ${GEN_DIR}"
)
add_dependencies(${TARGET} GenerateNetworkMessages${TARGET})
add_dependencies(codegen GenerateNetworkMessages${TARGET})
endmacro()

94
cmake/genshader.cmake Normal file
View File

@ -0,0 +1,94 @@
macro(generate_shaders TARGET)
set(files ${ARGV})
list(REMOVE_AT files 0)
set(GEN_DIR ${GENERATE_DIR}/shaders/${TARGET}/)
set(_template_header ${ROOT_DIR}/src/tools/shadertool/ShaderTemplate.h.in)
set(_template_cpp ${ROOT_DIR}/src/tools/shadertool/ShaderTemplate.cpp.in)
set(_template_ub ${ROOT_DIR}/src/tools/shadertool/UniformBufferTemplate.h.in)
file(MAKE_DIRECTORY ${GEN_DIR})
target_include_directories(${TARGET} PUBLIC ${GEN_DIR})
set(_headers)
set(_sources)
add_custom_target(UpdateShaders${TARGET})
file(WRITE ${CMAKE_BINARY_DIR}/UpdateShaderFile${TARGET}.cmake "configure_file(\${SRC} \${DST} @ONLY)")
if (NOT DEFINED video_SOURCE_DIR)
message(FATAL_ERROR "video project not found")
endif()
set(SHADERTOOL_INCLUDE_DIRS)
list(APPEND SHADERTOOL_INCLUDE_DIRS "${video_SOURCE_DIR}/shaders")
get_property(DEPENDENCIES GLOBAL PROPERTY ${TARGET}_DEPENDENCIES)
foreach (D ${DEPENDENCIES})
if (NOT DEFINED ${D}_SOURCE_DIR)
continue()
endif()
if (EXISTS ${${D}_SOURCE_DIR}/shaders)
list(APPEND SHADERTOOL_INCLUDE_DIRS "${${D}_SOURCE_DIR}/shaders")
endif()
endforeach()
list(REMOVE_DUPLICATES SHADERTOOL_INCLUDE_DIRS)
set(SHADERTOOL_INCLUDE_DIRS_PARAM)
foreach (IDIR ${SHADERTOOL_INCLUDE_DIRS})
list(APPEND SHADERTOOL_INCLUDE_DIRS_PARAM "-I")
list(APPEND SHADERTOOL_INCLUDE_DIRS_PARAM "${IDIR}")
endforeach()
foreach (_file ${files})
set(_shaders)
set(_dir ${CMAKE_CURRENT_SOURCE_DIR}/shaders)
if (EXISTS ${_dir}/${_file}.frag AND EXISTS ${_dir}/${_file}.vert)
list(APPEND _shaders ${_dir}/${_file}.frag ${_dir}/${_file}.vert)
if (EXISTS ${_dir}/${_file}.geom)
list(APPEND _shaders ${_dir}/${_file}.geom)
endif()
endif()
if (EXISTS ${_dir}/${_file}.comp)
list(APPEND _shaders ${_dir}/${_file}.comp)
endif()
if (_shaders)
convert_to_camel_case(${_file} _f)
set(_shaderheaderpath "${GEN_DIR}${_f}Shader.h")
set(_shadersourcepath "${GEN_DIR}${_f}Shader.cpp")
# TODO We have to add the shader/ dirs of all dependencies to the include path
add_custom_command(
OUTPUT ${_shaderheaderpath}.in ${_shadersourcepath}.in
IMPLICIT_DEPENDS C ${_shaders}
COMMENT "Validate ${_file}"
COMMAND $<TARGET_FILE:shadertool> --glslang ${CMAKE_BINARY_DIR}/glslangValidator -I ${_dir} ${SHADERTOOL_INCLUDE_DIRS_PARAM} --postfix .in --shader ${_dir}/${_file} --headertemplate ${_template_header} --sourcetemplate ${_template_cpp} --buffertemplate ${_template_ub} --sourcedir ${GEN_DIR}
DEPENDS shadertool ${_shaders} ${_template_header} ${_template_cpp} ${_template_ub}
)
list(APPEND _headers ${_shaderheaderpath})
list(APPEND _sources ${_shadersourcepath})
add_custom_command(
OUTPUT ${_shaderheaderpath}
COMMAND ${CMAKE_COMMAND} -D SRC=${_shaderheaderpath}.in -D DST=${_shaderheaderpath} -P ${CMAKE_BINARY_DIR}/UpdateShaderFile${TARGET}.cmake
DEPENDS ${_shaderheaderpath}.in
)
add_custom_command(
OUTPUT ${_shadersourcepath}
COMMAND ${CMAKE_COMMAND} -D SRC=${_shadersourcepath}.in -D DST=${_shadersourcepath} -P ${CMAKE_BINARY_DIR}/UpdateShaderFile${TARGET}.cmake
DEPENDS ${_shadersourcepath}.in
)
else()
message(FATAL_ERROR "Could not find any shader files for ${_file} and target '${TARGET}'")
endif()
endforeach()
convert_to_camel_case(${TARGET} _filetarget)
set(_shadersheader ${GEN_DIR}/${_filetarget}Shaders.h)
file(WRITE ${_shadersheader}.in "#pragma once\n")
foreach (header_path ${_headers})
string(REPLACE "${GEN_DIR}" "" header "${header_path}")
file(APPEND ${_shadersheader}.in "#include \"${header}\"\n")
endforeach()
add_custom_target(GenerateShaderBindings${TARGET}
DEPENDS ${_headers}
COMMENT "Generate shader bindings for ${TARGET} in ${GEN_DIR}"
)
engine_mark_as_generated(${_headers} ${_sources} ${_shadersheader})
generate_unity_sources(SOURCES TARGET ${TARGET} SRCS ${_sources} UNITY_SRC "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_shaders_unity.cpp")
target_sources(${TARGET} PRIVATE ${_headers} ${_shadersheader})
add_custom_target(GenerateShaderHeader${TARGET} ${CMAKE_COMMAND} -D SRC=${_shadersheader}.in -D DST=${_shadersheader} -P ${CMAKE_BINARY_DIR}/UpdateShaderFile${TARGET}.cmake)
add_dependencies(${TARGET} GenerateShaderHeader${TARGET} UpdateShaders${TARGET})
add_dependencies(GenerateShaderHeader${TARGET} GenerateShaderBindings${TARGET})
add_dependencies(codegen GenerateShaderHeader${TARGET} UpdateShaders${TARGET})
endmacro()

88
cmake/genunity.cmake Normal file
View File

@ -0,0 +1,88 @@
macro(generate_unity_sources)
set(_OPTIONS_ARGS SOURCES EXECUTABLE LIBRARY WINDOWED)
set(_ONE_VALUE_ARGS TARGET UNITY_SRC)
set(_MULTI_VALUE_ARGS SRCS)
cmake_parse_arguments(_UNITY "${_OPTIONS_ARGS}" "${_ONE_VALUE_ARGS}" "${_MULTI_VALUE_ARGS}" ${ARGN} )
if (NOT _UNITY_TARGET)
message(FATAL_ERROR "generate_unity_sources requires the TARGET argument")
endif()
if (NOT _UNITY_SRCS)
message(FATAL_ERROR "generate_unity_sources requires the SRCS argument")
endif()
if (NOT _UNITY_UNITY_SRC)
set(_UNITY_UNITY_SRC "${CMAKE_CURRENT_BINARY_DIR}/${_UNITY_TARGET}_unity.cpp")
endif()
set(TARGET ${_UNITY_TARGET})
set(UNITY_SRC ${_UNITY_UNITY_SRC})
set(SRCS ${_UNITY_SRCS})
get_property(NOUNITY GLOBAL PROPERTY ${TARGET}_NOUNITY)
if (NOUNITY)
if (_UNITY_SOURCES)
target_sources(${TARGET} PRIVATE ${SRCS})
elseif (_UNITY_EXECUTABLE)
if (_UNITY_WINDOWED)
if (WINDOWS)
add_executable(${TARGET} WIN32 ${SRCS})
if (USE_MSVC)
set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/SUBSYSTEM:WINDOWS")
endif()
else()
add_executable(${TARGET} ${SRCS})
endif()
else()
add_executable(${TARGET} ${SRCS})
if (WINDOWS)
if (USE_MSVC)
set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/SUBSYSTEM:CONSOLE")
endif()
endif()
endif()
elseif (_UNITY_LIBRARY)
add_library(${TARGET} ${SRCS})
endif()
else()
set(unity_srcs)
list(APPEND unity_srcs ${UNITY_SRC})
add_custom_command(
OUTPUT ${UNITY_SRC}
COMMAND ${CMAKE_COMMAND} -D "SRCS=\"${SRCS}\"" -D UNITY_SRC="${UNITY_SRC}" -D DIR="${CMAKE_CURRENT_SOURCE_DIR}" -P "${ROOT_DIR}/cmake/GenerateUnity.cmake"
DEPENDS ${SRCS}
COMMENT "Generate unity sources for ${TARGET}"
)
engine_mark_as_generated(${UNITY_SRC} ${UNITY_SRC}.in)
foreach(SRC ${SRCS})
get_filename_component(extension ${SRC} EXT)
if (NOT "${extension}" STREQUAL ".cpp")
list(APPEND unity_srcs ${SRC})
continue()
endif()
endforeach()
if (_UNITY_SOURCES)
target_sources(${TARGET} PRIVATE ${unity_srcs})
elseif (_UNITY_EXECUTABLE)
if (_UNITY_WINDOWED)
if (WINDOWS)
add_executable(${TARGET} WIN32 ${unity_srcs})
if (USE_MSVC)
set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/SUBSYSTEM:WINDOWS")
endif()
else()
add_executable(${TARGET} ${unity_srcs})
endif()
else()
add_executable(${TARGET} ${unity_srcs})
if (WINDOWS)
if (USE_MSVC)
set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/SUBSYSTEM:CONSOLE")
endif()
endif()
endif()
elseif (_UNITY_LIBRARY)
add_library(${TARGET} ${unity_srcs})
endif()
endif()
endmacro()

129
cmake/googletest.cmake Normal file
View File

@ -0,0 +1,129 @@
#-------------------------------------------------------------------------------
# Macros for generating google unit tests.
#-------------------------------------------------------------------------------
set(GOOGLETESTDIR ${CMAKE_CURRENT_LIST_DIR})
#-------------------------------------------------------------------------------
# gtest_suite_begin(name)
# Begin defining a unit test suite.
#
macro(gtest_suite_begin name)
if (UNITTESTS)
set(options NO_TEMPLATE)
set(oneValueArgs TEMPLATE)
set(multiValueArgs)
cmake_parse_arguments(${name} "${options}" "${oneValueArgs}" "" ${ARGN})
if (${name}_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "gtest_suite_begin(): called with invalid args '${${name}_UNPARSED_ARGUMENTS}'")
endif()
set_property(GLOBAL PROPERTY ${name}_Sources "")
set_property(GLOBAL PROPERTY ${name}_Deps "")
if (NOT ${name}_NO_TEMPLATE)
set(main_path ${CMAKE_CURRENT_BINARY_DIR}/${name}_main.cpp)
if (${name}_TEMPLATE)
configure_file(${${name}_TEMPLATE} ${main_path})
else()
configure_file(${GOOGLETESTDIR}/main.cpp.in ${main_path})
endif()
add_executable(${name} ${main_path})
else()
add_executable(${name})
endif()
# add googletest lib dependency
find_package(GTest)
if (GTEST_FOUND)
target_include_directories(${name} PRIVATE ${GTEST_INCLUDE_DIRS})
target_link_libraries(${name} ${GTEST_LIBRARIES})
else()
target_link_libraries(${name} gtest)
endif()
endif()
endmacro()
macro(gtest_suite_sources name)
if (UNITTESTS)
set(ARG_LIST ${ARGV})
list(REMOVE_AT ARG_LIST 0)
get_property(list GLOBAL PROPERTY ${name}_Sources)
foreach(entry ${ARG_LIST})
list(APPEND list ${CMAKE_CURRENT_SOURCE_DIR}/${entry})
endforeach()
set_property(GLOBAL PROPERTY ${name}_Sources ${list})
endif()
endmacro()
macro(gtest_suite_files name)
if (UNITTESTS)
set(ARG_LIST ${ARGV})
list(REMOVE_AT ARG_LIST 0)
get_property(list GLOBAL PROPERTY ${name}_Files)
foreach(entry ${ARG_LIST})
list(APPEND list ${entry})
endforeach()
set_property(GLOBAL PROPERTY ${name}_Files ${list})
endif()
endmacro()
macro(gtest_suite_deps name)
if (UNITTESTS)
set(ARG_LIST ${ARGV})
list(REMOVE_AT ARG_LIST 0)
get_property(list GLOBAL PROPERTY ${name}_Deps)
list(APPEND list ${ARG_LIST})
set_property(GLOBAL PROPERTY ${name}_Deps ${list})
endif()
endmacro()
macro(gtest_suite_end name)
if (UNITTESTS)
project(${name})
get_property(srcs GLOBAL PROPERTY ${name}_Sources)
get_property(deps GLOBAL PROPERTY ${name}_Deps)
generate_unity_sources(SOURCES TARGET ${name} SRCS ${srcs})
set_target_properties(${name} PROPERTIES OUTPUT_NAME "${CMAKE_PROJECT_NAME}-${name}")
set_target_properties(${name} PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${name}"
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${name}"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${name}"
)
foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
set_target_properties(${name} PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_BINARY_DIR}/${name}"
LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_BINARY_DIR}/${name}"
RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_BINARY_DIR}/${name}"
)
endforeach()
get_property(models GLOBAL PROPERTY ${name}_Models)
foreach(entry ${models})
string(REPLACE ":" ";" inout ${entry})
list(GET inout 0 in)
list(GET inout 1 out)
generate_db_models(${name} ${in} ${out})
endforeach()
get_property(files GLOBAL PROPERTY ${name}_Files)
foreach (datafile ${files})
string(REGEX REPLACE "^[^/]+" "" target_datafile "${datafile}")
string(LENGTH ${target_datafile} target_datafile_length)
string(SUBSTRING ${target_datafile} 1 ${target_datafile_length} target_datafile)
get_filename_component(datafiledir ${target_datafile} DIRECTORY)
get_filename_component(filename ${target_datafile} NAME)
configure_file(${DATA_DIR}/${datafile} ${CMAKE_BINARY_DIR}/${name}/${datafiledir}/${filename} COPYONLY)
endforeach()
target_link_libraries(${name} ${deps})
set_target_properties(${name} PROPERTIES FOLDER ${name})
add_test(NAME ${name} COMMAND $<TARGET_FILE:${name}>)
add_custom_target(${name}-run COMMAND $<TARGET_FILE:${name}> DEPENDS ${name} WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/${name}")
engine_add_debuggger(${name})
engine_add_valgrind(${name})
engine_add_perf(${name})
endif()
endmacro()

32
cmake/lua.cmake Normal file
View File

@ -0,0 +1,32 @@
macro(check_lua_files TARGET)
set(files ${ARGV})
list(REMOVE_AT files 0)
find_program(LUAC_EXECUTABLE NAMES ${DEFAULT_LUAC_EXECUTABLE})
if (LUAC_EXECUTABLE)
message(STATUS "${LUAC_EXECUTABLE} found")
foreach(_file ${files})
get_filename_component(filename ${_file} NAME)
string(REGEX REPLACE "[/]" "_" targetname ${_file})
add_custom_target(
${targetname}
COMMAND ${LUAC_EXECUTABLE} -o ${CMAKE_CURRENT_BINARY_DIR}/${filename}.out ${_file}
COMMENT "Validate ${_file}"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lua/
)
add_dependencies(${TARGET} ${targetname})
endforeach()
else()
foreach(_file ${files})
string(REGEX REPLACE "[/]" "_" targetname ${_file})
get_filename_component(filename ${_file} NAME)
add_custom_target(
${targetname}
COMMAND $<TARGET_FILE:luac> -o ${CMAKE_CURRENT_BINARY_DIR}/${filename}.out ${_file}
COMMENT "Validate ${_file}"
DEPENDS luac
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lua/
)
add_dependencies(${TARGET} ${targetname})
endforeach()
endif()
endmacro()

847
cmake/macros.cmake
View File

@ -1,849 +1,3 @@
include(CMakeParseArguments)
include(CheckCXXCompilerFlag)
include(CheckCCompilerFlag)
include(GNUInstallDirs)
set(LIBS_DIR ${PROJECT_SOURCE_DIR}/contrib/libs)
if (CMAKE_COMPILER_IS_GNUCC)
set(USE_GCC TRUE)
elseif (CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID MATCHES "AppleClang" OR CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
set(USE_CLANG TRUE)
elseif (MSVC)
set(USE_MSVC TRUE)
endif()
macro(var_global VARIABLES)
foreach(VAR ${VARIABLES})
set(${VAR} ${${VAR}} CACHE STRING "" FORCE)
mark_as_advanced(${VAR})
endforeach()
endmacro()
# some cross compiling toolchains define this
if(NOT COMMAND find_host_program)
macro(find_host_program)
find_program(${ARGN})
endmacro()
endif()
macro(convert_to_camel_case IN OUT)
string(REPLACE "-" "_" _list ${IN})
string(REPLACE "_" ";" _list ${_list})
set(_final "")
if (_list)
foreach(_e ${_list})
string(SUBSTRING ${_e} 0 1 _first_letter)
string(TOUPPER ${_first_letter} _first_letter)
string(SUBSTRING ${_e} 1 -1 _remaining)
set(_final "${_final}${_first_letter}${_remaining}")
endforeach()
else()
string(SUBSTRING ${IN} 0 1 _first_letter)
string(TOUPPER ${_first_letter} _first_letter)
string(SUBSTRING ${IN} 1 -1 _remaining)
set(_final "${_final}${_first_letter}${_remaining}")
endif()
set(${OUT} ${_final})
endmacro()
macro(engine_mark_as_generated)
set_source_files_properties(${ARGN} PROPERTIES GENERATED TRUE)
#set_source_files_properties(${ARGN} PROPERTIES LANGUAGE CXX)
endmacro()
macro(generate_unity_sources)
set(_OPTIONS_ARGS SOURCES EXECUTABLE LIBRARY WINDOWED)
set(_ONE_VALUE_ARGS TARGET UNITY_SRC)
set(_MULTI_VALUE_ARGS SRCS)
cmake_parse_arguments(_UNITY "${_OPTIONS_ARGS}" "${_ONE_VALUE_ARGS}" "${_MULTI_VALUE_ARGS}" ${ARGN} )
if (NOT _UNITY_TARGET)
message(FATAL_ERROR "generate_unity_sources requires the TARGET argument")
endif()
if (NOT _UNITY_SRCS)
message(FATAL_ERROR "generate_unity_sources requires the SRCS argument")
endif()
if (NOT _UNITY_UNITY_SRC)
set(_UNITY_UNITY_SRC "${CMAKE_CURRENT_BINARY_DIR}/${_UNITY_TARGET}_unity.cpp")
endif()
set(TARGET ${_UNITY_TARGET})
set(UNITY_SRC ${_UNITY_UNITY_SRC})
set(SRCS ${_UNITY_SRCS})
get_property(NOUNITY GLOBAL PROPERTY ${TARGET}_NOUNITY)
if (NOUNITY)
if (_UNITY_SOURCES)
target_sources(${TARGET} PRIVATE ${SRCS})
elseif (_UNITY_EXECUTABLE)
if (_UNITY_WINDOWED)
if (WINDOWS)
add_executable(${TARGET} WIN32 ${SRCS})
if (USE_MSVC)
set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/SUBSYSTEM:WINDOWS")
endif()
else()
add_executable(${TARGET} ${SRCS})
endif()
else()
add_executable(${TARGET} ${SRCS})
if (WINDOWS)
if (USE_MSVC)
set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/SUBSYSTEM:CONSOLE")
endif()
endif()
endif()
elseif (_UNITY_LIBRARY)
add_library(${TARGET} ${SRCS})
endif()
else()
set(unity_srcs)
list(APPEND unity_srcs ${UNITY_SRC})
add_custom_command(
OUTPUT ${UNITY_SRC}
COMMAND ${CMAKE_COMMAND} -D "SRCS=\"${SRCS}\"" -D UNITY_SRC="${UNITY_SRC}" -D DIR="${CMAKE_CURRENT_SOURCE_DIR}" -P "${ROOT_DIR}/cmake/GenerateUnity.cmake"
DEPENDS ${SRCS}
COMMENT "Generate unity sources for ${TARGET}"
)
engine_mark_as_generated(${UNITY_SRC} ${UNITY_SRC}.in)
foreach(SRC ${SRCS})
get_filename_component(extension ${SRC} EXT)
if (NOT "${extension}" STREQUAL ".cpp")
list(APPEND unity_srcs ${SRC})
continue()
endif()
endforeach()
if (_UNITY_SOURCES)
target_sources(${TARGET} PRIVATE ${unity_srcs})
elseif (_UNITY_EXECUTABLE)
if (_UNITY_WINDOWED)
if (WINDOWS)
add_executable(${TARGET} WIN32 ${unity_srcs})
if (USE_MSVC)
set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/SUBSYSTEM:WINDOWS")
endif()
else()
add_executable(${TARGET} ${unity_srcs})
endif()
else()
add_executable(${TARGET} ${unity_srcs})
if (WINDOWS)
if (USE_MSVC)
set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/SUBSYSTEM:CONSOLE")
endif()
endif()
endif()
elseif (_UNITY_LIBRARY)
add_library(${TARGET} ${unity_srcs})
endif()
endif()
endmacro()
macro(generate_shaders TARGET)
set(files ${ARGV})
list(REMOVE_AT files 0)
set(GEN_DIR ${GENERATE_DIR}/shaders/${TARGET}/)
set(_template_header ${ROOT_DIR}/src/tools/shadertool/ShaderTemplate.h.in)
set(_template_cpp ${ROOT_DIR}/src/tools/shadertool/ShaderTemplate.cpp.in)
set(_template_ub ${ROOT_DIR}/src/tools/shadertool/UniformBufferTemplate.h.in)
file(MAKE_DIRECTORY ${GEN_DIR})
target_include_directories(${TARGET} PUBLIC ${GEN_DIR})
set(_headers)
set(_sources)
add_custom_target(UpdateShaders${TARGET})
file(WRITE ${CMAKE_BINARY_DIR}/UpdateShaderFile${TARGET}.cmake "configure_file(\${SRC} \${DST} @ONLY)")
if (NOT DEFINED video_SOURCE_DIR)
message(FATAL_ERROR "video project not found")
endif()
set(SHADERTOOL_INCLUDE_DIRS)
list(APPEND SHADERTOOL_INCLUDE_DIRS "${video_SOURCE_DIR}/shaders")
get_property(DEPENDENCIES GLOBAL PROPERTY ${TARGET}_DEPENDENCIES)
foreach (D ${DEPENDENCIES})
if (NOT DEFINED ${D}_SOURCE_DIR)
continue()
endif()
if (EXISTS ${${D}_SOURCE_DIR}/shaders)
list(APPEND SHADERTOOL_INCLUDE_DIRS "${${D}_SOURCE_DIR}/shaders")
endif()
endforeach()
list(REMOVE_DUPLICATES SHADERTOOL_INCLUDE_DIRS)
set(SHADERTOOL_INCLUDE_DIRS_PARAM)
foreach (IDIR ${SHADERTOOL_INCLUDE_DIRS})
list(APPEND SHADERTOOL_INCLUDE_DIRS_PARAM "-I")
list(APPEND SHADERTOOL_INCLUDE_DIRS_PARAM "${IDIR}")
endforeach()
foreach (_file ${files})
set(_shaders)
set(_dir ${CMAKE_CURRENT_SOURCE_DIR}/shaders)
if (EXISTS ${_dir}/${_file}.frag AND EXISTS ${_dir}/${_file}.vert)
list(APPEND _shaders ${_dir}/${_file}.frag ${_dir}/${_file}.vert)
if (EXISTS ${_dir}/${_file}.geom)
list(APPEND _shaders ${_dir}/${_file}.geom)
endif()
endif()
if (EXISTS ${_dir}/${_file}.comp)
list(APPEND _shaders ${_dir}/${_file}.comp)
endif()
if (_shaders)
convert_to_camel_case(${_file} _f)
set(_shaderheaderpath "${GEN_DIR}${_f}Shader.h")
set(_shadersourcepath "${GEN_DIR}${_f}Shader.cpp")
# TODO We have to add the shader/ dirs of all dependencies to the include path
add_custom_command(
OUTPUT ${_shaderheaderpath}.in ${_shadersourcepath}.in
IMPLICIT_DEPENDS C ${_shaders}
COMMENT "Validate ${_file}"
COMMAND $<TARGET_FILE:shadertool> --glslang ${CMAKE_BINARY_DIR}/glslangValidator -I ${_dir} ${SHADERTOOL_INCLUDE_DIRS_PARAM} --postfix .in --shader ${_dir}/${_file} --headertemplate ${_template_header} --sourcetemplate ${_template_cpp} --buffertemplate ${_template_ub} --sourcedir ${GEN_DIR}
DEPENDS shadertool ${_shaders} ${_template_header} ${_template_cpp} ${_template_ub}
)
list(APPEND _headers ${_shaderheaderpath})
list(APPEND _sources ${_shadersourcepath})
add_custom_command(
OUTPUT ${_shaderheaderpath}
COMMAND ${CMAKE_COMMAND} -D SRC=${_shaderheaderpath}.in -D DST=${_shaderheaderpath} -P ${CMAKE_BINARY_DIR}/UpdateShaderFile${TARGET}.cmake
DEPENDS ${_shaderheaderpath}.in
)
add_custom_command(
OUTPUT ${_shadersourcepath}
COMMAND ${CMAKE_COMMAND} -D SRC=${_shadersourcepath}.in -D DST=${_shadersourcepath} -P ${CMAKE_BINARY_DIR}/UpdateShaderFile${TARGET}.cmake
DEPENDS ${_shadersourcepath}.in
)
else()
message(FATAL_ERROR "Could not find any shader files for ${_file} and target '${TARGET}'")
endif()
endforeach()
convert_to_camel_case(${TARGET} _filetarget)
set(_shadersheader ${GEN_DIR}/${_filetarget}Shaders.h)
file(WRITE ${_shadersheader}.in "#pragma once\n")
foreach (header_path ${_headers})
string(REPLACE "${GEN_DIR}" "" header "${header_path}")
file(APPEND ${_shadersheader}.in "#include \"${header}\"\n")
endforeach()
add_custom_target(GenerateShaderBindings${TARGET}
DEPENDS ${_headers}
COMMENT "Generate shader bindings for ${TARGET} in ${GEN_DIR}"
)
engine_mark_as_generated(${_headers} ${_sources} ${_shadersheader})
generate_unity_sources(SOURCES TARGET ${TARGET} SRCS ${_sources} UNITY_SRC "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_shaders_unity.cpp")
target_sources(${TARGET} PRIVATE ${_headers} ${_shadersheader})
add_custom_target(GenerateShaderHeader${TARGET} ${CMAKE_COMMAND} -D SRC=${_shadersheader}.in -D DST=${_shadersheader} -P ${CMAKE_BINARY_DIR}/UpdateShaderFile${TARGET}.cmake)
add_dependencies(${TARGET} GenerateShaderHeader${TARGET} UpdateShaders${TARGET})
add_dependencies(GenerateShaderHeader${TARGET} GenerateShaderBindings${TARGET})
add_dependencies(codegen GenerateShaderHeader${TARGET} UpdateShaders${TARGET})
endmacro()
macro(generate_compute_shaders TARGET)
set(files ${ARGV})
list(REMOVE_AT files 0)
set(GEN_DIR ${GENERATE_DIR}/compute-shaders/${TARGET}/)
set(_template ${ROOT_DIR}/src/tools/computeshadertool/ComputeShaderTemplate.h.in)
file(MAKE_DIRECTORY ${GEN_DIR})
target_include_directories(${TARGET} PUBLIC ${GEN_DIR})
set(_headers)
add_custom_target(UpdateComputeShaders${TARGET})
file(WRITE ${CMAKE_BINARY_DIR}/GenerateComputeShaderHeader${TARGET}.cmake "configure_file(\${SRC} \${DST} @ONLY)")
if (NOT DEFINED compute_SOURCE_DIR)
message(FATAL_ERROR "compute project not found")
endif()
set(SHADERTOOL_INCLUDE_DIRS)
list(APPEND SHADERTOOL_INCLUDE_DIRS "${compute_SOURCE_DIR}/shaders")
get_property(DEPENDENCIES GLOBAL PROPERTY ${TARGET}_DEPENDENCIES)
foreach (D ${DEPENDENCIES})
if (NOT DEFINED ${D}_SOURCE_DIR)
continue()
endif()
if (EXISTS ${${D}_SOURCE_DIR}/shaders)
list(APPEND SHADERTOOL_INCLUDE_DIRS "${${D}_SOURCE_DIR}/shaders")
endif()
endforeach()
list(REMOVE_DUPLICATES SHADERTOOL_INCLUDE_DIRS)
set(SHADERTOOL_INCLUDE_DIRS_PARAM)
foreach (IDIR ${SHADERTOOL_INCLUDE_DIRS})
list(APPEND SHADERTOOL_INCLUDE_DIRS_PARAM "-I")
list(APPEND SHADERTOOL_INCLUDE_DIRS_PARAM "${IDIR}")
endforeach()
foreach (_file ${files})
set(_shaders)
set(_dir ${CMAKE_CURRENT_SOURCE_DIR}/shaders)
if (EXISTS ${_dir}/${_file}.cl)
list(APPEND _shaders ${_dir}/${_file}.cl)
endif()
if (_shaders)
convert_to_camel_case(${_file} _f)
set(_shaderfile "${_f}Shader.h")
set(_shader "${GEN_DIR}${_shaderfile}")
# TODO We have to add the shader/ dirs of all dependencies to the include path
add_custom_command(
OUTPUT ${_shader}.in
IMPLICIT_DEPENDS C ${_shaders}
COMMENT "Validate ${_file} and generate ${_shaderfile}"
COMMAND $<TARGET_FILE:computeshadertool> --shader ${_dir}/${_file} -I ${_dir} ${SHADERTOOL_INCLUDE_DIRS_PARAM} --postfix .in --shadertemplate ${_template} --sourcedir ${GEN_DIR}
DEPENDS computeshadertool ${_shaders} ${_template}
VERBATIM
)
list(APPEND _headers ${_shader})
add_custom_command(
OUTPUT ${_shader}
COMMAND ${CMAKE_COMMAND} -D SRC=${_shader}.in -D DST=${_shader} -P ${CMAKE_BINARY_DIR}/GenerateComputeShaderHeader${TARGET}.cmake
DEPENDS ${_shader}.in
)
else()
message(FATAL_ERROR "Could not find any shader files for ${_file} and target '${TARGET}'")
endif()
endforeach()
convert_to_camel_case(${TARGET} _filetarget)
set(_h ${GEN_DIR}/${_filetarget}ComputeShaders.h)
file(WRITE ${_h}.in "#pragma once\n")
foreach (header_path ${_headers})
string(REPLACE "${GEN_DIR}" "" header "${header_path}")
file(APPEND ${_h}.in "#include \"${header}\"\n")
endforeach()
add_custom_target(GenerateComputeShaderBindings${TARGET}
DEPENDS ${_headers}
COMMENT "Generate shader bindings for ${TARGET} in ${GEN_DIR}"
)
engine_mark_as_generated(${_headers} ${_h})
add_custom_target(GenerateComputeShaderHeader${TARGET} ${CMAKE_COMMAND} -D SRC=${_h}.in -D DST=${_h} -P ${CMAKE_BINARY_DIR}/GenerateComputeShaderHeader${TARGET}.cmake)
add_dependencies(${TARGET} GenerateComputeShaderHeader${TARGET} UpdateComputeShaders${TARGET})
add_dependencies(GenerateComputeShaderHeader${TARGET} GenerateComputeShaderBindings${TARGET})
add_dependencies(codegen GenerateComputeShaderHeader${TARGET} UpdateComputeShaders${TARGET})
endmacro()
macro(generate_db_models TARGET INPUT OUTPUT)
set(GEN_DIR ${GENERATE_DIR}/dbmodels/${TARGET}/)
file(MAKE_DIRECTORY ${GEN_DIR})
target_include_directories(${TARGET} PUBLIC ${GEN_DIR})
add_custom_command(
OUTPUT ${GEN_DIR}${OUTPUT}
COMMENT "Generate ${OUTPUT}"
COMMAND $<TARGET_FILE:databasetool> --tablefile ${INPUT} --outfile ${GEN_DIR}${OUTPUT}
DEPENDS databasetool ${INPUT}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
add_custom_target(GenerateDatabaseModelBindings${TARGET}
DEPENDS ${GEN_DIR}${OUTPUT}
COMMENT "Generate database model bindings for ${TARGET} in ${GEN_DIR}"
)
engine_mark_as_generated(${GEN_DIR}${OUTPUT})
add_dependencies(${TARGET} GenerateDatabaseModelBindings${TARGET})
add_dependencies(codegen GenerateDatabaseModelBindings${TARGET})
endmacro()
macro(generate_protocol TARGET)
set(files ${ARGV})
list(REMOVE_AT files 0)
set(GEN_DIR ${GENERATE_DIR}/protocol/${TARGET}/)
file(MAKE_DIRECTORY ${GEN_DIR})
target_include_directories(${TARGET} PUBLIC ${GEN_DIR})
set(_headers)
foreach (_file ${files})
get_filename_component(_basefilename ${_file} NAME_WE)
set(HEADER "${_basefilename}_generated.h")
set(DEFINITION ${_file})
list(APPEND _headers ${GEN_DIR}${HEADER})
add_custom_command(
OUTPUT ${GEN_DIR}${HEADER}
COMMAND $<TARGET_FILE:flatc> -c -I ${CMAKE_CURRENT_SOURCE_DIR}/../attrib/definitions --scoped-enums -o ${GEN_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/definitions/${DEFINITION}
DEPENDS flatc ${CMAKE_CURRENT_SOURCE_DIR}/definitions/${DEFINITION}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Generating source code for ${DEFINITION}"
)
engine_mark_as_generated(${GEN_DIR}/${HEADER})
endforeach()
add_custom_target(GenerateNetworkMessages${TARGET}
DEPENDS ${_headers}
COMMENT "Generate network messages in ${GEN_DIR}"
)
add_dependencies(${TARGET} GenerateNetworkMessages${TARGET})
add_dependencies(codegen GenerateNetworkMessages${TARGET})
endmacro()
#
# macro for the FindLibName.cmake files.
#
# parameters:
# LIB: the library we are trying to find
# HEADER: the header we are trying to find
# SUFFIX: suffix for the include dir
# VERSION: the operator and version that is given to the pkg-config call (e.g. ">=1.0")
# (this only works for pkg-config)
#
# Example: engine_find(SDL2_image SDL_image.h SDL2 "")
#
macro(engine_find LIB HEADER SUFFIX VERSION)
string(TOUPPER ${LIB} PREFIX)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(_PROCESSOR_ARCH "x64")
else()
set(_PROCESSOR_ARCH "x86")
endif()
set(_SEARCH_PATHS
~/Library/Frameworks
/Library/Frameworks
/usr/local
/usr
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
$ENV{VCPKG_ROOT}/installed/${_PROCESSOR_ARCH}-windows
C:/Tools/vcpkg/installed/${_PROCESSOR_ARCH}-windows
C:/vcpkg/installed/${_PROCESSOR_ARCH}-windows
)
find_package(PkgConfig QUIET)
if (PKG_CONFIG_FOUND)
pkg_check_modules(_${PREFIX} "${LIB}${VERSION}")
endif()
find_path(${PREFIX}_INCLUDE_DIRS
NAMES ${HEADER}
HINTS ENV ${PREFIX}DIR
PATH_SUFFIXES include include/${SUFFIX} ${SUFFIX}
PATHS
${_${PREFIX}_INCLUDE_DIRS}
${_SEARCH_PATHS}
)
find_library(${PREFIX}_LIBRARIES
NAMES ${LIB} ${PREFIX} ${_${PREFIX}_LIBRARIES}
HINTS ENV ${PREFIX}DIR
PATH_SUFFIXES lib64 lib lib/${_PROCESSOR_ARCH}
PATHS
${_${PREFIX}_LIBRARY_DIRS}
${_SEARCH_PATHS}
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(${LIB} FOUND_VAR ${PREFIX}_FOUND REQUIRED_VARS ${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARIES)
mark_as_advanced(${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARIES ${PREFIX}_FOUND)
var_global(${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARIES ${PREFIX}_FOUND)
unset(PREFIX)
unset(_SEARCH_PATHS)
unset(_PROCESSOR_ARCH)
endmacro()
macro(engine_find_header_only LIB HEADER SUFFIX VERSION)
string(TOUPPER ${LIB} PREFIX)
set(_SEARCH_PATHS
~/Library/Frameworks
/Library/Frameworks
/usr/local
/usr
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
)
find_package(PkgConfig QUIET)
if (PKG_CONFIG_FOUND)
pkg_check_modules(_${PREFIX} "${LIB}${VERSION}")
endif()
find_path(${PREFIX}_INCLUDE_DIRS
NAMES ${HEADER}
HINTS ENV ${PREFIX}DIR
PATH_SUFFIXES include include/${SUFFIX} ${SUFFIX}
PATHS
${_${PREFIX}_INCLUDE_DIRS}
${_SEARCH_PATHS}
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(${LIB} FOUND_VAR ${PREFIX}_FOUND REQUIRED_VARS ${PREFIX}_INCLUDE_DIRS)
mark_as_advanced(${PREFIX}_INCLUDE_DIRS ${PREFIX}_FOUND)
var_global(${PREFIX}_INCLUDE_DIRS ${PREFIX}_FOUND)
unset(PREFIX)
unset(_SEARCH_PATHS)
endmacro()
#
# Add external dependency. It will trigger a find_package and use the system wide install if found
#
# parameters:
# PUBLICHEADER: optional
# LIB: the name of the lib. Must match the FindXXX.cmake module and the pkg-config name of the lib
# GCCCFLAGS: optional
# GCCLINKERFLAGS: optional
# SRCS: the list of source files for the bundled lib
# DEFINES: a list of defines (without -D or /D)
#
macro(engine_add_library)
set(_OPTIONS_ARGS UNITY)
set(_ONE_VALUE_ARGS LIB PACKAGE GCCCFLAGS LINKERFLAGS PUBLICHEADER)
set(_MULTI_VALUE_ARGS SRCS DEFINES)
cmake_parse_arguments(_ADDLIB "${_OPTIONS_ARGS}" "${_ONE_VALUE_ARGS}" "${_MULTI_VALUE_ARGS}" ${ARGN} )
if (NOT _ADDLIB_LIB)
message(FATAL_ERROR "engine_add_library requires the LIB argument")
endif()
if (NOT _ADDLIB_SRCS)
message(FATAL_ERROR "engine_add_library requires the SRCS argument")
endif()
if (NOT _ADDLIB_PUBLICHEADER)
set(_ADDLIB_PUBLICHEADER PUBLIC)
endif()
if (_ADDLIB_FIND_PACKAGE)
set(FIND_PACKAGE_NAME ${_ADDLIB_FIND_PACKAGE})
else()
set(FIND_PACKAGE_NAME ${_ADDLIB_LIB})
endif()
string(TOUPPER ${_ADDLIB_LIB} PREFIX)
if (NOT ${PREFIX}_LOCAL)
find_package(${FIND_PACKAGE_NAME})
endif()
# now convert it again - looks like find_package exports PREFIX in some versions of cmake, too
string(TOUPPER ${_ADDLIB_LIB} PREFIX)
string(TOUPPER ${FIND_PACKAGE_NAME} PKG_PREFIX)
if (NOT ${PREFIX} STREQUAL ${PKG_PREFIX})
if (${PKG_PREFIX}_INCLUDE_DIRS)
set(${PREFIX}_INCLUDE_DIRS ${PKG_PREFIX}_INCLUDE_DIRS)
else()
set(${PREFIX}_INCLUDE_DIRS ${PKG_PREFIX}_INCLUDE_DIR)
endif()
if (${PREFIX}_LIBRARIES ${PKG_PREFIX}_LIBRARIES)
set(${PREFIX}_LIBRARIES ${PKG_PREFIX}_LIBRARIES)
else()
set(${PREFIX}_LIBRARIES ${PKG_PREFIX}_LIBRARY)
endif()
set(${PREFIX}_FOUND ${PKG_PREFIX}_FOUND)
message(STATUS "find_package ${FIND_PACKAGE_NAME} for ${_ADDLIB_LIB}")
endif()
var_global(${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARIES ${PREFIX}_FOUND)
if (${PREFIX}_FOUND)
add_library(${_ADDLIB_LIB} INTERFACE)
set(LIBS ${${PREFIX}_LIBRARIES})
if (LIBS)
# Remove leading spaces
string(REGEX REPLACE "^[ \t\r\n]+" "" LIBS "${LIBS}" )
# Remove trailing spaces
string(REGEX REPLACE "(\ )+$" "" LIBS ${LIBS})
target_link_libraries(${_ADDLIB_LIB} INTERFACE ${LIBS})
endif()
if (${PREFIX}_INCLUDE_DIRS)
set_property(TARGET ${_ADDLIB_LIB} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${${PREFIX}_INCLUDE_DIRS})
endif()
else()
message(STATUS "Use the bundled lib ${_ADDLIB_LIB}")
if (_ADDLIB_UNITY)
set(UNITY_SRC_CPP ${CMAKE_CURRENT_BINARY_DIR}/${_ADDLIB_LIB}_unity.cpp)
file(WRITE ${UNITY_SRC_CPP}.in "/** autogenerated */\n")
set(UNITY_SRC_C ${CMAKE_CURRENT_BINARY_DIR}/${_ADDLIB_LIB}_unity.c)
file(WRITE ${UNITY_SRC_C}.in "/** autogenerated */\n")
set(unity_srcs)
list(APPEND unity_srcs ${UNITY_SRC_CPP} ${UNITY_SRC_C})
foreach(SRC ${_ADDLIB_SRCS})
get_filename_component(extension ${SRC} EXT)
if ("${extension}" STREQUAL ".cpp")
file(APPEND ${UNITY_SRC_CPP}.in "#include \"${SRC}\"\n")
continue()
endif()
if ("${extension}" STREQUAL ".c")
file(APPEND ${UNITY_SRC_C}.in "#include \"${SRC}\"\n")
continue()
endif()
list(APPEND unity_srcs ${SRC})
endforeach()
configure_file(${UNITY_SRC_CPP}.in ${UNITY_SRC_CPP})
configure_file(${UNITY_SRC_C}.in ${UNITY_SRC_C})
add_library(${_ADDLIB_LIB} STATIC ${unity_srcs})
else()
add_library(${_ADDLIB_LIB} STATIC ${_ADDLIB_SRCS})
endif()
target_include_directories(${_ADDLIB_LIB} ${_ADDLIB_PUBLICHEADER} ${LIBS_DIR}/${_ADDLIB_LIB})
set_target_properties(${_ADDLIB_LIB} PROPERTIES COMPILE_DEFINITIONS "${_ADDLIB_DEFINES}")
if (USE_GCC OR USE_CLANG)
message(STATUS "additional lib cflags: ${_ADDLIB_GCCCFLAGS}")
if(UNIX)
set_target_properties(${_ADDLIB_LIB} PROPERTIES COMPILE_FLAGS "${_ADDLIB_GCCCFLAGS} -fPIC")
else()
set_target_properties(${_ADDLIB_LIB} PROPERTIES COMPILE_FLAGS "${_ADDLIB_GCCCFLAGS}")
endif()
set_target_properties(${_ADDLIB_LIB} PROPERTIES LINK_FLAGS "${_ADDLIB_GCCLINKERFLAGS}")
endif()
set_target_properties(${_ADDLIB_LIB} PROPERTIES FOLDER ${_ADDLIB_LIB})
endif()
endmacro()
macro(engine_add_valgrind TARGET)
find_program(VALGRIND_EXECUTABLE NAMES valgrind)
if (VALGRIND_EXECUTABLE)
add_custom_target(${TARGET}-memcheckxml)
add_custom_command(TARGET ${TARGET}-memcheckxml
COMMAND
${VALGRIND_EXECUTABLE} --xml=yes --xml-file=${CMAKE_CURRENT_BINARY_DIR}/memcheck-${TARGET}.xml
--tool=memcheck --leak-check=full --show-reachable=yes
--undef-value-errors=yes --track-origins=no --child-silent-after-fork=no
--trace-children=no
$<TARGET_FILE:${TARGET}>
COMMENT "Executing valgrind memcheck and log into ${CMAKE_CURRENT_BINARY_DIR}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
add_custom_target(${TARGET}-memcheck)
add_custom_command(TARGET ${TARGET}-memcheck
COMMAND
${VALGRIND_EXECUTABLE}
--tool=memcheck --leak-check=full --show-reachable=yes
--undef-value-errors=yes --track-origins=no --child-silent-after-fork=no
--trace-children=no --log-file=${CMAKE_CURRENT_BINARY_DIR}/memcheck-${TARGET}.log
$<TARGET_FILE:${TARGET}>
COMMENT "Executing valgrind memcheck and log into ${CMAKE_CURRENT_BINARY_DIR}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
add_custom_target(${TARGET}-helgrind)
add_custom_command(TARGET ${TARGET}-helgrind
COMMAND
${VALGRIND_EXECUTABLE} --xml=yes --xml-file=${CMAKE_BINARY_DIR}/helgrind-${TARGET}.xml
--tool=helgrind --child-silent-after-fork=no
--trace-children=no --log-file=$<TARGET_FILE:${TARGET}>.helgrind.log
$<TARGET_FILE:${TARGET}>
COMMENT "Executing valgrind helgrind and log into ${CMAKE_CURRENT_BINARY_DIR}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
endif()
endmacro()
macro(engine_add_perf TARGET)
find_program(PERF_EXECUTABLE NAMES perf)
if (PERF_EXECUTABLE)
add_custom_target(${TARGET}-perf)
add_custom_command(TARGET ${TARGET}-perf
COMMAND
${PERF_EXECUTABLE} record --call-graph dwarf
$<TARGET_FILE:${TARGET}>
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
endif()
endmacro()
macro(engina_add_vogl TARGET)
find_program(VOGL_EXECUTABLE NAMES vogl)
if (VOGL_EXECUTABLE)
add_custom_target(${TARGET}-vogl)
add_custom_command(TARGET ${TARGET}-vogl
COMMAND
${VOGL_EXECUTABLE} trace --vogl_tracepath ${CMAKE_BINARY_DIR}
--vogl_tracefile ${TARGET}.trace.bin
--vogl_force_debug_context
$<TARGET_FILE:${TARGET}>
COMMENT "vogl trace file for ${TARGET}: ${CMAKE_BINARY_DIR}/${TARGET}.trace.bin"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
endif()
endmacro()
macro(engine_add_debuggger TARGET)
add_custom_target(${TARGET}-debug)
if (${DEBUGGER} STREQUAL "gdb")
add_custom_command(TARGET ${TARGET}-debug
COMMAND ${GDB_EXECUTABLE} -ex run --args $<TARGET_FILE:${TARGET}>
COMMENT "Starting debugger session for ${TARGET}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
elseif (${DEBUGGER} STREQUAL "lldb")
add_custom_command(TARGET ${TARGET}-debug
COMMAND ${LLDB_EXECUTABLE} -b -o run $<TARGET_FILE:${TARGET}>
COMMENT "Starting debugger session for ${TARGET}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
else()
message(WARN "Unknown DEBUGGER value - set to gdb or lldb")
endif()
endmacro()
#-------------------------------------------------------------------------------
# Macros for generating google unit tests.
#-------------------------------------------------------------------------------
set(GOOGLETESTDIR ${CMAKE_CURRENT_LIST_DIR})
#-------------------------------------------------------------------------------
# gtest_suite_begin(name)
# Begin defining a unit test suite.
#
macro(gtest_suite_begin name)
if (UNITTESTS)
set(options NO_TEMPLATE)
set(oneValueArgs TEMPLATE)
set(multiValueArgs)
cmake_parse_arguments(${name} "${options}" "${oneValueArgs}" "" ${ARGN})
if (${name}_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "gtest_suite_begin(): called with invalid args '${${name}_UNPARSED_ARGUMENTS}'")
endif()
set_property(GLOBAL PROPERTY ${name}_Sources "")
set_property(GLOBAL PROPERTY ${name}_Deps "")
if (NOT ${name}_NO_TEMPLATE)
set(main_path ${CMAKE_CURRENT_BINARY_DIR}/${name}_main.cpp)
if (${name}_TEMPLATE)
configure_file(${${name}_TEMPLATE} ${main_path})
else()
configure_file(${GOOGLETESTDIR}/main.cpp.in ${main_path})
endif()
add_executable(${name} ${main_path})
else()
add_executable(${name})
endif()
# add googletest lib dependency
find_package(GTest)
if (GTEST_FOUND)
target_include_directories(${name} PRIVATE ${GTEST_INCLUDE_DIRS})
target_link_libraries(${name} ${GTEST_LIBRARIES})
else()
target_link_libraries(${name} gtest)
endif()
endif()
endmacro()
macro(gtest_suite_sources name)
if (UNITTESTS)
set(ARG_LIST ${ARGV})
list(REMOVE_AT ARG_LIST 0)
get_property(list GLOBAL PROPERTY ${name}_Sources)
foreach(entry ${ARG_LIST})
list(APPEND list ${CMAKE_CURRENT_SOURCE_DIR}/${entry})
endforeach()
set_property(GLOBAL PROPERTY ${name}_Sources ${list})
endif()
endmacro()
macro(gtest_suite_files name)
if (UNITTESTS)
set(ARG_LIST ${ARGV})
list(REMOVE_AT ARG_LIST 0)
get_property(list GLOBAL PROPERTY ${name}_Files)
foreach(entry ${ARG_LIST})
list(APPEND list ${entry})
endforeach()
set_property(GLOBAL PROPERTY ${name}_Files ${list})
endif()
endmacro()
macro(gtest_suite_deps name)
if (UNITTESTS)
set(ARG_LIST ${ARGV})
list(REMOVE_AT ARG_LIST 0)
get_property(list GLOBAL PROPERTY ${name}_Deps)
list(APPEND list ${ARG_LIST})
set_property(GLOBAL PROPERTY ${name}_Deps ${list})
endif()
endmacro()
macro(gtest_suite_end name)
if (UNITTESTS)
project(${name})
get_property(srcs GLOBAL PROPERTY ${name}_Sources)
get_property(deps GLOBAL PROPERTY ${name}_Deps)
generate_unity_sources(SOURCES TARGET ${name} SRCS ${srcs})
set_target_properties(${name} PROPERTIES OUTPUT_NAME "${CMAKE_PROJECT_NAME}-${name}")
set_target_properties(${name} PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${name}"
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${name}"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${name}"
)
foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
set_target_properties(${name} PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_BINARY_DIR}/${name}"
LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_BINARY_DIR}/${name}"
RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_BINARY_DIR}/${name}"
)
endforeach()
get_property(models GLOBAL PROPERTY ${name}_Models)
foreach(entry ${models})
string(REPLACE ":" ";" inout ${entry})
list(GET inout 0 in)
list(GET inout 1 out)
generate_db_models(${name} ${in} ${out})
endforeach()
get_property(files GLOBAL PROPERTY ${name}_Files)
foreach (datafile ${files})
string(REGEX REPLACE "^[^/]+" "" target_datafile "${datafile}")
string(LENGTH ${target_datafile} target_datafile_length)
string(SUBSTRING ${target_datafile} 1 ${target_datafile_length} target_datafile)
get_filename_component(datafiledir ${target_datafile} DIRECTORY)
get_filename_component(filename ${target_datafile} NAME)
configure_file(${DATA_DIR}/${datafile} ${CMAKE_BINARY_DIR}/${name}/${datafiledir}/${filename} COPYONLY)
endforeach()
target_link_libraries(${name} ${deps})
set_target_properties(${name} PROPERTIES FOLDER ${name})
add_test(NAME ${name} COMMAND $<TARGET_FILE:${name}>)
add_custom_target(${name}-run COMMAND $<TARGET_FILE:${name}> DEPENDS ${name} WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/${name}")
engine_add_debuggger(${name})
engine_add_valgrind(${name})
engine_add_perf(${name})
endif()
endmacro()
macro(check_lua_files TARGET)
set(files ${ARGV})
list(REMOVE_AT files 0)
find_program(LUAC_EXECUTABLE NAMES ${DEFAULT_LUAC_EXECUTABLE})
if (LUAC_EXECUTABLE)
message("${LUA_EXECUTABLE} found")
foreach(_file ${files})
get_filename_component(filename ${_file} NAME)
string(REGEX REPLACE "[/]" "_" targetname ${_file})
add_custom_target(
${targetname}
COMMAND ${LUAC_EXECUTABLE} -o ${CMAKE_CURRENT_BINARY_DIR}/${filename}.out ${_file}
COMMENT "Validate ${_file}"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lua/
)
add_dependencies(${TARGET} ${targetname})
endforeach()
else()
foreach(_file ${files})
string(REGEX REPLACE "[/]" "_" targetname ${_file})
get_filename_component(filename ${_file} NAME)
add_custom_target(
${targetname}
COMMAND $<TARGET_FILE:luac> -o ${CMAKE_CURRENT_BINARY_DIR}/${filename}.out ${_file}
COMMENT "Validate ${_file}"
DEPENDS luac
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lua/
)
add_dependencies(${TARGET} ${targetname})
endforeach()
endif()
endmacro()
macro(check_ui_turbobadger TARGET)
set(_workingdir "${DATA_DIR}/${TARGET}")
set(_dir "${_workingdir}/ui/window")
file(GLOB UI_FILES ${_dir}/*.tb.txt)
foreach(_file ${UI_FILES})
get_filename_component(_filename ${_file} NAME)
add_custom_target(
${_filename}
COMMAND $<TARGET_FILE:uitool> ui/window/${_filename}
COMMENT "Validate ui file: ${_filename}"
DEPENDS uitool
WORKING_DIRECTORY ${_workingdir}
)
add_dependencies(${TARGET} ${_filename})
endforeach()
if (UI_FILES)
add_dependencies(${TARGET} uitool)
endif()
endmacro()
macro(engine_install TARGET FILE DESTINATION INSTALL_DATA)
set(INSTALL_DATA_DIR "${CMAKE_INSTALL_DATADIR}/${CMAKE_PROJECT_NAME}-${TARGET}")
if (INSTALL_DATA)
@ -1021,7 +175,6 @@ macro(engine_target_link_libraries)
string(REGEX REPLACE "^[^/]+" "" target_datafile "${datafile}")
string(LENGTH ${target_datafile} target_datafile_length)
string(SUBSTRING ${target_datafile} 1 ${target_datafile_length} target_datafile)
message(STATUS "${name}: ${target_datafile} => ${datafile}")
get_filename_component(datafiledir ${target_datafile} DIRECTORY)
engine_install(${_LIBS_TARGET} "${datafile}" "${datafiledir}" ${INSTALL_DATA})
endforeach()

18
cmake/manifests.cmake Normal file
View File

@ -0,0 +1,18 @@
#
# Replace variables in the templates to create openshift/kubernetes manifests
# Variables:
# * DOCKER_IMAGE_NAME_TAG: The name of the docker image that is created or used in the deployment
# * FQDN: The domain name where all the services are running with
# * PROJECT_NAME: The project() variable of the service to create the manifests for
#
# There can be other variables of course that are service dependent.
#
# The DOCKER_IMAGE_NAME_TAG variable that is set here, must be in sync with the docker target
#
macro(engine_manifests NAME)
set(DOCKER_IMAGE_NAME_TAG "${NAME}:${ROOT_PROJECT_VERSION}")
foreach (FILEPATH ${ARGN})
get_filename_component(FILENAME ${FILEPATH} NAME_WE)
configure_file(${FILEPATH} ${CMAKE_CURRENT_BINARY_DIR}/deployment/${FILENAME}.yaml)
endforeach()
endmacro()

13
cmake/perf.cmake Normal file
View File

@ -0,0 +1,13 @@
macro(engine_add_perf TARGET)
find_program(PERF_EXECUTABLE NAMES perf)
if (PERF_EXECUTABLE)
add_custom_target(${TARGET}-perf)
add_custom_command(TARGET ${TARGET}-perf
COMMAND
${PERF_EXECUTABLE} record --call-graph dwarf
$<TARGET_FILE:${TARGET}>
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
endif()
endmacro()

19
cmake/ui.cmake Normal file
View File

@ -0,0 +1,19 @@
macro(check_ui_turbobadger TARGET)
set(_workingdir "${DATA_DIR}/${TARGET}")
set(_dir "${_workingdir}/ui/window")
file(GLOB UI_FILES ${_dir}/*.tb.txt)
foreach(_file ${UI_FILES})
get_filename_component(_filename ${_file} NAME)
add_custom_target(
${_filename}
COMMAND $<TARGET_FILE:uitool> ui/window/${_filename}
COMMENT "Validate ui file: ${_filename}"
DEPENDS uitool
WORKING_DIRECTORY ${_workingdir}
)
add_dependencies(${TARGET} ${_filename})
endforeach()
if (UI_FILES)
add_dependencies(${TARGET} uitool)
endif()
endmacro()

31
cmake/util.cmake Normal file
View File

@ -0,0 +1,31 @@
# some cross compiling toolchains define this
if(NOT COMMAND find_host_program)
macro(find_host_program)
find_program(${ARGN})
endmacro()
endif()
macro(convert_to_camel_case IN OUT)
string(REPLACE "-" "_" _list ${IN})
string(REPLACE "_" ";" _list ${_list})
set(_final "")
if (_list)
foreach(_e ${_list})
string(SUBSTRING ${_e} 0 1 _first_letter)
string(TOUPPER ${_first_letter} _first_letter)
string(SUBSTRING ${_e} 1 -1 _remaining)
set(_final "${_final}${_first_letter}${_remaining}")
endforeach()
else()
string(SUBSTRING ${IN} 0 1 _first_letter)
string(TOUPPER ${_first_letter} _first_letter)
string(SUBSTRING ${IN} 1 -1 _remaining)
set(_final "${_final}${_first_letter}${_remaining}")
endif()
set(${OUT} ${_final})
endmacro()
macro(engine_mark_as_generated)
set_source_files_properties(${ARGN} PROPERTIES GENERATED TRUE)
#set_source_files_properties(${ARGN} PROPERTIES LANGUAGE CXX)
endmacro()

40
cmake/valgrind.cmake Normal file
View File

@ -0,0 +1,40 @@
macro(engine_add_valgrind TARGET)
find_program(VALGRIND_EXECUTABLE NAMES valgrind)
if (VALGRIND_EXECUTABLE)
add_custom_target(${TARGET}-memcheckxml)
add_custom_command(TARGET ${TARGET}-memcheckxml
COMMAND
${VALGRIND_EXECUTABLE} --xml=yes --xml-file=${CMAKE_CURRENT_BINARY_DIR}/memcheck-${TARGET}.xml
--tool=memcheck --leak-check=full --show-reachable=yes
--undef-value-errors=yes --track-origins=no --child-silent-after-fork=no
--trace-children=no
$<TARGET_FILE:${TARGET}>
COMMENT "Executing valgrind memcheck and log into ${CMAKE_CURRENT_BINARY_DIR}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
add_custom_target(${TARGET}-memcheck)
add_custom_command(TARGET ${TARGET}-memcheck
COMMAND
${VALGRIND_EXECUTABLE}
--tool=memcheck --leak-check=full --show-reachable=yes
--undef-value-errors=yes --track-origins=no --child-silent-after-fork=no
--trace-children=no --log-file=${CMAKE_CURRENT_BINARY_DIR}/memcheck-${TARGET}.log
$<TARGET_FILE:${TARGET}>
COMMENT "Executing valgrind memcheck and log into ${CMAKE_CURRENT_BINARY_DIR}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
add_custom_target(${TARGET}-helgrind)
add_custom_command(TARGET ${TARGET}-helgrind
COMMAND
${VALGRIND_EXECUTABLE} --xml=yes --xml-file=${CMAKE_BINARY_DIR}/helgrind-${TARGET}.xml
--tool=helgrind --child-silent-after-fork=no
--trace-children=no --log-file=$<TARGET_FILE:${TARGET}>.helgrind.log
$<TARGET_FILE:${TARGET}>
COMMENT "Executing valgrind helgrind and log into ${CMAKE_CURRENT_BINARY_DIR}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
endif()
endmacro()

16
cmake/vogl.cmake Normal file
View File

@ -0,0 +1,16 @@
macro(engina_add_vogl TARGET)
find_program(VOGL_EXECUTABLE NAMES vogl)
if (VOGL_EXECUTABLE)
add_custom_target(${TARGET}-vogl)
add_custom_command(TARGET ${TARGET}-vogl
COMMAND
${VOGL_EXECUTABLE} trace --vogl_tracepath ${CMAKE_BINARY_DIR}
--vogl_tracefile ${TARGET}.trace.bin
--vogl_force_debug_context
$<TARGET_FILE:${TARGET}>
COMMENT "vogl trace file for ${TARGET}: ${CMAKE_BINARY_DIR}/${TARGET}.trace.bin"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${TARGET}
DEPENDS ${TARGET}
)
endif()
endmacro()