## Copyright (c) 2010 Jamie Jones <jamie_jones_au@yahoo.com.au>
##
## This software is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This software is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 51 Franklin St, Fifth Floor,
## Boston, MA  02110-1301  USA
##
################################################################################
######################### CMake Configuration ##################################
PROJECT ("Eternity Engine" C CXX)
CMAKE_MINIMUM_REQUIRED (VERSION 2.4)
IF (COMMAND cmake_policy)
        CMAKE_POLICY (SET CMP0003 NEW)
ENDIF (COMMAND cmake_policy)
IF (${CMAKE_BINARY_DIR} STREQUAL ${CMAKE_SOURCE_DIR})
        MESSAGE( FATAL_ERROR "In-tree Builds are NOT supported.")
ENDIF (${CMAKE_BINARY_DIR} STREQUAL ${CMAKE_SOURCE_DIR})

# Supported Build Types are:
#    * Debug (CMAKE_C_FLAGS_DEBUG)
#    * Release (CMAKE_C_FLAGS_RELEASE)
#    * RelWithDebInfo (CMAKE_C_FLAGS_RELWITHDEBINFO)
#    * MinSizeRel (CMAKE_C_FLAGS_MINSIZEREL)
# If no build type requested, default to Debug
IF (NOT CMAKE_BUILD_TYPE)
        SET (CMAKE_BUILD_TYPE Debug)
ENDIF (NOT CMAKE_BUILD_TYPE)

INCLUDE(CheckIncludeFiles)
INCLUDE(CheckCCompilerFlag)
INCLUDE(CheckCXXCompilerFlag)
################################################################################
######################### Set Package Details  #################################
SET (CMAKE_MFC_FLAG 2)
SET (CMAKE_INSTALL_MFC_LIBRARIES 1)
INCLUDE(InstallRequiredSystemLibraries)
SET (CPACK_GENERATOR "DEB;RPM;STGZ;ZIP")
SET (CPACK_PACKAGE_VENDOR "Team Eternity")
SET (CPACK_PACKAGE_CONTACT "Team Eternity <haelyjd@hotmail.com>")
SET (CPACK_PACKAGE_VERSION_MAJOR "3")
SET (CPACK_PACKAGE_VERSION_MINOR "37")
SET (CPACK_PACKAGE_VERSION_PATCH "00")
SET (CPACK_PACKAGE_NAME "Eternity Engine")
SET (CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING")
SET (CPACK_PACKAGE_DESCRIPTION_SUMMARY "The Eternity Engine is Team Eternity's flagship product.")
SET (CPACK_DEBIAN_PACKAGE_SECTION "games")
SET (CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.11.0), libgcc1 (>= 1:4.4.3), libsdl1.2debian (>=1.2.14), libsdl-mixer1.2 (>=1.2.8), libsdl-net1.2 (>=1.2.7), bash")
SET (CPACK_DEBIAN_PACKAGE_RECOMMENDS "freedoom, game-data-packager")
SET (BUILD_ARCH "${CMAKE_SYSTEM_PROCESSOR}")
IF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "i686")
        SET (CPACK_DEBIAN_PACKAGE_ARCHITECTURE "i386")
        SET (CPACK_RPM_PACKAGE_ARCHITECTURE "i686" )
        SET (BUILD_ARCH "${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
ENDIF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "i686")
IF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
        SET (CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64")
        SET (CPACK_RPM_PACKAGE_ARCHITECTURE "x86_64" )
        SET (BUILD_ARCH "${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
ENDIF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
IF (WIN32)
        SET (BUILD_ARCH "windows-x86")
        IF("$ENV{PROCESSOR_ARCHITECTURE}" STREQUAL "AMD64")
                SET (BUILD_ARCH "windows-$ENV{PROCESSOR_ARCHITECTURE}")
        ENDIF("$ENV{PROCESSOR_ARCHITECTURE}" STREQUAL "AMD64")
ENDIF (WIN32)
SET (CPACK_PACKAGE_FILE_NAME "eternity-engine-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}_${BUILD_ARCH}")
SET (CPACK_DEBIAN_PACKAGE_NAME "${CPACK_PACKAGE_FILE_NAME}")
SET (CPACK_RPM_PACKAGE_NAME "${CPACK_PACKAGE_FILE_NAME}")

SET (BIN_DIR bin)
SET (SHARE_DIR share/eternity-engine)
IF (WIN32)
        SET (LIB_DIR ${BIN_DIR})
        SET (SHARE_DIR ${BIN_DIR})
ELSE (WIN32)
        SET (LIB_DIR lib)
ENDIF (WIN32)
INCLUDE(CPack)
################################################################################
######################### Compiler: Warnings  ##################################
IF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
        CHECK_C_COMPILER_FLAG (-Wall GCC_C_WALL)
        IF (GCC_C_WALL)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
        ENDIF (GCC_C_WALL)
        CHECK_C_COMPILER_FLAG (-Wextra GCC_C_WEXTRA)
        IF (GCC_C_WEXTRA)
                #SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wextra")
        ENDIF (GCC_C_WEXTRA)
ENDIF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
IF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        CHECK_CXX_COMPILER_FLAG (-Wall GCC_CXX_WALL)
        IF (GCC_CXX_WALL)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
        ENDIF (GCC_CXX_WALL)
        CHECK_CXX_COMPILER_FLAG (-Wextra GCC_CXX_WEXTRA)
        IF (GCC_CXX_WEXTRA)
                #SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra")
        ENDIF (GCC_CXX_WEXTRA)
ENDIF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")

IF (CMAKE_C_COMPILER_ID STREQUAL "Intel")
        CHECK_C_COMPILER_FLAG (-Wall INTEL_C_WALL)
        IF (INTEL_C_WALL)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
        ENDIF (INTEL_C_WALL)
        IF (INTEL_C_WCHECK)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wcheck")
        ENDIF (INTEL_C_WCHECK)
        CHECK_C_COMPILER_FLAG (-Wp64 INTEL_C_WP64)
        IF (INTEL_C_WP64)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wp64")
        ENDIF (INTEL_C_WP64)
        CHECK_C_COMPILER_FLAG (-Wshorten-64-to-32 INTEL_C_WSHORT64TO32)
        IF (INTEL_C_WSHORT64TO32)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wshorten-64-to-32")
        ENDIF (INTEL_C_WSHORT64TO32)
ENDIF (CMAKE_C_COMPILER_ID STREQUAL "Intel")
IF (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        CHECK_CXX_COMPILER_FLAG (-Wall INTEL_CXX_WALL)
        IF (INTEL_CXX_WALL)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
        ENDIF (INTEL_CXX_WALL)
        IF (INTEL_CXX_WCHECK)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcheck")
        ENDIF (INTEL_CXX_WCHECK)
        CHECK_CXX_COMPILER_FLAG (-Wp64 INTEL_CXX_WP64)
        IF (INTEL_CXX_WP64)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wp64")
        ENDIF (INTEL_CXX_WP64)
        CHECK_CXX_COMPILER_FLAG (-Wshorten-64-to-32 INTEL_CXX_WSHORT64TO32)
        IF (INTEL_CXX_WSHORT64TO32)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wshorten-64-to-32")
        ENDIF (INTEL_CXX_WSHORT64TO32)
ENDIF (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")

IF (MSVC)
        ADD_DEFINITIONS (-D_CRT_SECURE_NO_WARNINGS)
        ADD_DEFINITIONS (-D_CRT_NONSTDC_NO_WARNINGS)
ENDIF (MSVC)
IF (MSVC)
        CHECK_C_COMPILER_FLAG (/W4 MSVC_C_W4)
        IF (MSVC_C_W4)
                ## FIXME: This is an inelegant hack to club MSVC into
                ## submission. By default CMake defines /W3 but if /W4
                ## is available, I want to use it. Unfortantly for MSVC
                ## later options while superseeding earlier options, also
                ## cause MSVC to emit a warning message each time, so
                ## if /W4 is supported, we will do a REGEX replacement of
                ## it as I want to see real warnings...
                ## Better solutions are welcome.
                IF(${CMAKE_C_FLAGS} MATCHES "/W3")
                STRING(REGEX REPLACE "/W3" "/W4" ${CMAKE_C_FLAGS} "${${CMAKE_C_FLAGS}}")
                ENDIF(${CMAKE_C_FLAGS} MATCHES "/W3")
        ENDIF (MSVC_C_W4)
ENDIF (MSVC)
IF (MSVC)
        CHECK_CXX_COMPILER_FLAG (/W4 MSVC_CXX_W4)
        IF (MSVC_CXX_W4)
                ## FIXME: This is an inelegant hack to club MSVC into
                ## submission. By default CMake defines /W3 but if /W4
                ## is available, I want to use it. Unfortantly for MSVC
                ## later options while superseeding earlier options, also
                ## cause MSVC to emit a warning message each time, so
                ## if /W4 is supported, we will do a REGEX replacement of
                ## it as I want to see real warnings...
                ## Better solutions are welcome.
                IF(${CMAKE_CXX_FLAGS} MATCHES "/W3")
                STRING(REGEX REPLACE "/W3" "/W4" ${CMAKE_CXX_FLAGS} "${${CMAKE_CXX_FLAGS}}")
                ENDIF(${CMAKE_CXX_FLAGS} MATCHES "/W3")
        ENDIF (MSVC_CXX_W4)
ENDIF (MSVC)
################################################################################
######################### Compiler: Hardening  #################################
IF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "GNU")
        ADD_DEFINITIONS (-D_FORTIFY_SOURCE=2)
ENDIF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "GNU")
IF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
        CHECK_C_COMPILER_FLAG (-fstack-protector GCC_C_FSTACKPROTECTOR)
        IF (GCC_C_FSTACKPROTECTOR)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
        ENDIF (GCC_C_FSTACKPROTECTOR)
        IF (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
                CHECK_C_COMPILER_FLAG (-fPIC GCC_C_FPIC)
                IF (GCC_C_FPIC)
                        SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
                ENDIF (GCC_C_FPIC)
	        CHECK_C_COMPILER_FLAG (-pie GCC_C_PIE)
	        IF (GCC_C_PIE)
	                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pie")
	        ENDIF (GCC_C_PIE)
	        CHECK_C_COMPILER_FLAG (-Wl,-z,relro GCC_C_WLZRELRO)
	        IF (GCC_C_WLZRELRO)
	                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,relro")
	        ENDIF (GCC_C_WLZRELRO)
	        CHECK_C_COMPILER_FLAG (-Wl,-z,now GCC_C_WLZNOW)
	        IF (GCC_C_WLZNOW)
	                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,now")
	        ENDIF (GCC_C_WLZNOW)
	        CHECK_C_COMPILER_FLAG (-Wl,--as-needed GCC_C_WLASNEEDED)
	        IF (GCC_C_WLASNEEDED)
	                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,--as-needed")
	        ENDIF (GCC_C_WLASNEEDED)
	        CHECK_C_COMPILER_FLAG (-Wl,-z,noexecstack GCC_C_WLZNOEXECSTACK)
	        IF (GCC_C_WLZNOEXECSTACK)
	                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,noexecstack")
	        ENDIF (GCC_C_WLZNOEXECSTACK)
        ENDIF (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
ENDIF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
IF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        CHECK_CXX_COMPILER_FLAG (-fstack-protector GCC_CXX_FSTACKPROTECTOR)
        IF (GCC_CXX_FSTACKPROTECTOR)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector")
        ENDIF (GCC_CXX_FSTACKPROTECTOR)
        IF (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
                CHECK_CXX_COMPILER_FLAG (-fPIC GCC_CXX_FPIC)
                IF (GCC_CXX_FPIC)
                        SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
                ENDIF (GCC_CXX_FPIC)
	        CHECK_CXX_COMPILER_FLAG (-pie GCC_CXX_PIE)
	        IF (GCC_CXX_PIE)
	                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pie")
	        ENDIF (GCC_CXX_PIE)
	        CHECK_CXX_COMPILER_FLAG (-Wl,-z,relro GCC_CXX_WLZRELRO)
	        IF (GCC_CXX_WLZRELRO)
	                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-z,relro")
	        ENDIF (GCC_CXX_WLZRELRO)
	        CHECK_CXX_COMPILER_FLAG (-Wl,-z,now GCC_CXX_WLZNOW)
	        IF (GCC_CXX_WLZNOW)
	                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-z,now")
	        ENDIF (GCC_CXX_WLZNOW)
	        CHECK_CXX_COMPILER_FLAG (-Wl,--as-needed GCC_CXX_WLASNEEDED)
	        IF (GCC_CXX_WLASNEEDED)
	                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--as-needed")
	        ENDIF (GCC_CXX_WLASNEEDED)
	        CHECK_CXX_COMPILER_FLAG (-Wl,-z,noexecstack GCC_CXX_WLZNOEXECSTACK)
	        IF (GCC_CXX_WLZNOEXECSTACK)
	                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-z,noexecstack")
	        ENDIF (GCC_CXX_WLZNOEXECSTACK)
        ENDIF (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
ENDIF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")

IF (CMAKE_C_COMPILER_ID STREQUAL "Intel")
        CHECK_C_COMPILER_FLAG (-fstack-protector INTEL_C_FSTACKPROTECTOR)
        IF (INTEL_C_FSTACKPROTECTOR)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
        ENDIF (INTEL_C_FSTACKPROTECTOR)
        CHECK_C_COMPILER_FLAG (-fPIC INTEL_C_FPIC)
        IF (INTEL_C_FPIC)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
        ENDIF (INTEL_C_FPIC)
        CHECK_C_COMPILER_FLAG (-pie INTEL_C_PIE)
        IF (INTEL_C_PIE)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pie")
        ENDIF (INTEL_C_PIE)
        CHECK_C_COMPILER_FLAG (-Wl,-z,relro INTEL_C_WLZRELRO)
        IF (INTEL_C_WLZRELRO)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,relro")
        ENDIF (INTEL_C_WLZRELRO)
        CHECK_C_COMPILER_FLAG (-Wl,-z,now INTEL_C_WLZNOW)
        IF (INTEL_C_WLZNOW)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,now")
        ENDIF (INTEL_C_WLZNOW)
        CHECK_C_COMPILER_FLAG (-Wl,--as-needed INTEL_C_WLASNEEDED)
        IF (INTEL_C_WLASNEEDED)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,--as-needed")
        ENDIF (INTEL_C_WLASNEEDED)
        CHECK_C_COMPILER_FLAG (-Wl,-z,noexecstack INTEL_C_WLZNOEXECSTACK)
        IF (INTEL_C_WLZNOEXECSTACK)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,noexecstack")
        ENDIF (INTEL_C_WLZNOEXECSTACK)
ENDIF (CMAKE_C_COMPILER_ID STREQUAL "Intel")
IF (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        CHECK_CXX_COMPILER_FLAG (-fstack-protector INTEL_CXX_FSTACKPROTECTOR)
        IF (INTEL_CXX_FSTACKPROTECTOR)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector")
        ENDIF (INTEL_CXX_FSTACKPROTECTOR)
        CHECK_CXX_COMPILER_FLAG (-fPIC INTEL_CXX_FPIC)
        IF (INTEL_CXX_FPIC)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
        ENDIF (INTEL_CXX_FPIC)
        CHECK_CXX_COMPILER_FLAG (-pie INTEL_CXX_PIE)
        IF (INTEL_CXX_PIE)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pie")
        ENDIF (INTEL_CXX_PIE)
        CHECK_CXX_COMPILER_FLAG (-Wl,-z,relro INTEL_CXX_WLZRELRO)
        IF (INTEL_CXX_WLZRELRO)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-z,relro")
        ENDIF (INTEL_CXX_WLZRELRO)
        CHECK_CXX_COMPILER_FLAG (-Wl,-z,now INTEL_CXX_WLZNOW)
        IF (INTEL_CXX_WLZNOW)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-z,now")
        ENDIF (INTEL_CXX_WLZNOW)
        CHECK_CXX_COMPILER_FLAG (-Wl,--as-needed INTEL_CXX_WLASNEEDED)
        IF (INTEL_CXX_WLASNEEDED)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--as-needed")
        ENDIF (INTEL_CXX_WLASNEEDED)
        CHECK_CXX_COMPILER_FLAG (-Wl,-z,noexecstack INTEL_CXX_WLZNOEXECSTACK)
        IF (INTEL_CXX_WLZNOEXECSTACK)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-z,noexecstack")
        ENDIF (INTEL_CXX_WLZNOEXECSTACK)
ENDIF (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")

IF (MSVC)
        CHECK_C_COMPILER_FLAG (/GS MSVC_C_GS)
        IF (MSVC_C_GS)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /GS")
        ENDIF (MSVC_C_GS)
ENDIF (MSVC)
IF (MSVC)
        CHECK_CXX_COMPILER_FLAG (/GS MSVC_CXX_GS)
        IF (MSVC_CXX_GS)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GS")
        ENDIF (MSVC_CXX_GS)
ENDIF (MSVC)
################################################################################
######################### Compiler: Optimisation  ##############################
## NOTE: This is actually a counter-optimistion - it makes it slower, but as
## the Eternity Engine does break strict aliasing rules, correct code is
## preferable to fast code.
IF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
        CHECK_C_COMPILER_FLAG (-fno-strict-aliasing GCC_C_FNOSTRICTALIASING)
        IF (GCC_C_FNOSTRICTALIASING)
                SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-strict-aliasing")
        ENDIF (GCC_C_FNOSTRICTALIASING)
ENDIF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
IF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        CHECK_CXX_COMPILER_FLAG (-fno-strict-aliasing GCC_CXX_FNOSTRICTALIASING)
        IF (GCC_CXX_FNOSTRICTALIASING)
                SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing")
        ENDIF (GCC_CXX_FNOSTRICTALIASING)
ENDIF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")

IF (CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" OR CMAKE_BUILD_TYPE STREQUAL "Release")
        IF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
        CHECK_C_COMPILER_FLAG (-fomit-frame-pointer GCC_C_FOMITFRAMEPOINTER)
                IF (GCC_C_FOMITFRAMEPOINTER)
                        SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fomit-frame-pointer")
                ENDIF (GCC_C_FOMITFRAMEPOINTER)
        CHECK_C_COMPILER_FLAG (-flto GCC_C_FLTO)
                IF (GCC_C_FLTO)
                        SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -flto")
                ENDIF (GCC_C_FLTO)
        ENDIF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
        IF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        CHECK_CXX_COMPILER_FLAG (-fomit-frame-pointer GCC_CXX_FOMITFRAMEPOINTER)
                IF (GCC_CXX_FOMITFRAMEPOINTER)
                        SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fomit-frame-pointer")
                ENDIF (GCC_CXX_FOMITFRAMEPOINTER)
        CHECK_CXX_COMPILER_FLAG (-flto GCC_CXX_FLTO)
                IF (GCC_CXX_FLTO)
                        SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
                ENDIF (GCC_CXX_FLTO)
        ENDIF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")

        IF (CMAKE_C_COMPILER_ID STREQUAL "Intel")
        CHECK_C_COMPILER_FLAG (-fomit-frame-pointer INTEL_C_FOMITFRAMEPOINTER)
                IF (INTEL_C_FOMITFRAMEPOINTER)
                        SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fomit-frame-pointer")
                ENDIF (INTEL_C_FOMITFRAMEPOINTER)
        CHECK_C_COMPILER_FLAG (-ipo INTEL_C_IPO)
                IF (INTEL_C_IPO)
                        SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ipo")
                ENDIF (INTEL_C_IPO)
        ENDIF (CMAKE_C_COMPILER_ID STREQUAL "Intel")
        IF (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        CHECK_CXX_COMPILER_FLAG (-fomit-frame-pointer INTEL_CXX_FOMITFRAMEPOINTER)
                IF (INTEL_CXX_FOMITFRAMEPOINTER)
                        SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fomit-frame-pointer")
                ENDIF (INTEL_CXX_FOMITFRAMEPOINTER)
        CHECK_CXX_COMPILER_FLAG (-ipo INTEL_CXX_IPO)
                IF (INTEL_CXX_IPO)
                        SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ipo")
                ENDIF (INTEL_CXX_IPO)
        ENDIF (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
ENDIF (CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" OR CMAKE_BUILD_TYPE STREQUAL "Release")
################################################################################
######################### Find Headers #########################################
CHECK_INCLUDE_FILES (stdint.h HAVE_STDINT_H)
IF (NOT HAVE_STDINT_H)
        IF (MSVC)
                ## FIXME: This is bad. stdint.h and inttypes.h should be
                ## moved to a seperate folder. They are not used by MinGW or
                ## in Visual Studio 2010 onwards, and break those builds.
                INCLUDE_DIRECTORIES (${CMAKE_SOURCE_DIR}/source/win32/)
        ENDIF (MSVC)
ENDIF (NOT HAVE_STDINT_H)
################################################################################
######################### Find Needed Libs #####################################
IF (NOT GL_LIBRARY_SEARCHED)
        MESSAGE (STATUS "Looking for OpenGL")
        FIND_LIBRARY (GL_LIBRARY GL)
        IF (GL_LIBRARY)
                MESSAGE (STATUS "Looking for OpenGL - found")
        ELSE (GL_LIBRARY)
                MESSAGE (STATUS "Looking for OpenGL - not found")
        ENDIF (GL_LIBRARY)
        SET (GL_LIBRARY_SEARCHED TRUE CACHE INTERNAL "")
ENDIF (NOT GL_LIBRARY_SEARCHED)

FIND_PACKAGE (SDL REQUIRED)
INCLUDE_DIRECTORIES (${SDL_INCLUDE_DIR})

FIND_PACKAGE (SDL_mixer REQUIRED)
INCLUDE_DIRECTORIES (${SDLMIXER_INCLUDE_DIR})

FIND_PACKAGE (SDL_net REQUIRED)
INCLUDE_DIRECTORIES (${SDLNET_INCLUDE_DIR})

## FIXME: This is an inelegant hack to find, and grab all needed
## .dll support files on windows. It works by looking for SDL.dll
## then taking every .dll file found in that directory from your SDK.
## This ensures you get sdl and all of it's needed .dll files, but may
## also grab unneeded .dll files.
IF (WIN32)
       FIND_PATH (SDL_SUPPORT_LIBS_DIR SDL.dll
               HINTS
               $ENV{SDLDIR}
               PATH_SUFFIXES lib64 lib
               PATHS)
       FILE (GLOB SDL_SUPPORT_LIBS ${SDL_SUPPORT_LIBS_DIR}/*.dll)
ENDIF (WIN32)
################################################################################
######################### Set Build Targets   ##################################

INCLUDE_DIRECTORIES(libpng)
INCLUDE_DIRECTORIES(zlib)

ADD_SUBDIRECTORY(zlib)
ADD_SUBDIRECTORY(libpng)
ADD_SUBDIRECTORY(snes_spc)
ADD_SUBDIRECTORY(source)

IF (WIN32)
        ADD_SUBDIRECTORY(eecrashreport)
ENDIF (WIN32)

## FIXME: This is a continuation of the Windows SDL inelegant hack. This does
## the actual installation of those support libraries.
IF (WIN32)
        INSTALL (PROGRAMS ${SDL_SUPPORT_LIBS}
                DESTINATION ${LIB_DIR})
ENDIF (WIN32)