CMAKE_MINIMUM_REQUIRED(VERSION 2.4)

# project name
PROJECT(AstroMenace)


# depends
set(SDL_CONFIG "sdl-config" CACHE STRING "Path to sdl-config script")
EXEC_PROGRAM(${SDL_CONFIG} ARGS "--cflags" OUTPUT_VARIABLE SDL_CFLAGS)
EXEC_PROGRAM(${SDL_CONFIG} ARGS "--libs" OUTPUT_VARIABLE SDL_LIBS)


IF (NOT APPLE)
FIND_PACKAGE(X11 REQUIRED)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${X11_LIBRARIES})
ENDIF (NOT APPLE)

FIND_PACKAGE(SDL REQUIRED)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${SDL_LIBS})

FIND_PACKAGE(OpenGL REQUIRED)
IF(OPENGL_FOUND)
	INCLUDE_DIRECTORIES(${OPENGL_INCLUDE_DIR})
ELSE(OPENGL_FOUND)
	MESSAGE(FATAL_ERROR "OpenGL not found")
ENDIF(OPENGL_FOUND)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${OPENGL_gl_LIBRARY})

FIND_PACKAGE(OpenAL REQUIRED)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${OPENAL_LIBRARY})



# Xinerama lib + header

IF (NOT APPLE)
FIND_LIBRARY(XINERAMA_LIBRARY Xinerama)
IF(XINERAMA_LIBRARY)
	MESSAGE(STATUS "Found Xinerama: ${XINERAMA_LIBRARY}")
ELSE(XINERAMA_LIBRARY)
	MESSAGE(FATAL_ERROR "Xinerama not found")
ENDIF(XINERAMA_LIBRARY)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${XINERAMA_LIBRARY})
FIND_PATH(XINERAMA_INCLUDE_DIR X11/extensions/Xinerama.h
 	HINTS
 	PATHS
 	PATH_SUFFIXES include)
IF(XINERAMA_INCLUDE_DIR)
	MESSAGE(STATUS "Found Xinerama headers: ${XINERAMA_INCLUDE_DIR}")
ELSE(XINERAMA_INCLUDE_DIR)
	MESSAGE(FATAL_ERROR "Xinerama headers not found")
ENDIF(XINERAMA_INCLUDE_DIR)
INCLUDE_DIRECTORIES(${XINERAMA_INCLUDE_DIR})
ENDIF (NOT APPLE)


# GLU lib + header (GLU - part of OpenGL framework in MacOSX)

IF (NOT APPLE)
FIND_LIBRARY(GLU_LIBRARY GLU)
IF(GLU_LIBRARY)
	MESSAGE(STATUS "Found GLU: ${GLU_LIBRARY}")
ELSE(GLU_LIBRARY)
	MESSAGE(FATAL_ERROR "GLU not found")
ENDIF(GLU_LIBRARY)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${GLU_LIBRARY})
FIND_PATH(GLU_INCLUDE_DIR GL/glu.h
 	HINTS
	$ENV{GLUTDIR}
	$ENV{GLU_PATH}
 	PATHS
 	PATH_SUFFIXES include/GL include)
IF(GLU_INCLUDE_DIR)
	MESSAGE(STATUS "Found GLU headers: ${GLU_INCLUDE_DIR}")
ELSE(GLU_INCLUDE_DIR)
	MESSAGE(FATAL_ERROR "GLU headers not found")
ENDIF(GLU_INCLUDE_DIR)
INCLUDE_DIRECTORIES(${GLU_INCLUDE_DIR})
ENDIF (NOT APPLE)


# alut lib + header

FIND_LIBRARY(ALUT_LIBRARY alut)
IF(ALUT_LIBRARY)
	MESSAGE(STATUS "Found alut: ${ALUT_LIBRARY}")
ELSE(ALUT_LIBRARY)
	MESSAGE(FATAL_ERROR "alut not found")
ENDIF(ALUT_LIBRARY)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${ALUT_LIBRARY})
FIND_PATH(ALUT_INCLUDE_DIR alut.h
 	HINTS
	$ENV{ALUTDIR}
	$ENV{ALUT_PATH}
 	PATHS
 	PATH_SUFFIXES include/AL include)
IF(ALUT_INCLUDE_DIR)
	MESSAGE(STATUS "Found alut headers: ${ALUT_INCLUDE_DIR}")
ELSE(ALUT_INCLUDE_DIR)
	MESSAGE(FATAL_ERROR "alut headers not found")
ENDIF(ALUT_INCLUDE_DIR)
INCLUDE_DIRECTORIES(${ALUT_INCLUDE_DIR})


# ogg lib + header

FIND_LIBRARY(OGG_LIBRARY ogg)
IF(OGG_LIBRARY)
	MESSAGE(STATUS "Found ogg: ${OGG_LIBRARY}")
ELSE(OGG_LIBRARY)
	MESSAGE(FATAL_ERROR "ogg not found")
ENDIF(OGG_LIBRARY)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${OGG_LIBRARY})
FIND_PATH(OGG_INCLUDE_DIR ogg/ogg.h
	HINTS
	$ENV{OGGDIR}
        $ENV{OGG_PATH}
 	PATHS
 	PATH_SUFFIXES include)
IF(OGG_INCLUDE_DIR)
	MESSAGE(STATUS "Found ogg headers: ${OGG_INCLUDE_DIR}")
ELSE(OGG_INCLUDE_DIR)
	MESSAGE(FATAL_ERROR "ogg headers not found")
ENDIF(OGG_INCLUDE_DIR)
INCLUDE_DIRECTORIES(${OGG_INCLUDE_DIR})


# vorbis lib

FIND_LIBRARY(VORBIS_LIBRARY vorbis)
IF(VORBIS_LIBRARY)
	MESSAGE(STATUS "Found vorbis: ${VORBIS_LIBRARY}")
ELSE(VORBIS_LIBRARY)
	MESSAGE(FATAL_ERROR "vorbis not found")
ENDIF(VORBIS_LIBRARY)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${VORBIS_LIBRARY})


# vorbisfile lib + header

FIND_LIBRARY(VORBISFILE_LIBRARY vorbisfile)
IF(VORBISFILE_LIBRARY)
	MESSAGE(STATUS "Found vorbisfile: ${VORBISFILE_LIBRARY}")
ELSE(VORBISFILE_LIBRARY)
	MESSAGE(FATAL_ERROR "vorbisfile not found")
ENDIF(VORBISFILE_LIBRARY)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${VORBISFILE_LIBRARY})
FIND_PATH(VORBISFILE_INCLUDE_DIR vorbis/vorbisfile.h
	HINTS
        $ENV{VORBISFILEDIR}
        $ENV{VORBISFILE_PATH}
        $ENV{VORBISDIR}
        $ENV{VORBIS_PATH}
 	PATHS
 	PATH_SUFFIXES vorbis include)
IF(VORBISFILE_INCLUDE_DIR)
	MESSAGE(STATUS "Found vorbisfile headers: ${VORBISFILE_INCLUDE_DIR}")
ELSE(VORBISFILE_INCLUDE_DIR)
	MESSAGE(FATAL_ERROR "vorbisfile headers not found")
ENDIF(VORBISFILE_INCLUDE_DIR)
INCLUDE_DIRECTORIES(${VORBISFILE_INCLUDE_DIR})


# freetype lib + header

FIND_LIBRARY(FREETYPE_LIBRARY freetype)
IF(FREETYPE_LIBRARY)
	MESSAGE(STATUS "Found freetype: ${FREETYPE_LIBRARY}")
ELSE(FREETYPE_LIBRARY)
	MESSAGE(FATAL_ERROR "freetype not found")
ENDIF(FREETYPE_LIBRARY)
SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${FREETYPE_LIBRARY})
FIND_PATH(FREETYPE_INCLUDE_DIR_freetype2 freetype/config/ftheader.h
	HINTS
	$ENV{FREETYPE_DIR}/include/freetype2
	PATHS
	PATH_SUFFIXES freetype2)
IF(FREETYPE_INCLUDE_DIR_freetype2)
	MESSAGE(STATUS "Found freetype2 headers: ${FREETYPE_INCLUDE_DIR_freetype2}")
ELSE(FREETYPE_INCLUDE_DIR_freetype2)
	MESSAGE(FATAL_ERROR "freetype2 headers not found")
ENDIF(FREETYPE_INCLUDE_DIR_freetype2)
INCLUDE_DIRECTORIES(${FREETYPE_INCLUDE_DIR_freetype2})



# sources
FILE(GLOB_RECURSE astromenace_SRCS AstroMenaceSource/*.cpp)

# targets
IF(DEFINED DATADIR)
	ADD_DEFINITIONS(-DDATADIR=\\"${DATADIR}\\")
ENDIF(DEFINED DATADIR)

# we need all speed optimization flags, this could add up to 40% FPS in game
ADD_DEFINITIONS(${SDL_CFLAGS} "-O -O1 -O2 -O3 -Os -fomit-frame-pointer")
ADD_EXECUTABLE(AstroMenace ${astromenace_SRCS})
TARGET_LINK_LIBRARIES(AstroMenace ${ALL_LIBRARIES})
