Skip to content
Snippets Groups Projects
Commit e63887f1 authored by Lars Bilke's avatar Lars Bilke
Browse files

Moved some CMake modules to cmake/.

parent 6c559784
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
FindMSVCRedist.cmake 0 → 100644
+ 41
− 0
View file @ e63887f1
IF (MSVC)
if (MSVC80)
set(VCVERS 8)
endif()
if (MSVC90)
set(VCVERS 9)
endif()
IF(CMAKE_CL_64)
#IF(MSVC_VERSION GREATER 1599)
# VS 10 and later:
SET(CMAKE_MSVC_ARCH x64)
#ELSE()
# # VS 9 and earlier:
# SET(CMAKE_MSVC_ARCH amd64)
#ENDIF()
ELSE(CMAKE_CL_64)
SET(CMAKE_MSVC_ARCH x86)
ENDIF(CMAKE_CL_64)
set(SDKVERS "2.0")
if(${VCVERS} EQUAL 8)
set(SDKVERS "2.0")
endif()
if(${VCVERS} EQUAL 9)
set(SDKVERS "3.5")
endif()
IF(MSVC${VCVERS}0)
FIND_PROGRAM(MSVC_REDIST NAMES
vcredist_${CMAKE_MSVC_ARCH}/vcredist_${CMAKE_MSVC_ARCH}.exe
PATHS
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\${VCVERS}.0;InstallDir]/../../SDK/v${SDKVERS}/BootStrapper/Packages/"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\${VCVERS}.0;InstallDir]/../../SDK/v${SDKVERS}/BootStrapper/Packages/"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\${VCVERS}.0;InstallDir]/../../SDK/v${SDKVERS}/BootStrapper/Packages/"
)
GET_FILENAME_COMPONENT(vcredist_name "${MSVC_REDIST}" NAME)
INSTALL(PROGRAMS ${MSVC_REDIST} COMPONENT msvc_redist DESTINATION bin)
SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS "ExecWait '\\\"$INSTDIR\\\\bin\\\\${vcredist_name}\\\"'")
message(STATUS "MSVC_REDIST: ${MSVC_REDIST}")
ENDIF(MSVC${VCVERS}0)
ENDIF ()
\ No newline at end of file
FindOpenSG.cmake 0 → 100644
+ 328
− 0
View file @ e63887f1
# - Find OpenSG 1.8 libraries
# Find the specified OpenSG 1.8 libraries and header files. Slightly modified
# from the version for 2.0, see # 1.8 - comments
#
# Since OpenSG consists of a number of libraries you need to specify which
# of those you want to use. To do so, pass a list of their names after
# the COMPONENTS argument to FIND_PACKAGE. A typical call looks like this:
# FIND_PACKAGE(OpenSG REQUIRED COMPONENTS OSGBase OSGSystem OSGDrawable)
#
# This module specifies the following variables:
# OpenSG_INCLUDE_DIRS
# OpenSG_LIBRARIES
# OpenSG_LIBRARY_DIRS
#
# For each component COMP the capitalized name (e.g. OSGBASE, OSGSYSTEM):
# OpenSG_${COMP}_LIBRARY
# OpenSG_${COMP}_LIBRARY_RELEASE
# OpenSG_${COMP}_LIBRARY_DEBUG
#
# You can control where this module attempts to locate libraries and headers:
# you can use the following input variables:
# OPENSG_ROOT root of an installed OpenSG with include/OpenSG and lib below it
# OPENSG_INCLUDE_DIR header directory
# OPENSG_LIBRARY_DIR library directory
# OR
# OPENSG_INCLUDE_SEARCH_DIR
# OPENSG_LIBRARY_SEARCH_DIR
# This macro sets the include path and libraries to link to.
# On Windows this also sets some preprocessor definitions and disables some warnings.
MACRO(USE_OPENSG targetName)
IF (MSVC)
ADD_DEFINITIONS(
-DOSG_BUILD_DLL
-DOSG_HAVE_CONFIGURED_H_
-DOSG_WITH_GIF
-DOSG_WITH_TIF
-DOSG_WITH_JPG
)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4231 /wd4275")
ENDIF (MSVC)
TARGET_LINK_LIBRARIES( ${targetName} ${OpenSG_LIBRARIES} )
INCLUDE_DIRECTORIES( ${OpenSG_INCLUDE_DIRS} )
ENDMACRO()
SET(__OpenSG_IN_CACHE TRUE)
IF(OpenSG_INCLUDE_DIR)
FOREACH(COMPONENT ${OpenSG_FIND_COMPONENTS})
STRING(TOUPPER ${COMPONENT} COMPONENT)
IF(NOT OpenSG_${COMPONENT}_FOUND)
SET(__OpenSG_IN_CACHE FALSE)
ENDIF(NOT OpenSG_${COMPONENT}_FOUND)
ENDFOREACH(COMPONENT)
ELSE(OpenSG_INCLUDE_DIR)
SET(__OpenSG_IN_CACHE FALSE)
ENDIF(OpenSG_INCLUDE_DIR)
# The reason that we failed to find OpenSG. This will be set to a
# user-friendly message when we fail to find some necessary piece of
# OpenSG.
set(OpenSG_ERROR_REASON)
############################################
#
# Check the existence of the libraries.
#
############################################
# This macro is directly taken from FindBoost.cmake that comes with the cmake
# distribution. It is NOT my work, only minor modifications have been made to
# remove references to boost.
#########################################################################
MACRO(__OpenSG_ADJUST_LIB_VARS basename)
IF(OpenSG_INCLUDE_DIR)
IF(OpenSG_${basename}_LIBRARY_DEBUG AND OpenSG_${basename}_LIBRARY_RELEASE)
# if the generator supports configuration types then set
# optimized and debug libraries, or if the CMAKE_BUILD_TYPE has a value
IF (CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
SET(OpenSG_${basename}_LIBRARY optimized ${OpenSG_${basename}_LIBRARY_RELEASE} debug ${OpenSG_${basename}_LIBRARY_DEBUG})
ELSE(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
# if there are no configuration types and CMAKE_BUILD_TYPE has no value
# then just use the release libraries
SET(OpenSG_${basename}_LIBRARY ${OpenSG_${basename}_LIBRARY_RELEASE} )
ENDIF(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
SET(OpenSG_${basename}_LIBRARIES optimized ${OpenSG_${basename}_LIBRARY_RELEASE} debug ${OpenSG_${basename}_LIBRARY_DEBUG})
ENDIF(OpenSG_${basename}_LIBRARY_DEBUG AND OpenSG_${basename}_LIBRARY_RELEASE)
# if only the release version was found, set the debug variable also to the release version
IF(OpenSG_${basename}_LIBRARY_RELEASE AND NOT OpenSG_${basename}_LIBRARY_DEBUG)
SET(OpenSG_${basename}_LIBRARY_DEBUG ${OpenSG_${basename}_LIBRARY_RELEASE})
SET(OpenSG_${basename}_LIBRARY ${OpenSG_${basename}_LIBRARY_RELEASE})
SET(OpenSG_${basename}_LIBRARIES ${OpenSG_${basename}_LIBRARY_RELEASE})
ENDIF(OpenSG_${basename}_LIBRARY_RELEASE AND NOT OpenSG_${basename}_LIBRARY_DEBUG)
# if only the debug version was found, set the release variable also to the debug version
IF(OpenSG_${basename}_LIBRARY_DEBUG AND NOT OpenSG_${basename}_LIBRARY_RELEASE)
SET(OpenSG_${basename}_LIBRARY_RELEASE ${OpenSG_${basename}_LIBRARY_DEBUG})
SET(OpenSG_${basename}_LIBRARY ${OpenSG_${basename}_LIBRARY_DEBUG})
SET(OpenSG_${basename}_LIBRARIES ${OpenSG_${basename}_LIBRARY_DEBUG})
ENDIF(OpenSG_${basename}_LIBRARY_DEBUG AND NOT OpenSG_${basename}_LIBRARY_RELEASE)
IF(OpenSG_${basename}_LIBRARY)
SET(OpenSG_${basename}_LIBRARY ${OpenSG_${basename}_LIBRARY} CACHE FILEPATH "The OpenSG ${basename} library")
GET_FILENAME_COMPONENT(OpenSG_LIBRARY_DIRS "${OpenSG_${basename}_LIBRARY}" PATH)
SET(OpenSG_LIBRARY_DIRS ${OpenSG_LIBRARY_DIRS} CACHE FILEPATH "OpenSG library directory")
SET(OpenSG_${basename}_FOUND ON CACHE INTERNAL "Whether the OpenSG ${basename} library found")
ENDIF(OpenSG_${basename}_LIBRARY)
ENDIF(OpenSG_INCLUDE_DIR)
# Make variables changeble to the advanced user
MARK_AS_ADVANCED(
OpenSG_${basename}_LIBRARY
OpenSG_${basename}_LIBRARY_RELEASE
OpenSG_${basename}_LIBRARY_DEBUG
)
ENDMACRO(__OpenSG_ADJUST_LIB_VARS)
#-------------------------------------------------------------------------------
IF(__OpenSG_IN_CACHE)
# values are already in the cache
SET(OpenSG_FOUND TRUE)
FOREACH(COMPONENT ${OpenSG_FIND_COMPONENTS})
STRING(TOUPPER ${COMPONENT} COMPONENT)
__OpenSG_ADJUST_LIB_VARS(${COMPONENT})
SET(OpenSG_LIBRARIES ${OpenSG_LIBRARIES} ${OpenSG_${COMPONENT}_LIBRARY})
ENDFOREACH(COMPONENT)
SET(OpenSG_INCLUDE_DIRS "${OpenSG_INCLUDE_DIR}" "${OpenSG_INCLUDE_DIR}/OpenSG")
ELSE(__OpenSG_IN_CACHE)
# need to search for libs
# Visual Studio x32
if (VS32)
# Visual Studio x32
SET( __OpenSG_INCLUDE_SEARCH_DIRS
$ENV{OPENSG_ROOT}/include
${OPENSG_ROOT}/include
${LIBRARIES_DIR}/opensg/include
${CMAKE_SOURCE_DIR}/../OpenSG/include )
SET( __OpenSG_LIBRARIES_SEARCH_DIRS
$ENV{OPENSG_ROOT}/lib
${OPENSG_ROOT}/lib
${LIBRARIES_DIR}/opensg/lib
${CMAKE_SOURCE_DIR}/../opensg/lib )
else (VS32)
if (VS64)
# Visual Studio x64
SET( __OpenSG_INCLUDE_SEARCH_DIRS
$ENV{OPENSG_ROOT}/include
${OPENSG_ROOT}/include
${LIBRARIES_DIR}/opensg_x64/include
${CMAKE_SOURCE_DIR}/../opensg_x64/include )
SET( __OpenSG_LIBRARIES_SEARCH_DIRS
$ENV{OPENSG_ROOT}/lib
${OPENSG_ROOT}/lib
${LIBRARIES_DIR}/opensg_x64/lib
${CMAKE_SOURCE_DIR}/../opensg_x64/lib )
else (VS64)
# Linux or Mac
SET( __OpenSG_INCLUDE_SEARCH_DIRS
"/usr/local"
"/usr/local/include" )
SET( __OpenSG_LIBRARIES_SEARCH_DIRS
"/usr/local"
"/usr/local/lib" )
endif(VS64)
endif (VS32)
# handle input variable OPENSG_INCLUDE_DIR
IF(OPENSG_INCLUDE_DIR)
FILE(TO_CMAKE_PATH ${OPENSG_INCLUDE_DIR} OPENSG_INCLUDE_DIR)
SET(__OpenSG_INCLUDE_SEARCH_DIRS
${OPENSG_INCLUDE_DIR} ${__OpenSG_INCLUDE_SEARCH_DIRS})
ENDIF(OPENSG_INCLUDE_DIR)
# handle input variable OPENSG_LIBRARY_DIR
IF(OPENSG_LIBRARY_DIR)
FILE(TO_CMAKE_PATH ${OPENSG_LIBRARY_DIR} OPENSG_LIBRARY_DIR)
SET(__OpenSG_LIBRARIES_SEARCH_DIRS
${OPENSG_LIBRARY_DIR} ${__OpenSG_LIBRARIES_SEARCH_DIRS})
ENDIF(OPENSG_LIBRARY_DIR)
# handle input variable OPENSG_INCLUDE_SEARCH_DIR
IF(OPENSG_INCLUDE_SEARCH_DIR)
FILE(TO_CMAKE_PATH ${OPENSG_INCLUDE_SEARCH_DIR} OPENSG_INCLUDE_SEARCH_DIR)
SET(__OpenSG_INCLUDE_SEARCH_DIRS
${OPENSG_INCLUDE_SEARCH_DIR} ${__OpenSG_INCLUDE_SEARCH_DIRS})
ENDIF(OPENSG_INCLUDE_SEARCH_DIR)
# handle input variable OPENSG_LIBRARY_SEARCH_DIR
IF(OPENSG_LIBRARY_SEARCH_DIR)
FILE(TO_CMAKE_PATH ${OPENSG_LIBRARY_SEARCH_DIR} OPENSG_LIBRARY_SEARCH_DIR)
SET(__OpenSG_LIBRARIES_SEARCH_DIRS
${OPENSG_LIBRARY_SEARCH_DIR} ${__OpenSG_LIBRARIES_SEARCH_DIRS})
ENDIF(OPENSG_LIBRARY_SEARCH_DIR)
IF(NOT OpenSG_INCLUDE_DIR)
# try to find include dirrectory by searching for OSGConfigured.h
FIND_PATH(OpenSG_INCLUDE_DIR
NAMES OpenSG/OSGConfigured.h
HINTS ${__OpenSG_INCLUDE_SEARCH_DIRS})
ENDIF(NOT OpenSG_INCLUDE_DIR)
#message(STATUS "OpenSG_INCLUDE_DIR: " ${OpenSG_INCLUDE_DIR})
# ------------------------------------------------------------------------
# Begin finding OpenSG libraries
# ------------------------------------------------------------------------
FOREACH(COMPONENT ${OpenSG_FIND_COMPONENTS})
STRING(TOUPPER ${COMPONENT} UPPERCOMPONENT)
SET(OpenSG_${UPPERCOMPONENT}_LIBRARY "OpenSG_${UPPERCOMPONENT}_LIBRARY-NOTFOUND" )
SET(OpenSG_${UPPERCOMPONENT}_LIBRARY_RELEASE "OpenSG_${UPPERCOMPONENT}_LIBRARY_RELEASE-NOTFOUND" )
SET(OpenSG_${UPPERCOMPONENT}_LIBRARY_DEBUG "OpenSG_${UPPERCOMPONENT}_LIBRARY_DEBUG-NOTFOUND")
IF (WIN32)
FIND_LIBRARY(OpenSG_${UPPERCOMPONENT}_LIBRARY_RELEASE
NAMES ${COMPONENT}
HINTS ${__OpenSG_LIBRARIES_SEARCH_DIRS}
)
#message(STATUS "OpenSG Component: " ${COMPONENT})
FIND_LIBRARY(OpenSG_${UPPERCOMPONENT}_LIBRARY_DEBUG
# 1.8 Added the "D" suffix
NAMES ${COMPONENT}D
HINTS ${__OpenSG_LIBRARIES_SEARCH_DIRS}
# 1.8 Removed next line
#PATH_SUFFIXES "debug"
)
ELSE (WIN32)
FIND_LIBRARY(OpenSG_${UPPERCOMPONENT}_LIBRARY_RELEASE
NAMES ${COMPONENT}
HINTS ${__OpenSG_LIBRARIES_SEARCH_DIRS}
PATH_SUFFIXES "/opt"
)
#message(STATUS "OpenSG Component: " ${COMPONENT})
FIND_LIBRARY(OpenSG_${UPPERCOMPONENT}_LIBRARY_DEBUG
NAMES ${COMPONENT}
HINTS ${__OpenSG_LIBRARIES_SEARCH_DIRS}
PATH_SUFFIXES "/dbg"
)
ENDIF(WIN32)
__OpenSG_ADJUST_LIB_VARS(${UPPERCOMPONENT})
ENDFOREACH(COMPONENT)
# ------------------------------------------------------------------------
# End finding OpenSG libraries
# ------------------------------------------------------------------------
SET(OpenSG_INCLUDE_DIRS "${OpenSG_INCLUDE_DIR}" "${OpenSG_INCLUDE_DIR}/OpenSG")
SET(OpenSG_FOUND FALSE)
IF(OpenSG_INCLUDE_DIR)
SET(OpenSG_FOUND TRUE)
# check if all requested components were found
SET(__OpenSG_CHECKED_COMPONENT FALSE)
SET(__OpenSG_MISSING_COMPONENTS)
FOREACH(COMPONENT ${OpenSG_FIND_COMPONENTS})
STRING(TOUPPER ${COMPONENT} COMPONENT)
SET(__OpenSG_CHECKED_COMPONENT TRUE)
IF(NOT OpenSG_${COMPONENT}_FOUND)
STRING(TOLOWER ${COMPONENT} COMPONENT)
LIST(APPEND __OpenSG_MISSING_COMPONENTS ${COMPONENT})
SET(OpenSG_FOUND FALSE)
ENDIF(NOT OpenSG_${COMPONENT}_FOUND)
ENDFOREACH(COMPONENT)
IF(__OpenSG_MISSING_COMPONENTS)
# We were unable to find some libraries, so generate a sensible
# error message that lists the libraries we were unable to find.
SET(OpenSG_ERROR_REASON
"${OpenSG_ERROR_REASON}\nThe following OpenSG libraries could not be found:\n")
FOREACH(COMPONENT ${__OpenSG_MISSING_COMPONENTS})
SET(OpenSG_ERROR_REASON
"${OpenSG_ERROR_REASON} ${COMPONENT}\n")
ENDFOREACH(COMPONENT)
LIST(LENGTH OpenSG_FIND_COMPONENTS __OpenSG_NUM_COMPONENTS_WANTED)
LIST(LENGTH __OpenSG_MISSING_COMPONENTS __OpenSG_NUM_MISSING_COMPONENTS)
IF(${__OpenSG_NUM_COMPONENTS_WANTED} EQUAL ${__OpenSG_NUM_MISSING_COMPONENTS})
SET(OpenSG_ERROR_REASON
"${OpenSG_ERROR_REASON}No OpenSG libraries were found. You may need to set OPENSG_LIBRARY_DIR to the directory containing OpenSG libraries or OPENSG_ROOT to the location of OpenSG.")
ELSE(${__OpenSG_NUM_COMPONENTS_WANTED} EQUAL ${__OpenSG_NUM_MISSING_COMPONENTS})
SET(OpenSG_ERROR_REASON
"${OpenSG_ERROR_REASON}Some (but not all) of the required OpenSG libraries were found. You may need to install these additional OpenSG libraries. Alternatively, set OPENSG_LIBRARY_DIR to the directory containing OpenSG libraries or OPENSG_ROOT to the location of OpenSG.")
ENDIF(${__OpenSG_NUM_COMPONENTS_WANTED} EQUAL ${__OpenSG_NUM_MISSING_COMPONENTS})
ENDIF(__OpenSG_MISSING_COMPONENTS)
ENDIF(OpenSG_INCLUDE_DIR)
IF(OpenSG_FOUND)
IF(NOT OpenSG_FIND_QUIETLY)
MESSAGE(STATUS "OpenSG found.")
ENDIF(NOT OpenSG_FIND_QUIETLY)
IF (NOT OpenSG_FIND_QUIETLY)
MESSAGE(STATUS "Found the following OpenSG libraries:")
ENDIF(NOT OpenSG_FIND_QUIETLY)
FOREACH(COMPONENT ${OpenSG_FIND_COMPONENTS})
STRING(TOUPPER ${COMPONENT} UPPERCOMPONENT)
IF(OpenSG_${UPPERCOMPONENT}_FOUND)
IF(NOT OpenSG_FIND_QUIETLY)
MESSAGE(STATUS " ${COMPONENT}")
ENDIF(NOT OpenSG_FIND_QUIETLY)
SET(OpenSG_LIBRARIES ${OpenSG_LIBRARIES} ${OpenSG_${UPPERCOMPONENT}_LIBRARY})
ENDIF(OpenSG_${UPPERCOMPONENT}_FOUND)
ENDFOREACH(COMPONENT)
ELSE(OpenSG_FOUND)
IF(OpenSG_FIND_REQUIRED)
MESSAGE(SEND_ERROR "Unable to find the requested OpenSG libraries.\n${OpenSG_ERROR_REASON}")
ENDIF(OpenSG_FIND_REQUIRED)
ENDIF(OpenSG_FOUND)
ENDIF(__OpenSG_IN_CACHE)
FindOpenSGSupportlibs.cmake 0 → 100644
+ 45
− 0
View file @ e63887f1
# - Try to find OpenSGSupportlibs
# Once done, this will define
#
# OpenSGSupportlibs_FOUND
# OpenSGSupportlibs_INCLUDE_DIRS
# OpenSGSupportlibs_LIBRARIES
if (NOT OpenSGSupportlibs_FOUND)
include(LibFindMacros)
# Visual Studio x32
if (VS32)
# Visual Studio x32
find_path( OpenSGSupportlibs_INCLUDE_DIR
NAMES zlib.h
PATHS ${LIBRARIES_DIR}/supportlibs/include
${CMAKE_SOURCE_DIR}/../supportlibs/include )
find_library(OpenSGSupportlibs_LIBRARY
NAMES glut32 libjpg libpng tif32 zlib
PATHS ${LIBRARIES_DIR}/supportlibs/lib
${CMAKE_SOURCE_DIR}/../supportlibs/lib )
else (VS32)
if (VS64)
# Visual Studio x64
find_path( OpenSGSupportlibs_INCLUDE_DIR
NAMES zlib.h
PATHS ${LIBRARIES_DIR}/supportlibs_x64/include
${CMAKE_SOURCE_DIR}/../supportlibs_x64/include )
find_library(OpenSGSupportlibs_LIBRARY
NAMES glut32 libjpg libpng tif32 zlib
PATHS ${LIBRARIES_DIR}/supportlibs_x64/lib
${CMAKE_SOURCE_DIR}/../supportlibs_x64/lib )
endif(VS64)
endif (VS32)
# Set the include dir variables and the libraries and let libfind_process do the rest.
# NOTE: Singular variables for this library, plural for libraries this this lib depends on.
set(OpenSGSupportlibs_PROCESS_INCLUDES OpenSGSupportlibs_INCLUDE_DIR)
set(OpenSGSupportlibs_PROCESS_LIBS OpenSGSupportlibs_LIBRARY)
libfind_process(OpenSGSupportlibs)
endif (NOT OpenSGSupportlibs_FOUND)
\ No newline at end of file
LibFindMacros.cmake 0 → 100644
+ 101
− 0
View file @ e63887f1
# Works the same as find_package, but forwards the "REQUIRED" and "QUIET" arguments
# used for the current package. For this to work, the first parameter must be the
# prefix of the current package, then the prefix of the new package etc, which are
# passed to find_package.
macro (libfind_package PREFIX)
set (LIBFIND_PACKAGE_ARGS ${ARGN})
if (${PREFIX}_FIND_QUIETLY)
set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} QUIET)
endif (${PREFIX}_FIND_QUIETLY)
if (${PREFIX}_FIND_REQUIRED)
set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} REQUIRED)
endif (${PREFIX}_FIND_REQUIRED)
find_package(${LIBFIND_PACKAGE_ARGS})
endmacro (libfind_package)
# Damn CMake developers made the UsePkgConfig system deprecated in the same release (2.6)
# where they added pkg_check_modules. Consequently I need to support both in my scripts
# to avoid those deprecated warnings. Here's a helper that does just that.
# Works identically to pkg_check_modules, except that no checks are needed prior to use.
macro (libfind_pkg_check_modules PREFIX PKGNAME)
if (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
include(UsePkgConfig)
pkgconfig(${PKGNAME} ${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARY_DIRS ${PREFIX}_LDFLAGS ${PREFIX}_CFLAGS)
else (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
find_package(PkgConfig)
if (PKG_CONFIG_FOUND)
pkg_check_modules(${PREFIX} ${PKGNAME})
endif (PKG_CONFIG_FOUND)
endif (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
endmacro (libfind_pkg_check_modules)
# Do the final processing once the paths have been detected.
# If include dirs are needed, ${PREFIX}_PROCESS_INCLUDES should be set to contain
# all the variables, each of which contain one include directory.
# Ditto for ${PREFIX}_PROCESS_LIBS and library files.
# Will set ${PREFIX}_FOUND, ${PREFIX}_INCLUDE_DIRS and ${PREFIX}_LIBRARIES.
# Also handles errors in case library detection was required, etc.
macro (libfind_process PREFIX)
# Skip processing if already processed during this run
if (NOT ${PREFIX}_FOUND)
# Start with the assumption that the library was found
set (${PREFIX}_FOUND TRUE CACHE INTERNAL "Whether the OpenSG support libraries were found")
# Process all includes and set _FOUND to false if any are missing
foreach (i ${${PREFIX}_PROCESS_INCLUDES})
if (${i})
set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIRS} ${${i}})
mark_as_advanced(${i})
else (${i})
set (${PREFIX}_FOUND FALSE)
endif (${i})
endforeach (i)
# Process all libraries and set _FOUND to false if any are missing
foreach (i ${${PREFIX}_PROCESS_LIBS})
if (${i})
set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARIES} ${${i}})
mark_as_advanced(${i})
else (${i})
set (${PREFIX}_FOUND FALSE)
endif (${i})
endforeach (i)
# Print message and/or exit on fatal error
if (${PREFIX}_FOUND)
if (NOT ${PREFIX}_FIND_QUIETLY)
message (STATUS "Found ${PREFIX} ${${PREFIX}_VERSION}")
endif (NOT ${PREFIX}_FIND_QUIETLY)
else (${PREFIX}_FOUND)
if (${PREFIX}_FIND_REQUIRED)
foreach (i ${${PREFIX}_PROCESS_INCLUDES} ${${PREFIX}_PROCESS_LIBS})
message("${i}=${${i}}")
endforeach (i)
message (FATAL_ERROR "Required library ${PREFIX} NOT FOUND.\nInstall the library (dev version) and try again. If the library is already installed, use ccmake to set the missing variables manually.")
endif (${PREFIX}_FIND_REQUIRED)
endif (${PREFIX}_FOUND)
endif (NOT ${PREFIX}_FOUND)
# Cache libraries variable
SET (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARIES} CACHE STRING "${PREFIX} libraries")
endmacro (libfind_process)
macro(libfind_library PREFIX basename)
set(TMP "")
if(MSVC80)
set(TMP -vc80)
endif(MSVC80)
if(MSVC90)
set(TMP -vc90)
endif(MSVC90)
set(${PREFIX}_LIBNAMES ${basename}${TMP})
if(${ARGC} GREATER 2)
set(${PREFIX}_LIBNAMES ${basename}${TMP}-${ARGV2})
string(REGEX REPLACE "\\." "_" TMP ${${PREFIX}_LIBNAMES})
set(${PREFIX}_LIBNAMES ${${PREFIX}_LIBNAMES} ${TMP})
endif(${ARGC} GREATER 2)
find_library(${PREFIX}_LIBRARY
NAMES ${${PREFIX}_LIBNAMES}
PATHS ${${PREFIX}_PKGCONF_LIBRARY_DIRS}
)
endmacro(libfind_library)
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment