Changed: Updated CMale modules

--HG--
branch : hotfix

code/CMakeModules/AndroidToolChain.cmake

@@ -26,63 +26,46 @@ IF(TARGET_CPU STREQUAL "armv7")
   SET(LIBRARY_ARCHITECTURE "armeabi-v7a")
   SET(CMAKE_SYSTEM_PROCESSOR "armv7")
   SET(TOOLCHAIN_ARCH "arm")
-  SET(TOOLCHAIN_PREFIX "arm-linux-androideabi")
+  SET(GCC_TOOLCHAIN_PREFIX "arm-linux-androideabi")
   SET(TOOLCHAIN_BIN_PREFIX "arm")
   SET(MINIMUM_NDK_TARGET 4)
 ELSEIF(TARGET_CPU STREQUAL "armv5")
   SET(LIBRARY_ARCHITECTURE "armeabi")
   SET(CMAKE_SYSTEM_PROCESSOR "armv5")
   SET(TOOLCHAIN_ARCH "arm")
-  SET(TOOLCHAIN_PREFIX "arm-linux-androideabi")
+  SET(GCC_TOOLCHAIN_PREFIX "arm-linux-androideabi")
   SET(TOOLCHAIN_BIN_PREFIX "arm")
   SET(MINIMUM_NDK_TARGET 4)
 ELSEIF(TARGET_CPU STREQUAL "x86")
   SET(LIBRARY_ARCHITECTURE "x86")
   SET(CMAKE_SYSTEM_PROCESSOR "x86")
   SET(TOOLCHAIN_ARCH "x86")
-  SET(TOOLCHAIN_PREFIX "x86")
+  SET(GCC_TOOLCHAIN_PREFIX "x86")
   SET(TOOLCHAIN_BIN_PREFIX "i686")
   SET(MINIMUM_NDK_TARGET 9)
 ELSEIF(TARGET_CPU STREQUAL "mips")
   SET(LIBRARY_ARCHITECTURE "mips")
   SET(CMAKE_SYSTEM_PROCESSOR "mips")
   SET(TOOLCHAIN_ARCH "mips")
-  SET(TOOLCHAIN_PREFIX "mipsel-linux-android")
+  SET(GCC_TOOLCHAIN_PREFIX "mipsel-linux-android")
   SET(TOOLCHAIN_BIN_PREFIX "mipsel")
   SET(MINIMUM_NDK_TARGET 9)
 ENDIF(TARGET_CPU STREQUAL "armv7")
 
+SET(ANDROID_COMPILER "GCC")
+
+IF(NDK_TOOLCHAIN_VERSION STREQUAL "clang")
+  SET(ANDROID_COMPILER "clang")
+  SET(CLANG_TOOLCHAIN_PREFIX "llvm")
+  SET(CLANG ON)
+ELSE()
+  SET(GCC_TOOLCHAIN_VERSION ${NDK_TOOLCHAIN_VERSION})
+ENDIF()
+
 IF(NOT NDK_TARGET)
   SET(NDK_TARGET ${MINIMUM_NDK_TARGET})
 ENDIF(NOT NDK_TARGET)
 
-FILE(GLOB _TOOLCHAIN_VERSIONS "${NDK_ROOT}/toolchains/${TOOLCHAIN_PREFIX}-*")
-IF(_TOOLCHAIN_VERSIONS)
-  LIST(SORT _TOOLCHAIN_VERSIONS)
-  LIST(REVERSE _TOOLCHAIN_VERSIONS)
-  FOREACH(_TOOLCHAIN_VERSION ${_TOOLCHAIN_VERSIONS})
-    STRING(REGEX REPLACE ".+${TOOLCHAIN_PREFIX}-([0-9.]+)" "\\1" _TOOLCHAIN_VERSION "${_TOOLCHAIN_VERSION}")
-    IF(_TOOLCHAIN_VERSION MATCHES "^([0-9.]+)$")
-      LIST(APPEND NDK_TOOLCHAIN_VERSIONS ${_TOOLCHAIN_VERSION})
-    ENDIF(_TOOLCHAIN_VERSION MATCHES "^([0-9.]+)$")
-  ENDFOREACH(_TOOLCHAIN_VERSION)
-ENDIF(_TOOLCHAIN_VERSIONS)
-
-IF(NOT NDK_TOOLCHAIN_VERSIONS)
-  MESSAGE(FATAL_ERROR "No Android toolchain found in default search path ${NDK_ROOT}/toolchains")
-ENDIF(NOT NDK_TOOLCHAIN_VERSIONS)
-
-IF(NDK_TOOLCHAIN_VERSION)
-  LIST(FIND NDK_TOOLCHAIN_VERSIONS "${NDK_TOOLCHAIN_VERSION}" _INDEX)
-  IF(_INDEX EQUAL -1)
-    LIST(GET NDK_TOOLCHAIN_VERSIONS 0 NDK_TOOLCHAIN_VERSION)
-  ENDIF(_INDEX EQUAL -1)
-ELSE(NDK_TOOLCHAIN_VERSION)
-  LIST(GET NDK_TOOLCHAIN_VERSIONS 0 NDK_TOOLCHAIN_VERSION)
-ENDIF(NDK_TOOLCHAIN_VERSION)
-
-MESSAGE(STATUS "Target Android NDK ${NDK_TARGET} and use GCC ${NDK_TOOLCHAIN_VERSION}")
-
 IF(CMAKE_HOST_WIN32)
   SET(TOOLCHAIN_HOST "windows")
   SET(TOOLCHAIN_BIN_SUFFIX ".exe")
@@ -94,33 +77,73 @@ ELSEIF(CMAKE_HOST_UNIX)
   SET(TOOLCHAIN_BIN_SUFFIX "")
 ENDIF(CMAKE_HOST_WIN32)
 
-SET(TOOLCHAIN_ROOT "${NDK_ROOT}/toolchains/${TOOLCHAIN_PREFIX}-${NDK_TOOLCHAIN_VERSION}/prebuilt/${TOOLCHAIN_HOST}")
-SET(PLATFORM_ROOT "${NDK_ROOT}/platforms/android-${NDK_TARGET}/arch-${TOOLCHAIN_ARCH}")
+MACRO(SEARCH_TOOLCHAIN _COMPILER)
+  SET(${_COMPILER}_TOOLCHAIN_VERSIONS)
+  FILE(GLOB _TOOLCHAIN_VERSIONS "${NDK_ROOT}/toolchains/${${_COMPILER}_TOOLCHAIN_PREFIX}-*")
+  IF(_TOOLCHAIN_VERSIONS)
+    LIST(SORT _TOOLCHAIN_VERSIONS)
+    LIST(REVERSE _TOOLCHAIN_VERSIONS)
+    FOREACH(_TOOLCHAIN_VERSION ${_TOOLCHAIN_VERSIONS})
+      STRING(REGEX REPLACE ".+${_PREFIX}-([0-9.]+)" "\\1" _TOOLCHAIN_VERSION "${_TOOLCHAIN_VERSION}")
+      IF(_TOOLCHAIN_VERSION MATCHES "^([0-9.]+)$")
+        LIST(APPEND ${_COMPILER}_TOOLCHAIN_VERSIONS ${_TOOLCHAIN_VERSION})
+      ENDIF()
+    ENDFOREACH()
+  ENDIF()
+
+  IF(NOT ${_COMPILER}_TOOLCHAIN_VERSIONS)
+    MESSAGE(FATAL_ERROR "No Android ${_COMPILER} toolchain found in default search path ${NDK_ROOT}/toolchains")
+  ENDIF()
+
+  IF(${_COMPILER}_TOOLCHAIN_VERSIONS)
+    LIST(FIND ${_COMPILER}_TOOLCHAIN_VERSIONS "${${_COMPILER}_TOOLCHAIN_VERSION}" _INDEX)
+    IF(_INDEX EQUAL -1)
+      LIST(GET ${_COMPILER}_TOOLCHAIN_VERSIONS 0 ${_COMPILER}_TOOLCHAIN_VERSION)
+    ENDIF()
+  ELSE()
+    LIST(GET ${_COMPILER}_TOOLCHAIN_VERSIONS 0 ${_COMPILER}_TOOLCHAIN_VERSION)
+  ENDIF()
+
+  SET(${_COMPILER}_TOOLCHAIN_ROOT "${NDK_ROOT}/toolchains/${${_COMPILER}_TOOLCHAIN_PREFIX}-${${_COMPILER}_TOOLCHAIN_VERSION}/prebuilt/${TOOLCHAIN_HOST}")
 
-IF(NOT EXISTS "${TOOLCHAIN_ROOT}")
-  FILE(GLOB _TOOLCHAIN_PREFIXES "${TOOLCHAIN_ROOT}*")
+  IF(NOT EXISTS "${${_COMPILER}_TOOLCHAIN_ROOT}")
+    FILE(GLOB _TOOLCHAIN_PREFIXES "${${_COMPILER}_TOOLCHAIN_ROOT}*")
     IF(_TOOLCHAIN_PREFIXES)
-    LIST(GET _TOOLCHAIN_PREFIXES 0 TOOLCHAIN_ROOT)
+      LIST(GET _TOOLCHAIN_PREFIXES 0 ${_COMPILER}_TOOLCHAIN_ROOT)
     ENDIF(_TOOLCHAIN_PREFIXES)
-ENDIF(NOT EXISTS "${TOOLCHAIN_ROOT}")
+  ENDIF()
+ENDMACRO()
+
+IF(CLANG)
+  SEARCH_TOOLCHAIN(CLANG)
+
+  MESSAGE(STATUS "Target Android NDK ${NDK_TARGET} and use clang ${CLANG_TOOLCHAIN_VERSION}")
+ENDIF()
+
+SEARCH_TOOLCHAIN(GCC)
+
+MESSAGE(STATUS "Target Android NDK ${NDK_TARGET} and use GCC ${GCC_TOOLCHAIN_VERSION}")
+MESSAGE(STATUS "Found Android LLVM toolchain in ${CLANG_TOOLCHAIN_ROOT}")
+MESSAGE(STATUS "Found Android GCC toolchain in ${GCC_TOOLCHAIN_ROOT}")
+
+SET(PLATFORM_ROOT "${NDK_ROOT}/platforms/android-${NDK_TARGET}/arch-${TOOLCHAIN_ARCH}")
 
-MESSAGE(STATUS "Found Android toolchain in ${TOOLCHAIN_ROOT}")
 MESSAGE(STATUS "Found Android platform in ${PLATFORM_ROOT}")
 
 # include dirs
 SET(PLATFORM_INCLUDE_DIR "${PLATFORM_ROOT}/usr/include")
 SET(STL_DIR "${NDK_ROOT}/sources/cxx-stl/gnu-libstdc++")
 
-IF(EXISTS "${STL_DIR}/${NDK_TOOLCHAIN_VERSION}")
+IF(EXISTS "${STL_DIR}/${GCC_TOOLCHAIN_VERSION}")
   # NDK version >= 8b
-  SET(STL_DIR "${STL_DIR}/${NDK_TOOLCHAIN_VERSION}")
-ENDIF(EXISTS "${STL_DIR}/${NDK_TOOLCHAIN_VERSION}")
+  SET(STL_DIR "${STL_DIR}/${GCC_TOOLCHAIN_VERSION}")
+ENDIF(EXISTS "${STL_DIR}/${GCC_TOOLCHAIN_VERSION}")
 
 # Determine bin prefix for toolchain
-FILE(GLOB _TOOLCHAIN_BIN_PREFIXES "${TOOLCHAIN_ROOT}/bin/${TOOLCHAIN_BIN_PREFIX}-*-gcc${TOOLCHAIN_BIN_SUFFIX}")
+FILE(GLOB _TOOLCHAIN_BIN_PREFIXES "${GCC_TOOLCHAIN_ROOT}/bin/${TOOLCHAIN_BIN_PREFIX}-*-gcc${TOOLCHAIN_BIN_SUFFIX}")
 IF(_TOOLCHAIN_BIN_PREFIXES)
   LIST(GET _TOOLCHAIN_BIN_PREFIXES 0 _TOOLCHAIN_BIN_PREFIX)
-  STRING(REGEX REPLACE "${TOOLCHAIN_ROOT}/bin/([a-z0-9-]+)-gcc${TOOLCHAIN_BIN_SUFFIX}" "\\1" TOOLCHAIN_BIN_PREFIX "${_TOOLCHAIN_BIN_PREFIX}")
+  STRING(REGEX REPLACE "${GCC_TOOLCHAIN_ROOT}/bin/([a-z0-9-]+)-gcc${TOOLCHAIN_BIN_SUFFIX}" "\\1" TOOLCHAIN_BIN_PREFIX "${_TOOLCHAIN_BIN_PREFIX}")
 ENDIF(_TOOLCHAIN_BIN_PREFIXES)
 
 SET(STL_INCLUDE_DIR "${STL_DIR}/include")
@@ -128,22 +151,48 @@ SET(STL_LIBRARY_DIR "${STL_DIR}/libs/${LIBRARY_ARCHITECTURE}")
 SET(STL_INCLUDE_CPU_DIR "${STL_LIBRARY_DIR}/include")
 SET(STL_LIBRARY "${STL_LIBRARY_DIR}/libgnustl_static.a")
 
-SET(CMAKE_FIND_ROOT_PATH ${TOOLCHAIN_ROOT} ${PLATFORM_ROOT}/usr ${CMAKE_PREFIX_PATH} ${CMAKE_INSTALL_PREFIX} $ENV{EXTERNAL_ANDROID_PATH} CACHE string  "Android find search path root")
+MESSAGE(STATUS "STL include dir: ${STL_INCLUDE_DIR}")
+MESSAGE(STATUS "STL library dir: ${STL_LIBRARY_DIR}")
+
+SET(CMAKE_FIND_ROOT_PATH ${CLANG_TOOLCHAIN_ROOT} ${GCC_TOOLCHAIN_ROOT} ${PLATFORM_ROOT}/usr ${CMAKE_PREFIX_PATH} ${CMAKE_INSTALL_PREFIX} $ENV{EXTERNAL_ANDROID_PATH} CACHE string  "Android find search path root")
 
 SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
 SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 
-INCLUDE_DIRECTORIES(${STL_INCLUDE_DIR} ${STL_INCLUDE_CPU_DIR})
-
 MACRO(SET_TOOLCHAIN_BINARY _NAME _BINARY)
-  SET(${_NAME} ${TOOLCHAIN_ROOT}/bin/${TOOLCHAIN_BIN_PREFIX}-${_BINARY}${TOOLCHAIN_BIN_SUFFIX})
+  IF("${_BINARY}" MATCHES "clang")
+    SET(${_NAME} ${CLANG_TOOLCHAIN_ROOT}/bin/${_BINARY}${TOOLCHAIN_BIN_SUFFIX} CACHE PATH "" FORCE )
+  ELSE()
+    SET(${_NAME} ${GCC_TOOLCHAIN_ROOT}/bin/${TOOLCHAIN_BIN_PREFIX}-${_BINARY}${TOOLCHAIN_BIN_SUFFIX} CACHE PATH "" FORCE)
+  ENDIF()
 ENDMACRO(SET_TOOLCHAIN_BINARY)
 
-SET_TOOLCHAIN_BINARY(CMAKE_C_COMPILER gcc)
-SET_TOOLCHAIN_BINARY(CMAKE_CXX_COMPILER g++)
-
 # Force the compilers to GCC for Android
 include (CMakeForceCompiler)
-CMAKE_FORCE_C_COMPILER(${CMAKE_C_COMPILER} GNU)
-CMAKE_FORCE_CXX_COMPILER(${CMAKE_CXX_COMPILER} GNU)
+
+IF(CLANG)
+  SET_TOOLCHAIN_BINARY(CMAKE_C_COMPILER clang)
+  SET_TOOLCHAIN_BINARY(CMAKE_CXX_COMPILER clang++)
+
+  CMAKE_FORCE_C_COMPILER(${CMAKE_C_COMPILER} clang)
+  CMAKE_FORCE_CXX_COMPILER(${CMAKE_CXX_COMPILER} clang)
+
+  MESSAGE(STATUS "Using clang compiler")
+ELSE()
+  SET_TOOLCHAIN_BINARY(CMAKE_C_COMPILER gcc)
+  SET_TOOLCHAIN_BINARY(CMAKE_CXX_COMPILER g++)
+
+  CMAKE_FORCE_C_COMPILER(${CMAKE_C_COMPILER} GNU)
+  CMAKE_FORCE_CXX_COMPILER(${CMAKE_CXX_COMPILER} GNU)
+
+  MESSAGE(STATUS "Using GCC compiler")
+ENDIF()
+
+SET_TOOLCHAIN_BINARY(CMAKE_STRIP strip)
+SET_TOOLCHAIN_BINARY(CMAKE_AR ar)
+SET_TOOLCHAIN_BINARY(CMAKE_LINKER ld)
+SET_TOOLCHAIN_BINARY(CMAKE_NM nm)
+SET_TOOLCHAIN_BINARY(CMAKE_OBJCOPY objcopy)
+SET_TOOLCHAIN_BINARY(CMAKE_OBJDUMP objdump)
+SET_TOOLCHAIN_BINARY(CMAKE_RANLIB ranlib)

code/CMakeModules/FindMSVC.cmake

@@ -57,6 +57,7 @@ ENDMACRO(DETECT_EXPRESS_VERSION)
 
 IF(MSVC12)
   DETECT_VC_VERSION("12.0")
+  SET(MSVC_TOOLSET "120")
 
   IF(NOT MSVC12_REDIST_DIR)
     # If you have VC++ 2013 Express, put x64/Microsoft.VC120.CRT/*.dll in ${EXTERNAL_PATH}/redist
@@ -64,6 +65,7 @@ IF(MSVC12)
   ENDIF(NOT MSVC11_REDIST_DIR)
 ELSEIF(MSVC11)
   DETECT_VC_VERSION("11.0")
+  SET(MSVC_TOOLSET "110")
 
   IF(NOT MSVC11_REDIST_DIR)
     # If you have VC++ 2012 Express, put x64/Microsoft.VC110.CRT/*.dll in ${EXTERNAL_PATH}/redist
@@ -71,6 +73,7 @@ ELSEIF(MSVC11)
   ENDIF(NOT MSVC11_REDIST_DIR)
 ELSEIF(MSVC10)
   DETECT_VC_VERSION("10.0")
+  SET(MSVC_TOOLSET "100")
 
   IF(NOT MSVC10_REDIST_DIR)
     # If you have VC++ 2010 Express, put x64/Microsoft.VC100.CRT/*.dll in ${EXTERNAL_PATH}/redist
@@ -78,8 +81,10 @@ ELSEIF(MSVC10)
   ENDIF(NOT MSVC10_REDIST_DIR)
 ELSEIF(MSVC90)
   DETECT_VC_VERSION("9.0")
+  SET(MSVC_TOOLSET "90")
 ELSEIF(MSVC80)
   DETECT_VC_VERSION("8.0")
+  SET(MSVC_TOOLSET "80")
 ENDIF(MSVC12)
 
 # If you plan to use VC++ compilers with WINE, set VC_DIR environment variable

code/CMakeModules/FindMySQL.cmake

@@ -13,7 +13,7 @@
 IF(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
    SET(MYSQL_FOUND TRUE)
 
-ELSE(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
+ELSE()
 
   FIND_PATH(MYSQL_INCLUDE_DIR mysql.h
       PATH_SUFFIXES mysql
@@ -33,7 +33,7 @@ ELSE(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
       PATHS
       $ENV{ProgramFiles}/MySQL/*/lib/opt
       $ENV{SystemDrive}/MySQL/*/lib/opt)
-  ELSE(WIN32 AND MSVC)
+  ELSE()
     FIND_LIBRARY(MYSQL_LIBRARY_RELEASE NAMES mysqlclient
       PATHS
       /usr/lib
@@ -51,31 +51,30 @@ ELSE(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
       /usr/local/lib/mysql
       /opt/local/lib/mysql5/mysql
       )
-  ENDIF(WIN32 AND MSVC)
+  ENDIF()
 
   IF(MYSQL_INCLUDE_DIR)
     IF(MYSQL_LIBRARY_RELEASE)
-      SET(MYSQL_LIBRARIES optimized ${MYSQL_LIBRARY_RELEASE})
       IF(MYSQL_LIBRARY_DEBUG)
-        SET(MYSQL_LIBRARIES ${MYSQL_LIBRARIES} debug ${MYSQL_LIBRARY_DEBUG})
-      ELSE(MYSQL_LIBRARY_DEBUG)
-	    SET(MYSQL_LIBRARIES ${MYSQL_LIBRARIES} debug ${MYSQL_LIBRARY_RELEASE})
-      ENDIF(MYSQL_LIBRARY_DEBUG)
+        SET(MYSQL_LIBRARIES optimized ${MYSQL_LIBRARY_RELEASE} debug ${MYSQL_LIBRARY_DEBUG})
+      ELSE()
+	    SET(MYSQL_LIBRARIES ${MYSQL_LIBRARY_RELEASE})
+      ENDIF()
       FIND_PACKAGE(OpenSSL)
       IF(OPENSSL_FOUND)
         SET(MYSQL_LIBRARIES ${MYSQL_LIBRARIES} ${OPENSSL_LIBRARIES})
-      ENDIF(OPENSSL_FOUND)
-    ENDIF(MYSQL_LIBRARY_RELEASE)
-  ENDIF(MYSQL_INCLUDE_DIR)
+      ENDIF()
+    ENDIF()
+  ENDIF()
 
   IF(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
     SET(MYSQL_FOUND TRUE)
     MESSAGE(STATUS "Found MySQL: ${MYSQL_INCLUDE_DIR}, ${MYSQL_LIBRARIES}")
-  ELSE(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
+  ELSE()
     SET(MYSQL_FOUND FALSE)
     MESSAGE(STATUS "MySQL not found.")
-  ENDIF(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
+  ENDIF()
 
   MARK_AS_ADVANCED(MYSQL_LIBRARY_RELEASE MYSQL_LIBRARY_DEBUG)
 
-ENDIF(MYSQL_INCLUDE_DIR AND MYSQL_LIBRARIES)
+ENDIF()

code/CMakeModules/FindWindowsSDK.cmake

@@ -68,6 +68,10 @@ ENDIF(WINSDKCURRENT_VERSION_INCLUDE)
 
 SET(WINSDKENV_DIR $ENV{WINSDK_DIR})
 
+IF(NOT WINSDKENV_DIR)
+  SET(WINSDKENV_DIR $ENV{WindowsSDKDir})
+ENDIF(NOT WINSDKENV_DIR)
+
 MACRO(FIND_WINSDK_VERSION_HEADERS)
   IF(WINSDK_DIR AND NOT WINSDK_VERSION)
     # Search version in headers
@@ -78,7 +82,6 @@ MACRO(FIND_WINSDK_VERSION_HEADERS)
     )
 
     IF(_MSI_FILE)
-
       # Look for Windows SDK 8.0
       FILE(STRINGS ${_MSI_FILE} _CONTENT REGEX "^#ifndef NTDDI_WIN8")
 
@@ -181,7 +184,7 @@ MACRO(USE_CURRENT_WINSDK)
       # Look for Windows.h because there are several paths
       IF(EXISTS ${_INCLUDE}/Windows.h)
         STRING(REGEX REPLACE "/(include|INCLUDE|Include)(.*)" "" WINSDK_DIR ${_INCLUDE})
-        MESSAGE(STATUS "Found Windows SDK from include environment variable in ${WINSDK_DIR}")
+        MESSAGE(STATUS "Found Windows SDK in INCLUDE environment variable: ${WINSDK_DIR}")
         BREAK()
       ENDIF(EXISTS ${_INCLUDE}/Windows.h)
     ENDFOREACH(_INCLUDE)
@@ -280,6 +283,13 @@ FIND_PATH(WINSDK_SHARED_INCLUDE_DIR d3d9.h
   ${WINSDK_DIR}/Include
 )
 
+# directory where OpenGL headers are found
+FIND_PATH(WINSDK_OPENGL_INCLUDE_DIR GL.h
+  HINTS
+  ${WINSDK_DIR}/Include/gl
+  ${WINSDK_DIR}/Include
+)
+
 # directory where all libraries are found
 FIND_PATH(WINSDK_LIBRARY_DIR ComCtl32.lib
   HINTS
@@ -303,7 +313,7 @@ FIND_PROGRAM(WINSDK_MIDL midl
 
 IF(WINSDK_INCLUDE_DIR)
   SET(WINSDK_FOUND ON)
-  SET(WINSDK_INCLUDE_DIRS ${WINSDK_INCLUDE_DIR} ${WINSDK_SHARED_INCLUDE_DIR})
+  SET(WINSDK_INCLUDE_DIRS ${WINSDK_INCLUDE_DIR} ${WINSDK_SHARED_INCLUDE_DIR} ${WINSDK_OPENGL_INCLUDE_DIR})
   SET(CMAKE_LIBRARY_PATH ${WINSDK_LIBRARY_DIR} ${CMAKE_LIBRARY_PATH})
   INCLUDE_DIRECTORIES(${WINSDK_INCLUDE_DIRS})
 

code/CMakeModules/GetRevision.cmake

@@ -13,38 +13,44 @@ IF(SOURCE_DIR)
 
   IF(NOT ROOT_DIR AND SOURCE_DIR)
     SET(ROOT_DIR ${SOURCE_DIR})
-  ENDIF(NOT ROOT_DIR AND SOURCE_DIR)
+  ENDIF()
 
   IF(NOT SOURCE_DIR AND ROOT_DIR)
     SET(SOURCE_DIR ${ROOT_DIR})
-  ENDIF(NOT SOURCE_DIR AND ROOT_DIR)
-ELSE(SOURCE_DIR)
+  ENDIF()
+ELSE()
   SET(SOURCE_DIR ${CMAKE_SOURCE_DIR})
   SET(ROOT_DIR ${CMAKE_SOURCE_DIR})
-ENDIF(SOURCE_DIR)
+ENDIF()
 
 MACRO(NOW RESULT)
   IF (WIN32)
     EXECUTE_PROCESS(COMMAND "wmic" "os" "get" "localdatetime" OUTPUT_VARIABLE DATETIME)
     IF(NOT DATETIME MATCHES "ERROR")
       STRING(REGEX REPLACE ".*\n([0-9][0-9][0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9]).*" "\\1-\\2-\\3 \\4:\\5:\\6" ${RESULT} "${DATETIME}")
-    ENDIF(NOT DATETIME MATCHES "ERROR")
+    ENDIF()
   ELSEIF(UNIX)
     EXECUTE_PROCESS(COMMAND "date" "+%Y-%m-%d %H:%M:%S" OUTPUT_VARIABLE DATETIME)
     STRING(REGEX REPLACE "([0-9: -]+).*" "\\1" ${RESULT} "${DATETIME}")
-  ELSE (WIN32)
+  ELSE()
     MESSAGE(SEND_ERROR "date not implemented")
     SET(${RESULT} "0000-00-00 00:00:00")
-  ENDIF (WIN32)
+  ENDIF()
 ENDMACRO(NOW)
 
 IF(EXISTS "${ROOT_DIR}/.svn/")
-  FIND_PACKAGE(Subversion)
+  FIND_PACKAGE(Subversion QUIET)
 
   IF(SUBVERSION_FOUND)
     Subversion_WC_INFO(${ROOT_DIR} ER)
     SET(REVISION ${ER_WC_REVISION})
   ENDIF(SUBVERSION_FOUND)
+
+  FIND_PACKAGE(TortoiseSVN QUIET)
+
+  IF(TORTOISESVN_FOUND)
+    TORTOISESVN_GET_REVISION(${ROOT_DIR} REVISION)
+  ENDIF(TORTOISESVN_FOUND)
 ENDIF(EXISTS "${ROOT_DIR}/.svn/")
 
 IF(EXISTS "${ROOT_DIR}/.hg/")
@@ -55,8 +61,8 @@ IF(EXISTS "${ROOT_DIR}/.hg/")
     SET(REVISION ${ER_WC_REVISION})
     SET(CHANGESET ${ER_WC_CHANGESET})
     SET(BRANCH ${ER_WC_BRANCH})
-  ENDIF(MERCURIAL_FOUND)
-ENDIF(EXISTS "${ROOT_DIR}/.hg/")
+  ENDIF()
+ENDIF()
 
 # if processing exported sources, use "revision" file if exists
 IF(SOURCE_DIR AND NOT DEFINED REVISION)
@@ -64,8 +70,8 @@ IF(SOURCE_DIR AND NOT DEFINED REVISION)
   IF(EXISTS ${REVISION_FILE})
     FILE(STRINGS ${REVISION_FILE} REVISION LIMIT_COUNT 1)
     MESSAGE(STATUS "Read revision ${REVISION} from file")
-  ENDIF(EXISTS ${REVISION_FILE})
-ENDIF(SOURCE_DIR AND NOT DEFINED REVISION)
+  ENDIF()
+ENDIF()
 
 IF(SOURCE_DIR AND DEFINED REVISION)
   IF(EXISTS ${SOURCE_DIR}/revision.h.in)
@@ -73,5 +79,5 @@ IF(SOURCE_DIR AND DEFINED REVISION)
     NOW(BUILD_DATE)
     CONFIGURE_FILE(${SOURCE_DIR}/revision.h.in revision.h.txt)
     EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E copy revision.h.txt revision.h) # copy_if_different
-  ENDIF(EXISTS ${SOURCE_DIR}/revision.h.in)
-ENDIF(SOURCE_DIR AND DEFINED REVISION)
+  ENDIF()
+ENDIF()