CMakeLists.txt

cmake_minimum_required(VERSION 2.8)
project(barony)

if (NOT CMAKE_BUILD_TYPE)
	set (CMAKE_BUILD_TYPE Release)
endif(NOT CMAKE_BUILD_TYPE)

if (DEFINED ENV{STEAMWORKS_ENABLED})
	set (STEAMWORKS_ENABLED $ENV{STEAMWORKS_ENABLED})
endif()

if (NOT DEFINED STEAMWORKS_ENABLED)
	set (STEAMWORKS_ENABLED 0)
endif()

if (DEFINED ENV{OPTIMIZATION_LEVEL})
	set (OPTIMIZATION_LEVEL $ENV{OPTIMIZATION_LEVEL})
else()
	set (OPTIMIZATION_LEVEL "-O3")
endif()

if (DEFINED ENV{EOS_ENABLED})
	set (EOS_ENABLED $ENV{EOS_ENABLED})
endif()

if (NOT DEFINED EOS_ENABLED)
	set (EOS_ENABLED 0)
endif()

# EOS Tokens

if (DEFINED ENV{BUILD_ENV_PR} AND NOT DEFINED BUILD_ENV_PR) # TODO: We should make all environment variable checks in this file not overwrite whatever was explicitly passed in on the command line...
	set (BUILD_ENV_PR $ENV{BUILD_ENV_PR})
endif()
if (EOS_ENABLED AND "${BUILD_ENV_PR}" STREQUAL "")
	message(FATAL_ERROR "BUILD_ENV_PR must be specified if EOS is enabled.")
endif()

if (DEFINED ENV{BUILD_ENV_SA} AND NOT DEFINED BUILD_ENV_SA)
	set (BUILD_ENV_SA $ENV{BUILD_ENV_SA})
endif()
if (EOS_ENABLED AND "${BUILD_ENV_SA}" STREQUAL "")
	message(FATAL_ERROR "BUILD_ENV_SA must be specified if EOS is enabled.")
endif()

if (DEFINED ENV{BUILD_ENV_DE} AND NOT DEFINED BUILD_ENV_DE)
	set (BUILD_ENV_DE $ENV{BUILD_ENV_DE})
endif()
if (EOS_ENABLED AND "${BUILD_ENV_DE}" STREQUAL "")
	message(FATAL_ERROR "BUILD_ENV_DE must be specified if EOS is enabled.")
endif()

if (DEFINED ENV{BUILD_ENV_CC} AND NOT DEFINED BUILD_ENV_CC)
	set (BUILD_ENV_CC $ENV{BUILD_ENV_CC})
endif()
if (EOS_ENABLED AND "${BUILD_ENV_CC}" STREQUAL "")
	message(FATAL_ERROR "BUILD_ENV_CC must be specified if EOS is enabled.")
endif()

if (DEFINED ENV{BUILD_ENV_CS} AND NOT DEFINED BUILD_ENV_CS)
	set (BUILD_ENV_CS $ENV{BUILD_ENV_CS})
endif()
if (EOS_ENABLED AND "${BUILD_ENV_CS}" STREQUAL "")
	message(FATAL_ERROR "BUILD_ENV_CS must be specified if EOS is enabled.")
endif()

if (DEFINED ENV{BUILD_ENV_GSE} AND NOT DEFINED BUILD_ENV_GSE)
	set (BUILD_ENV_GSE $ENV{BUILD_ENV_GSE})
endif()
if (EOS_ENABLED AND "${BUILD_ENV_GSE}" STREQUAL "")
	message(FATAL_ERROR "BUILD_ENV_GSE must be specified if EOS is enabled.")
endif()

if (DEFINED ENV{EDITOR_ENABLED})
	set (EDITOR_ENABLED $ENV{EDITOR_ENABLED})
else()
	set (EDITOR_ENABLED 1)
endif()

if (DEFINED ENV{GAME_ENABLED})
	set (GAME_ENABLED $ENV{GAME_ENABLED})
else()
	set (GAME_ENABLED 1)
endif()

if (DEFINED ENV{BARONY_WIN32_LIBRARIES})
	set (BARONY_WIN32_LIBRARIES $ENV{BARONY_WIN32_LIBRARIES})
endif()

if (NOT "${BARONY_WIN32_LIBRARIES}" STREQUAL "")
	list(APPEND CMAKE_PREFIX_PATH $ENV{BARONY_WIN32_LIBRARIES})
endif(NOT "${BARONY_WIN32_LIBRARIES}" STREQUAL "")

#FMOD can be disabled in one of two ways:
# * Not having FMOD installed will automatically disable FMOD (and, consequently, the game's sound engine as a whole).
# * Running cmake with -DFMOD_ENABLED=OFF
set(FMOD 0) #Acts as an alias to FMOD_FOUND
option(FMOD_ENABLED "Use the FMOD Ex library in the sound engine" ON)
set(OPENAL 0) #Acts as an alias to OPENAL_FOUND
option(OPENAL_ENABLED "Use the OpenAL library in the sound engine" OFF)
set(TREMOR 0) #Acts as an alias to TREMOR_FOUND
option(TREMOR_ENABLED "Use Tremor instead of libvorbis for OpenAL" OFF)

if(FMOD_ENABLED AND OPENAL_ENABLED)
	set(FMOD_ENABLED OFF)
endif()

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")

set(CMAKE_OSX_ARCHITECTURES x86_64)

if (EDITOR_ENABLED)
	set(EDITOR_EXE_NAME "editor" CACHE STRING "Editor executable name")
endif()
option(DATA_DIR "Points to install data directory" FALSE)

if (STEAMWORKS_ENABLED)
	message("------------------------")
	message("Building with steamworks")
	message("------------------------")
else()
	message("------------------------")
	message("Building without steamworks")
	message("------------------------")
endif()

if (EOS_ENABLED)
	message("------------------------")
	message("Building with EOS")
	message("------------------------")
else()
	message("------------------------")
	message("Building without EOS")
	message("------------------------")
endif()

# OS/Platform Flags
set(Apple 0)
set(Windows 0)
set(Linux 0)
set(Bsd 0)
set(Haiku 0)
set(PANDORA 0)
set(NOT_DWORD_DEFINED 0)
option(PANDORA_ENABLED "Build for the OpenPandora" OFF)
if(PANDORA_ENABLED)
	set(PANDORA 1)
endif()

# Set platform-dependent compiler & linker flags
if( NOT WIN32 )
  if(PANDORA)
	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wall -ffast-math -funroll-loops -fstrict-aliasing -mcpu=cortex-a8 -mfpu=neon -mfloat-abi=softfp -g -fuse-ld=gold -fuse-linker-plugin")
	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall ")
	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${OPTIMIZATION_LEVEL} -ffast-math -funroll-loops -fstrict-aliasing -mcpu=cortex-a8 -mfpu=neon -mfloat-abi=softfp -g -fuse-ld=gold -fuse-linker-plugin -fsingle-precision-constant")
	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OPTIMIZATION_LEVEL} -ffast-math -funroll-loops -fstrict-aliasing -mcpu=cortex-a8 -mfpu=neon -mfloat-abi=softfp -g -fuse-ld=gold -fuse-linker-plugin -fsingle-precision-constant")
  else()
	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -pedantic -Wall -pg -ffast-math -funroll-loops -fstrict-aliasing")
	#set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -pg -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover -Wreturn-type -Werror=return-type")
	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -pedantic -Wall -pg")
	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -pedantic ${OPTIMIZATION_LEVEL} -ffast-math -funroll-loops -fstrict-aliasing")
	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -pedantic ${OPTIMIZATION_LEVEL}")
  endif()
  if (APPLE)
	set (Apple 1)
	set (NOT_DWORD_DEFINED 1)
	#set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -x objective-c")
	#set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -x objective-c")
	set(MACOSX_BUNDLE true)
	set(MACOSX_BUNDLE_BUNDLE_NAME Barony)
	#TODO: Make version a define which is also set in src/Config.h
	set(MACOSX_BUNDLE_INFO_STRING Barony 2.0.2)
	set(MACOSX_BUNDLE_LONG_VERSION 2.0.2)
	set(MACOSX_BUNDLE_SHORT_VERSION_STRING 2.0.2)
	set(MACOSX_BUNDLE_BUNDLE_VERSION 2.0.2)
	set(MACOSX_BUNDLE_ICON_FILE "barony.icns")
	#set(MACOSX_BUNDLE_ICON_FILE "game.icns")
	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -std=c++14 -stdlib=libc++ -I/opt/local/include/")
	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++14 -stdlib=libc++ -I/opt/local/include/")
  else()
	set (Apple 0)
	set (Linux 1) #TODO: Should not assume this? What if BSD/DOS/whatever-have-you?
	if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD|NetBSD|DragonFly") # OpenBSD is purposely discarded at it lacks for now current exe path retrieval feature
	   set(Bsd 1)
	endif()
	if (${CMAKE_SYSTEM_NAME} STREQUAL "Haiku")
	   set(Haiku 1)
	endif()
	set (NOT_DWORD_DEFINED 1)
	if (NOT DISABLE_MALIGN_DOUBLE) #Only compile with -malign-double if not told to disable. Pass via command line flags.
	  set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -malign-double")
	  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -malign-double")
	endif()
	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -rdynamic -Wl,-rpath=$ORIGIN")
	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -std=c++14 -rdynamic -Wl,-rpath=$ORIGIN")
	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Wl,-rpath=$ORIGIN -Wno-write-strings")
	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++14 -Wl,-rpath=$ORIGIN")
  endif()

	if (ARCHITECTURE) # TODO: Support this on Windows too.
		set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -mcpu=${ARCHITECTURE}")
		set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_DEBUG} -mcpu=${ARCHITECTURE}")
	endif()
else( NOT WIN32 )
	# These look like mingw to me?
	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wall -pg ${OPTIMIZATION_LEVEL} -ffast-math -funroll-loops -malign-double -fstrict-aliasing -mwindows")
	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${OPTIMIZATION_LEVEL} -ffast-math -funroll-loops -malign-double -fstrict-aliasing -mwindows")
	# We should be using Visual Studio flags...or better yet, providing an option to select which you'd prefer.
	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MP")
	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MP ")
	set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS")
  set (Windows 1)
endif( NOT WIN32 )

if (APPLE)
	set ( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -LD_RUNPATH_SEARCH_PATHS=@loader_path/../Frameworks -rpath @loader_path/../Frameworks")
endif()
set ( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
set ( CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")


IF (APPLE)
  #include_directories(/usr/X11R6/include/)
  #link_directories(/usr/X11R6/lib)
  #FIND_LIBRARY(OpenGL_LIBRARY OpenGL )
  #SET(EXTRA_LIBS ${OpenGL_LIBRARY} X11)
  FIND_LIBRARY(OpenGL_LIBRARY OpenGL )
  SET(EXTRA_LIBS ${OpenGL_LIBRARY})

  #set(CMAKE_LIBRARY_PATH "/Library/Frameworks/")
  find_package(SDL2 REQUIRED)
  find_package(SDL2_image REQUIRED)
  find_package(SDL2_net REQUIRED)
  find_package(SDL2_ttf REQUIRED)
  find_package(IOKit REQUIRED)
ELSE (APPLE)
	find_package(OpenGL REQUIRED)
	IF(NOT WIN32)
		INCLUDE(FindPkgConfig)
		PKG_SEARCH_MODULE(SDL2 REQUIRED sdl2)
		PKG_SEARCH_MODULE(SDL2IMAGE REQUIRED SDL2_image>=2.0.0)
		PKG_SEARCH_MODULE(SDL2NET REQUIRED SDL2_net)
		PKG_SEARCH_MODULE(SDL2TTF REQUIRED SDL2_ttf)
	ELSE(NOT WIN32)
		find_package(SDL2 REQUIRED)
		find_package(SDL2_image REQUIRED)
	ENDIF(NOT WIN32)
	find_package(SDL2_net REQUIRED) # ...why the duplication?
	find_package(SDL2_ttf REQUIRED)
ENDIF (APPLE)
find_package(PhysFS REQUIRED)
find_package(RapidJson REQUIRED)
INCLUDE_DIRECTORIES(${RAPID_JSON_INCLUDE_DIR})
LINK_DIRECTORIES(${RAPID_JSON_LINK_DIR})
INCLUDE_DIRECTORIES(${SDL2_INCLUDE_DIRS} ${SDL2_INCLUDE_DIR} ${SDL2IMAGE_INCLUDE_DIRS} ${SDL2_IMAGE_INCLUDE_DIR} ${SDL2NET_INCLUDE_DIR} ${SDL2_NET_INCLUDE_DIRS} ${SDL2TTF_INCLUDE_DIR}  ${SDL2_TTF_INCLUDE_DIRS} ${PHYSFS_INCLUDE_DIR})
LINK_DIRECTORIES(${SDL2_LINK_DIRS} ${SDL2_LINK_DIR} ${SDL2IMAGE_LINK_DIRS} ${SDL2_IMAGE_LINK_DIR} ${SDL2NET_LINK_DIR} ${SDL2_NET_LINK_DIRS} ${SDL2TTF_LINK_DIR}  ${SDL2_TTF_LINK_DIRS} ${PHYSFS_LINK_DIR})

# if (NOT WIN32)
# else()
#   INCLUDE_DIRECTORIES(${SDL2_INCLUDE_DIRS} ${SDL2IMAGE_INCLUDE_DIRS})
# endif()
if (OPENAL_ENABLED)
  find_package(OpenAL)
  if(TREMOR_ENABLED)
	find_package(TREMOR)
  else()
	find_package(OGGVORBIS)
  endif()
  if (OPENAL_FOUND AND ((TREMOR_ENABLED AND TREMOR_FOUND) OR ((NOT TREMOR_ENABLED) AND OGGVORBIS_FOUND)))
	INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIR})
	if(TREMOR_ENABLED)
	  set(TREMOR 1)
	  INCLUDE_DIRECTORIES(${TREMOR_INCLUDE_DIR})
	else()
	  INCLUDE_DIRECTORIES(${OGG_INCLUDE_DIR} ${VORBIS_INCLUDE_DIR})
	endif()
	set(OPENAL 1)
  endif()
endif()

find_package(Threads REQUIRED)
if(NOT APPLE)
  #Linux needs these two.
  #Macs have their own special line.
  if (FMOD_ENABLED)
	find_package(FMOD)
	if (FMOD_FOUND)
	  set(FMOD 1)
	endif()
  endif()
  find_package(PNG REQUIRED)
elseif (APPLE)
  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FMOD_CXX_FLAGS}")
  MESSAGE("CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
  set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${FMOD_LINK_FLAGS}")
  MESSAGE("CMAKE_EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}")
  if (FMOD_ENABLED)
	set(FMOD 1)
  endif()
endif()

if(STEAMWORKS_ENABLED)
  find_package(STEAMWORKS REQUIRED)
  #find_package(STEAMWORKS_CWRAPPER REQUIRED)
endif()
if (STEAMWORKS_ENABLED)
  #include_directories(${STEAMWORKS_CWRAPPER_INCLUDE_DIR})
  include_directories(${STEAMWORKS_INCLUDE_DIR})
endif()

if(EOS_ENABLED)
  find_package(EOS REQUIRED)
endif()
if (EOS_ENABLED)
  include_directories(${EOS_INCLUDE_DIR})
endif()


# Add include directories
#include_directories(${GLM_INCLUDE_DIR})
if( NOT WIN32 )
  include_directories(${THREADS_INCLUDE_DIR})
endif()
if(NOT APPLE)
  #Remember, Mac doesn't have find_package for fmod and png.
  if (FMOD_FOUND)
	include_directories(${FMOD_INCLUDE_DIR})
  endif()
  include_directories(${PNG_INCLUDE_DIR})
elseif (APPLE)
  if (FMOD_ENABLED)
	include_directories("${PROJECT_SOURCE_DIR}/libraries/fmod/inc")
	link_directories("${PROJECT_SOURCE_DIR}/libraries/fmod/lib")
  endif()
endif()

# Add the source directory
#file(GLOB_RECURSE SOURCE_FILES src/*.c src/*.h) # Can't do this because it'd then compile barony and editor together. Which just won't work.
#file(GLOB_RECURSE BOOK_FILES books/*)
#file(GLOB_RECURSE IMAGE_FILES images/*)
#file(GLOB_RECURSE ITEM_FILES items/*)
#file(GLOB_RECURSE MAP_FILES maps/*)
#file(GLOB_RECURSE MODEL_FILES models/*)
#file(GLOB_RECURSE MUSIC_FILES music/*)
#file(GLOB_RECURSE SOUND_FILES sound/*)

#add_subdirectory(books)
 
configure_file ( "${PROJECT_SOURCE_DIR}/src/Config.hpp.in" "${PROJECT_SOURCE_DIR}/src/Config.hpp")

message("***************************")
message("Debug flags: ")
message("${CMAKE_C_FLAGS_DEBUG}")
message("${CMAKE_CXX_FLAGS_DEBUG}")
#-g -Wall -pg -ffast-math -funroll-loops -fstrict-aliasing
message("Release flags: ")
message("${CMAKE_C_FLAGS_RELEASE}")
message("${CMAKE_CXX_FLAGS_RELEASE}")
#-O3 -DNDEBUG -Wall -pg -ffast-math -funroll-loops -fstrict-aliasing
message("***************************")


add_subdirectory(src)
if( WIN32 )
	set(GAME_RESOURCE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/barony.rc")
	set(EDITOR_RESOURCE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/editor.rc")
endif()

#ADD_DEFINITONS(${PNG_DEFINITIONS})
if (APPLE)
  set(COPY_FRAMEWORKS ${PROJECT_SOURCE_DIR}/../Frameworks/SDL.framework ${PROJECT_SOURCE_DIR}/../Frameworks/SDL_image.framework ${PROJECT_SOURCE_DIR}/../Frameworks/SDL_mixer.framework ${PROJECT_SOURCE_DIR}/../Frameworks/SDL_net.framework)
  message("{COPY_FRAMEWORKS}: ${COPY_FRAMEWORKS}")
  if (FMOD_ENABLED)
	SET_SOURCE_FILES_PROPERTIES(libfmodex.dylib PROPERTIES MACOSX_PACKAGE_LOCATION MacOS)
  endif()
  #add_executable(barony MACOSX_BUNDLE OSX/SDLmain.m ${GAME_SOURCES} ${COPY_FRAMEWORKS} ${BOOK_FILES} ${IMAGE_FILES} ${ITEM_FILES} ${MAP_FILES} ${MODEL_FILES} ${MUSIC_FILES} ${SOUND_FILES} libfmodex.dylib)
  #add_executable(barony MACOSX_BUNDLE OSX/SDLmain.m ${GAME_SOURCES} ${COPY_FRAMEWORKS} libfmodex.dylib /opt/local/lib/libpng16.16.dylib)
  #add_executable(barony MACOSX_BUNDLE OSX/SDLmain.m ${GAME_SOURCES} ${MACOSX_BUNDLE_ICON_FILE} libfmodex.dylib /opt/local/lib/libpng16.16.dylib)
  if (GAME_ENABLED)
	if (FMOD_ENABLED)
	  add_executable(barony MACOSX_BUNDLE ${GAME_SOURCES} ${MACOSX_BUNDLE_ICON_FILE} libfmodex.dylib ${PROJECT_SOURCE_DIR}/libpng16.16.dylib)
	else()
	  add_executable(barony MACOSX_BUNDLE ${GAME_SOURCES} ${MACOSX_BUNDLE_ICON_FILE} ${PROJECT_SOURCE_DIR}/libpng16.16.dylib)
	endif(FMOD_ENABLED)
  #add_executable(barony OSX/SDLmain.m ${GAME_SOURCES})
  #add_executable(barony ${GAME_SOURCES})
  #SET_SOURCE_FILES_PROPERTIES(${COPY_FRAMEWORKS} PROPERTIES MACOSX_PACKAGE_LOCATION Frameworks)
  #SET_SOURCE_FILES_PROPERTIES(${BOOK_FILES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources/books/)
  #SET_SOURCE_FILES_PROPERTIES(${IMAGE_FILES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources/images/)
  #SET_SOURCE_FILES_PROPERTIES(${ITEM_FILES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources/items/)
  #SET_SOURCE_FILES_PROPERTIES(${MAP_FILES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources/maps/)
  #SET_SOURCE_FILES_PROPERTIES(${MODEL_FILES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources/models/)
  #SET_SOURCE_FILES_PROPERTIES(${MUSIC_FILES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources/music/)
  #SET_SOURCE_FILES_PROPERTIES(${SOUND_FILES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources/sound/)
	set_source_files_properties(${GAME_SOURCES} PROPERTIES COMPILE_FLAGS "-x objective-c++")
  endif(GAME_ENABLED)
  SET_SOURCE_FILES_PROPERTIES(${PROJECT_SOURCE_DIR}/libpng16.16.dylib PROPERTIES MACOSX_PACKAGE_LOCATION MacOS)
  SET_SOURCE_FILES_PROPERTIES(${COPY_RESOURCES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
  SET_SOURCE_FILES_PROPERTIES(${MACOSX_BUNDLE_ICON_FILE} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
  #set_source_files_properties(${GAME_SOURCES} PROPERTIES COMPILE_FLAGS "-stdlib=libc++")
else()
  if (GAME_ENABLED)
	add_executable(barony ${GAME_SOURCES} ${GAME_RESOURCE_FILE})
  endif (GAME_ENABLED)
endif(APPLE)

if (GAME_ENABLED)
  if(WIN32)
    # Only for MinGW...
	# target_link_libraries(barony -lmingw32)
	# target_link_libraries(barony -lSDL2main)
	# target_link_libraries(barony -lSDL2)
	# target_link_libraries(barony -lSDL2_net)
	# target_link_libraries(barony -lSDL2_image)
	# target_link_libraries(barony -lSDL2_ttf)
	# if(STEAMWORKS_ENABLED)
	#   #target_link_libraries(barony -lsteamworks_cwrapper -lstdc++)
	#   target_link_libraries(barony -lsteam_api)
	# endif()
	# if(EOS_ENABLED)
	#   target_link_libraries(barony -lsteam_api) #TODO: Fix for Windows.
	# endif()
	target_link_libraries(barony ${SDL2_LIBRARIES} ${SDL2_LIBRARY} ${SDL2IMAGE_LIBRARIES} ${SDL2_IMAGE_LIBRARIES} ${SDL2_NET_LIBRARIES} ${SDL2_TTF_LIBRARIES} ${SDL2TTF_LIBRARY})
	if (STEAMWORKS_ENABLED)
		target_link_libraries(barony ${STEAMWORKS_LIBRARY})
	endif()
	if (EOS_ENABLED)
		target_link_libraries(barony ${EOS_LIBRARIES})
	endif()
  else(WIN32)
	if( ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") AND (NOT APPLE) )
	  # 64 bit
	  target_link_libraries(barony -L/usr/lib64 -lstdc++)
	endif()
	target_link_libraries(barony ${SDL2_LIBRARIES} ${SDL2_LIBRARY} ${SDL2IMAGE_LIBRARIES} ${SDL2_IMAGE_LIBRARIES} ${SDL2_NET_LIBRARIES} ${SDL2_TTF_LIBRARIES} ${SDL2TTF_LIBRARY})
	if (STEAMWORKS_ENABLED)
	  target_link_libraries(barony ${STEAMWORKS_LIBRARY})
	  #target_link_libraries(barony ${STEAMWORKS_CWRAPPER_LIBRARIES} -lstdc++)
	endif()
	if (EOS_ENABLED)
	  target_link_libraries(barony ${EOS_LIBRARIES})
	endif()
	if (APPLE)
	  target_link_libraries(barony ${PROJECT_SOURCE_DIR}/libpng16.16.dylib) #Wait...what? if(APPLE) in if(WIN32)? What was I thinking back then, haha.
	endif()
	if (${CMAKE_SYSTEM_NAME} MATCHES "BSD|DragonFly" OR ${CMAKE_SYSTEM_NAME} STREQUAL "Haiku")
	  # For backtrace
	  find_path(EXECINFO_INC NAMES execinfo.h)
	  find_library(EXECINFO_LIB NAMES execinfo)
	  include_directories(${EXECINFO_INC})
	  target_link_libraries(barony ${EXECINFO_LIB})
	endif()
  endif()
  target_link_libraries(barony ${OPENGL_LIBRARIES})
  target_link_libraries(barony ${THREADS_LIBRARIES})
  target_link_libraries(barony -lm) # TODO: In Visual Studio, I bet this is something else, right?
  if (NOT CMAKE_SYSTEM_NAME MATCHES "Haiku")
	  target_link_libraries(barony -lc)
  endif()
  if(NOT APPLE)
	#Remember, Mac isn't using find_package for FMOD and PNG.
	target_link_libraries(barony ${PNG_LIBRARY})
	target_link_libraries(barony ${PHYSFS_LIBRARY})
	if (FMOD_FOUND)
	  target_link_libraries(barony ${FMOD_LIBRARY})
	endif()
  endif()
  if (APPLE)
	target_link_libraries(barony ${PHYSFS_LIBRARY})
	target_link_libraries(barony ${IOKit_LIBRARY})
  endif()
  # We need to link to Winsock if we're on Windows
  if(WIN32)
	target_link_libraries(barony wsock32 ws2_32)
	#target_link_libraries(barony -lpng -lfmodex) Mingw, not Visual Studio.
  endif()
  if(APPLE)
	if (FMOD_ENABLED)
	  target_link_libraries(barony -lfmodex) #Finally manually link fmod for mac.
	endif()
  endif(APPLE)
  target_link_libraries(barony ${EXTRA_LIBS}) #Apple needs this for OpenGL to work.

  if (OPENAL)
	target_link_libraries(barony ${OPENAL_LIBRARY})
	if(TREMOR_ENABLED)
	  target_link_libraries(barony ${TREMOR_LIBRARY})
	else()
	  target_link_libraries(barony ${VORBISFILE_LIBRARY} ${OGG_LIBRARY})
	endif()
  endif()
endif(GAME_ENABLED)

set(BASE_DATA_DIR "./" CACHE INTERNAL "Base data dir")

if (NOT APPLE AND UNIX)
  include(GNUInstallDirs)
  if (DATA_DIR)
	set(BASE_DATA_DIR "${CMAKE_INSTALL_FULL_DATAROOTDIR}/barony")
  endif()
  message(STATUS "Base data directory ${BASE_DATA_DIR}")

  if (GAME_ENABLED)
	install(TARGETS barony
	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
	COMPONENT Runtime
	)
  endif(GAME_ENABLED)
else()
  if (GAME_ENABLED)
	install(TARGETS barony
	  RUNTIME DESTINATION bin COMPONENT Runtime BUNDLE DESTINATION Resources
	)
  endif(GAME_ENABLED)
endif()

add_definitions(-DBASE_DATA_DIR=\"${BASE_DATA_DIR}\")

if (EDITOR_ENABLED)
  if (APPLE)
	#add_executable(editor OSX/SDLmain.m ${EDITOR_SOURCES})
	#set(MACOSX_BUNDLE_ICON_FILE "${PROJECT_SOURCE_DIR}/editor.icns")
	#add_executable(editor MACOSX_BUNDLE OSX/SDLmain.m ${EDITOR_SOURCES} ${COPY_FRAMEWORKS} libfmodex.dylib  /opt/local/lib/libpng16.16.dylib)
	#add_executable(editor MACOSX_BUNDLE OSX/SDLmain.m ${EDITOR_SOURCES} libfmodex.dylib  /opt/local/lib/libpng16.16.dylib)
	if (FMOD_ENABLED)
	  add_executable(${EDITOR_EXE_NAME} MACOSX_BUNDLE ${EDITOR_SOURCES} libfmodex.dylib ${PROJECT_SOURCE_DIR}/libpng16.16.dylib)
	else()
	  add_executable(${EDITOR_EXE_NAME} MACOSX_BUNDLE ${EDITOR_SOURCES} ${PROJECT_SOURCE_DIR}/libpng16.16.dylib)
	endif()
	#SET_SOURCE_FILES_PROPERTIES(${MACOSX_BUNDLE_ICON_FILE} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
	set_source_files_properties(${EDITOR_SOURCES} PROPERTIES COMPILE_FLAGS "-x objective-c++")
  else()
	add_executable(${EDITOR_EXE_NAME} ${EDITOR_SOURCES} ${EDITOR_RESOURCE_FILE})
  endif()
  target_compile_definitions(${EDITOR_EXE_NAME} PUBLIC EDITOR) # So that shared source files know this is the editor they're dealing with.

  target_link_libraries(${EDITOR_EXE_NAME} ${SDL2_LIBRARIES} ${SDL2_LIBRARY} ${SDL2IMAGE_LIBRARIES} ${SDL2_IMAGE_LIBRARIES} ${SDL2_NET_LIBRARIES} ${SDL2_TTF_LIBRARIES} ${SDL2TTF_LIBRARY})
  if(STEAMWORKS_ENABLED)
	target_link_libraries(${EDITOR_EXE_NAME} ${STEAMWORKS_LIBRARY})
  endif()
  if(WIN32)
	if (EOS_ENABLED)
	  target_link_libraries(${EDITOR_EXE_NAME} ${EOS_LIBRARY}) #TODO: Fix for Windows.
	endif()
  else()
	if( ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") AND (NOT APPLE))
	  # 64 bit
	  target_link_libraries(${EDITOR_EXE_NAME} -L/usr/lib64 -lstdc++)
	endif()
  endif()
  target_link_libraries(${EDITOR_EXE_NAME} ${OPENGL_LIBRARIES})
  target_link_libraries(${EDITOR_EXE_NAME} ${THREADS_LIBRARIES})
  target_link_libraries(${EDITOR_EXE_NAME} -lm) # TODO: Only for Mingw?
  if (NOT CMAKE_SYSTEM_NAME MATCHES "Haiku")
	  target_link_libraries(${EDITOR_EXE_NAME} -lc)
  endif()
  # We need to link to Winsock if we're on Windows
  if(NOT APPLE)
	#Remember, Mac isn't using find_package for FMOD and PNG.
	target_link_libraries(${EDITOR_EXE_NAME} ${PHYSFS_LIBRARY})
	target_link_libraries(${EDITOR_EXE_NAME} ${PNG_LIBRARY})
	if (FMOD_FOUND)
	  target_link_libraries(${EDITOR_EXE_NAME} ${FMOD_LIBRARY})
	endif()
  endif()
  if (APPLE)
	target_link_libraries(${EDITOR_EXE_NAME} ${PHYSFS_LIBRARY})
	target_link_libraries(${EDITOR_EXE_NAME} ${IOKit_LIBRARY})
	if (EOS_ENABLED)
	  target_link_libraries(${EDITOR_EXE_NAME} ${EOS_LIBRARY})
	endif()
  endif()
  if(WIN32)
	target_link_libraries(${EDITOR_EXE_NAME} wsock32 ws2_32)
  endif()
  if (APPLE)
	if (FMOD_ENABLED)
	  target_link_libraries(${EDITOR_EXE_NAME} -lfmodex) #Finally manually link fmod for mac.
	endif()
  endif()
  target_link_libraries(${EDITOR_EXE_NAME} ${EXTRA_LIBS}) #Apple needs this for OpenGL to work.
  if (OPENAL)
	target_link_libraries(${EDITOR_EXE_NAME} ${OPENAL_LIBRARY})
	if(TREMOR_ENABLED)
	  target_link_libraries(${EDITOR_EXE_NAME} ${TREMOR_LIBRARY})
	else()
	  target_link_libraries(${EDITOR_EXE_NAME} ${VORBISFILE_LIBRARY})
	endif()
  endif()
endif(EDITOR_ENABLED)

if (NOT APPLE AND UNIX)
  if (EDITOR_ENABLED)
	install(TARGETS ${EDITOR_EXE_NAME}
	  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT Runtime
	)
  endif()

  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lang DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/barony)

  if (EXISTS books)
	install(DIRECTORY 
		${CMAKE_CURRENT_BINARY_DIR}/books ${CMAKE_CURRENT_BINARY_DIR}/images ${CMAKE_CURRENT_BINARY_DIR}/items
		${CMAKE_CURRENT_BINARY_DIR}/maps ${CMAKE_CURRENT_BINARY_DIR}/models ${CMAKE_CURRENT_BINARY_DIR}/music
		${CMAKE_CURRENT_BINARY_DIR}/sound DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/barony
	)
  endif()
endif()

if (APPLE)
#  SET_TARGET_PROPERTIES(
#    barony
#    PROPERTIES
#    RESOURCE ${BOOK_FILES} ${IMAGE_FILES} ${ITEM_FILES} ${MAP_FILES} ${MODEL_FILES} ${MUSIC_FILES} ${SOUND_FILES}
#  )
endif()