diff --git a/FindMSVCRedist.cmake b/FindMSVCRedist.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..099defc8f1372fb85ee33fdc9466a67eb1f132bf
--- /dev/null
+++ b/FindMSVCRedist.cmake
@@ -0,0 +1,41 @@
+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
diff --git a/FindOpenSG.cmake b/FindOpenSG.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7ad3d2b6b34cfe2ce1528269d2505f74c5569867
--- /dev/null
+++ b/FindOpenSG.cmake
@@ -0,0 +1,328 @@
+# - 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)
diff --git a/FindOpenSGSupportlibs.cmake b/FindOpenSGSupportlibs.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a1a6ee697f605af40a19a608aa09eec878623747
--- /dev/null
+++ b/FindOpenSGSupportlibs.cmake
@@ -0,0 +1,45 @@
+# - 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
diff --git a/LibFindMacros.cmake b/LibFindMacros.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..2195d141a59a060f47203a28b6171441bb5f7e97
--- /dev/null
+++ b/LibFindMacros.cmake
@@ -0,0 +1,101 @@
+# 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)