CMakeLists.txt

cmake_minimum_required(VERSION 2.8)
project(barony)

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

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})
else()
  set (STEAMWORKS_ENABLED 0)
endif()

#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)
option(TREMOR_ENABLED "Use Tremor instead of libvorbis for OpenAL" OFF)

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

set(PANDORA 0)
option(PANDORA_ENABLED "Build for the OpenPandora" OFF)
if(PANDORA_ENABLED)
  set(PANDORA 1)
endif()

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

set(CMAKE_OSX_ARCHITECTURES x86_64)

set(EDITOR_EXE_NAME "editor" CACHE STRING "Editor executable name")
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()

set (Apple 0)
set (Windows 0)
set (Linux 0)
set (NOT_DWORD_DEFINED 0)
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} -O3 -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} -O3 -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} -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} -Wall -pg")
  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -ffast-math -funroll-loops -fstrict-aliasing")
  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
  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++11 -stdlib=libc++")
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++11 -stdlib=libc++")
  else()
    set (Apple 0)
    set (Linux 1) #TODO: Should not assume this? What if BSD/DOS/whatever-have-you?
    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++11 -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++11 -Wl,-rpath=$ORIGIN -Wno-write-strings")
  endif()
else()
  set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wall -pg -O3 -ffast-math -funroll-loops -malign-double -fstrict-aliasing -mwindows")
  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -ffast-math -funroll-loops -malign-double -fstrict-aliasing -mwindows")
  set (Windows 1)
endif()

if (ARCHITECTURE)
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -mcpu=${ARCHITECTURE}")
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_DEBUG} -mcpu=${ARCHITECTURE}")
endif()

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


# Find OpenGL
if (NOT APPLE)
  find_package(OpenGL REQUIRED)
endif()
#find_package(GLM REQUIRED)

if (NOT WIN32)
  if (NOT APPLE)
    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)
    find_package(SDL2_net REQUIRED)
    find_package(SDL2_ttf REQUIRED)
  endif()
  find_package(PhysFS REQUIRED)
endif()

if (NOT WIN32)
  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})
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 WIN32 AND NOT APPLE)
  #Linux needs these two.
  #Windows has manual links later on.
  #And 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)
  #This is to make libpng work on Macs.
  exec_program(libpng-config ARGS --cflags
    OUTPUT_VARIABLE FMOD_CXX_FLAGS)
  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FMOD_CXX_FLAGS}")
  MESSAGE("CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
  exec_program(libpng-config ARGS --ldflags
    OUTPUT_VARIABLE FMOD_LINK_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( NOT WIN32 AND 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()


# Add include directories
#include_directories(${GLM_INCLUDE_DIR})
if( NOT WIN32 )
  include_directories(${THREADS_INCLUDE_DIR})
endif()
if(NOT WIN32 AND NOT APPLE)
  #Remember, Windows and Mac don'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()

  find_package(GLUT REQUIRED)
  include_directories(${GLUT_INCLUDE_DIR})
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)

#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}")
#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 (FMOD_ENABLED)
  add_executable(barony MACOSX_BUNDLE ${GAME_SOURCES} ${MACOSX_BUNDLE_ICON_FILE} libfmodex.dylib /opt/local/lib/libpng16.16.dylib)
else()
  add_executable(barony MACOSX_BUNDLE ${GAME_SOURCES} ${MACOSX_BUNDLE_ICON_FILE} /opt/local/lib/libpng16.16.dylib)
endif()
#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/)
if (FMOD_ENABLED)
  SET_SOURCE_FILES_PROPERTIES(libfmodex.dylib PROPERTIES MACOSX_PACKAGE_LOCATION MacOS)
endif()
SET_SOURCE_FILES_PROPERTIES(/opt/local/lib/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 "-x objective-c++")
#set_source_files_properties(${GAME_SOURCES} PROPERTIES COMPILE_FLAGS "-stdlib=libc++")
else()
add_executable(barony ${GAME_SOURCES})
endif()

if(WIN32)
  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()
else()
  if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
    # 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 (APPLE)
    target_link_libraries(barony ${GLUT_LIBRARIES})
  endif()
  if (${CMAKE_SYSTEM_NAME} MATCHES "BSD")
    # 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 -lc)
if( NOT WIN32 AND NOT APPLE)
  #Remember, Windows and Mac aren'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)
endif()
if(APPLE)
  if (FMOD_ENABLED)
    target_link_libraries(barony -lfmodex) #Finally manually link fmod for mac.
  endif()
endif()
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()

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

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

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

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  /opt/local/lib/libpng16.16.dylib)
  else()
	  add_executable(${EDITOR_EXE_NAME} MACOSX_BUNDLE ${EDITOR_SOURCES} /opt/local/lib/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})
endif()

if(WIN32)
	target_link_libraries(${EDITOR_EXE_NAME} -lmingw32 -lSDL2main -lSDL2 -lSDL2_net -lSDL2_image -lSDL2_ttf)
  if(STEAMWORKS_ENABLED)
    #target_link_libraries(editor -lsteamworks_cwrapper -lstdc++)
    target_link_libraries(${EDITOR_EXE_NAME} -lsteam_api)
  endif()
else()
  if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
    # 64 bit
    target_link_libraries(${EDITOR_EXE_NAME} -L/usr/lib64 -lstdc++)
  endif()
  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})
    #target_link_libraries(editor ${STEAMWORKS_CWRAPPER_LIBRARIES} -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 -lc)
# We need to link to Winsock if we're on Windows
if( NOT WIN32 AND NOT APPLE)
  #Remember, Windows and Mac aren'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})
endif()
if(WIN32)
	target_link_libraries(${EDITOR_EXE_NAME} wsock32 ws2_32)
	target_link_libraries(${EDITOR_EXE_NAME} -lfmodex)
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()

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

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