minetest-mapper-cpp/CMakeLists.txt

project(minetestmapper CXX)
cmake_minimum_required(VERSION 2.6)
cmake_policy(SET CMP0003 NEW)
set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)

set(VERSION_MAJOR 1)
set(VERSION_MINOR 0)
set(VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}")

# try_compile does not remove the temporary build directory, so put it in CMakeFiles...
# Also: use absolute paths; cmake chokes on relative paths :-(
try_compile(CXX_C0X_SUPPORTED "${CMAKE_HOME_DIRECTORY}/CMakeFiles/CMakeTmp/c0x-test" "${CMAKE_HOME_DIRECTORY}/empty.cpp" CMAKE_FLAGS "-std=c++0x")
if(CXX_C0X_SUPPORTED)
	# Yes, I *know* c++0x is *not* an official C++ standard...
	message(STATUS "Compiler: C++ standard version 'c++0x' is supported")
elseif(CXX_C0X_SUPPORTED)
	message(FATAL_ERROR "Compiler: C++ standard version c++0x is not supported")
endif(CXX_C0X_SUPPORTED)
try_compile(CXX_C11_SUPPORTED "${CMAKE_HOME_DIRECTORY}/CMakeFiles/CMakeTmp/c11-test" "${CMAKE_HOME_DIRECTORY}/empty.cpp" CMAKE_FLAGS "-std=c++11")
if(CXX_C11_SUPPORTED)
	message(STATUS "Compiler: C++ standard version 'c++11' is supported")
else(CXX_C11_SUPPORTED)
	message(STATUS "Compiler: C++ standard version 'c++11' is not supported")
endif(CXX_C11_SUPPORTED)

# Determine C++ standard to use
# If CXX_CXX_STANDARD is empty, use autodetected c++ standard version
set(CXX_CXX_STANDARD "" CACHE STRING "C++ standard version to use. Leave empty, or set to c++11 or c++0x")
string(COMPARE NOTEQUAL "${CXX_CXX_STANDARD}" "" CXX_CXX_STANDARD_OVERRIDE)
if(CXX_CXX_STANDARD_OVERRIDE)
	string(COMPARE EQUAL "${CXX_CXX_STANDARD}" "c++11" CXX_C11_REQUESTED)
	string(COMPARE EQUAL "${CXX_CXX_STANDARD}" "c++0x" CXX_C0X_REQUESTED)
	if(CXX_C11_REQUESTED AND CXX_C11_SUPPORTED)
		message(STATUS "Compiler: C++ standard version 'c++11' selected (as requested)")
		set(CXX_USE_CXX_STANDARD "c++11")
	elseif(CXX_C11_REQUESTED AND NOT CXX_C11_SUPPORTED)
		message(FATAL_ERROR "Compiler: requested standard version '${CXX_CXX_STANDARD}' is not supported")
	elseif(CXX_C0X_REQUESTED)
		message(STATUS "Compiler: C++ standard version 'c++0x' selected (as requested)")
		set(CXX_USE_CXX_STANDARD "c++0x")
	else(CXX_C11_REQUESTED AND CXX_C11_SUPPORTED)
		message(FATAL_ERROR "Unrecognised c++ standard version requested: ${CXX_CXX_STANDARD}")
	endif(CXX_C11_REQUESTED AND CXX_C11_SUPPORTED)
else(CXX_CXX_STANDARD_OVERRIDE)
	if(CXX_C11_SUPPORTED)
		message(STATUS "Compiler: C++ standard version 'c++11' selected")
		set(CXX_USE_CXX_STANDARD "c++11")
	else(CXX_C11_SUPPORTED)
		message(STATUS "Compiler: C++ standard version 'c++0x' selected (c++11 not supported)")
		set(CXX_USE_CXX_STANDARD "c++0x")
	endif(CXX_C11_SUPPORTED)
endif(CXX_CXX_STANDARD_OVERRIDE)

# Clean targets after change in c++ standard, and remember current standard
string(COMPARE EQUAL "${CXX_CXX_STANDARD_LAST}" "" FIRST_CXX_STANDARD)
string(COMPARE NOTEQUAL "${CXX_CXX_STANDARD_LAST}" "${CXX_USE_CXX_STANDARD}" DIFFERENT_CXX_STANDARD)
set(CXX_CXX_STANDARD_LAST_TEMP "${CXX_CXX_STANDARD_LAST}")
set(CXX_CXX_STANDARD_LAST "${CXX_USE_CXX_STANDARD}" CACHE INTERNAL "Internal use - do not modify")
if(DIFFERENT_CXX_STANDARD AND NOT FIRST_CXX_STANDARD)
	execute_process(COMMAND "${CMAKE_BUILD_TOOL}" clean RESULT_VARIABLE CLEANING_RESULT OUTPUT_QUIET ERROR_QUIET)
	if(CLEANING_RESULT)
		message(STATUS "Clean previous build because of standard change (was: '${CXX_CXX_STANDARD_LAST_TEMP}') (exit: ${CLEANING_RESULT})")
	else(CLEANING_RESULT)
		message(STATUS "Clean previous build because of standard change (was: '${CXX_CXX_STANDARD_LAST_TEMP}')")
	endif(CLEANING_RESULT)
endif(DIFFERENT_CXX_STANDARD AND NOT FIRST_CXX_STANDARD)

set(CMAKE_CXX_FLAGS_RELEASE "-std=${CXX_USE_CXX_STANDARD} -Wall -DNDEBUG")
set(CMAKE_CXX_FLAGS_DEBUG   "-O0 -g -std=${CXX_USE_CXX_STANDARD} -Wall -Wextra -DDEBUG")


# Find libgd
find_library(LIBGD_LIBRARY gd)
find_path(LIBGD_INCLUDE_DIR gd.h)
message (STATUS "libgd library: ${LIBGD_LIBRARY}")
message (STATUS "libgd headers: ${LIBGD_INCLUDE_DIR}")
if(NOT LIBGD_LIBRARY OR NOT LIBGD_INCLUDE_DIR)
	message(FATAL_ERROR "libgd not found!")
endif(NOT LIBGD_LIBRARY OR NOT LIBGD_INCLUDE_DIR)

# Find zlib
find_library(ZLIB_LIBRARY z)
find_path(ZLIB_INCLUDE_DIR zlib.h)
message (STATUS "zlib library: ${ZLIB_LIBRARY}")
message (STATUS "zlib headers: ${ZLIB_INCLUDE_DIR}")
if(NOT ZLIB_LIBRARY OR NOT ZLIB_INCLUDE_DIR)
	message(FATAL_ERROR "zlib not found!")
endif(NOT ZLIB_LIBRARY OR NOT ZLIB_INCLUDE_DIR)

find_package(PkgConfig)
include(FindPackageHandleStandardArgs)

# Find libsqlite3
find_library(SQLITE3_LIBRARY sqlite3)
find_path(SQLITE3_INCLUDE_DIR zlib.h)
message (STATUS "sqlite3 library: ${SQLITE3_LIBRARY}")
message (STATUS "sqlite3 headers: ${SQLITE3_INCLUDE_DIR}")
if(NOT SQLITE3_LIBRARY OR NOT SQLITE3_INCLUDE_DIR)
	message(FATAL_ERROR "sqlite3 not found!")
endif(NOT SQLITE3_LIBRARY OR NOT SQLITE3_INCLUDE_DIR)

# Find leveldb
set(USE_LEVELDB 0)

OPTION(ENABLE_LEVELDB "Enable LevelDB backend")

if(ENABLE_LEVELDB)
	find_library(LEVELDB_LIBRARY leveldb)
	find_path(LEVELDB_INCLUDE_DIR db.h PATH_SUFFIXES leveldb)
	message (STATUS "LevelDB library: ${LEVELDB_LIBRARY}")
	message (STATUS "LevelDB headers: ${LEVELDB_INCLUDE_DIR}")
	if(LEVELDB_LIBRARY AND LEVELDB_INCLUDE_DIR)
		set(USE_LEVELDB 1)
		message(STATUS "LevelDB backend enabled")
		include_directories(${LEVELDB_INCLUDE_DIR})
	else(LEVELDB_LIBRARY AND LEVELDB_INCLUDE_DIR)
		set(USE_LEVELDB 0)
		message(STATUS "LevelDB not found!")
	endif(LEVELDB_LIBRARY AND LEVELDB_INCLUDE_DIR)
endif(ENABLE_LEVELDB)

include_directories(
	"${PROJECT_BINARY_DIR}"
	"${CMAKE_CURRENT_SOURCE_DIR}"
	"${CMAKE_CURRENT_BINARY_DIR}"
	${SQLITE3_INCLUDE_DIR}
	${LIBGD_INCLUDE_DIR}
	${ZLIB_INCLUDE_DIR}
)

configure_file(
	"${PROJECT_SOURCE_DIR}/cmake_config.h.in"
	"${PROJECT_BINARY_DIR}/cmake_config.h"
)
add_definitions ( -DUSE_CMAKE_CONFIG_H )

set(mapper_SRCS
	PixelAttributes.cpp
	PlayerAttributes.cpp
	TileGenerator.cpp
	ZlibDecompressor.cpp
	Color.cpp
	mapper.cpp
	db-sqlite3.cpp
)

if(USE_LEVELDB)
	set(mapper_SRCS ${mapper_SRCS} db-leveldb.cpp)
endif(USE_LEVELDB)

add_executable(minetestmapper
	${mapper_SRCS}
)

target_link_libraries(
	minetestmapper
	${SQLITE3_LIBRARY}
	${LEVELDB_LIBRARY}
	${LIBGD_LIBRARY}
	${ZLIB_LIBRARY}
)

install(FILES "AUTHORS" DESTINATION ".")
install(FILES "COPYING" DESTINATION ".")
install(FILES "README.rst" DESTINATION ".")
install(FILES "colors.txt" DESTINATION ".")

# CPack

set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Overview mapper for Minetest")
set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR})
set(CPACK_PACKAGE_VENDOR "celeron55")
set(CPACK_PACKAGE_CONTACT "Perttu Ahola <celeron55@gmail.com>")

if(WIN32)
	install(FILES "${PROJECT_BINARY_DIR}/minetestmapper.exe" DESTINATION ".")
	set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${VERSION_STRING}-win32")
	set(CPACK_GENERATOR ZIP)
else()
	install(FILES "${PROJECT_BINARY_DIR}/minetestmapper" DESTINATION ".")
	set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${VERSION_STRING}-linux")
	set(CPACK_GENERATOR TGZ)
	set(CPACK_SOURCE_GENERATOR TGZ)
endif()

include(CPack)