Announcement

Collapse
No announcement yet.

Static Linking error for Bullet Physics Engine

Collapse
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • Static Linking error for Bullet Physics Engine

    I'm trying to import the library Bullet physics to unreal engine source.

    But I'm having problem with static linking of library, I get this error: unresolved external symbol _DllMainCRTStartup

    Code:
     Creating makefile for UE4Editor (no existing makefile)
    2>  Performing 2 actions (4 in parallel)
    2>  [1/2] Link UE4Editor-Engine.dll
    2>  [2/2] Link UE4Editor-Bullet.dll
    2>LINK : error LNK2001: unresolved external symbol _DllMainCRTStartup
    2>D:\WorkSpace\GitHubProjects\UE_4.16\UnrealEngine\Engine\Binaries\Win64\UE4Editor-Bullet.dll : fatal error LNK1120: 1 unresolved externals
    2>     Creating library D:\WorkSpace\GitHubProjects\UE_4.16\UnrealEngine\Engine\Intermediate\Build\Win64\UE4Editor\Development\UE4Editor-Engine.suppressed.lib and object D:\WorkSpace\GitHubProjects\UE_4.16\UnrealEngine\Engine\Intermediate\Build\Win64\UE4Editor\Development\UE4Editor-Engine.suppressed.exp
    2>ERROR : UBT error : Failed to produce item: D:\WorkSpace\GitHubProjects\UE_4.16\UnrealEngine\Engine\Binaries\Win64\UE4Editor-Bullet.dll
    Do you know what cause this error and how to fix it?

    What I did
    Step 1
    I've create Bullet VS project using CMake, then I've builded it.

    Step 2
    I've copyed either the include and lib directory to "\Engine\Source\ThirdParty\Bullet\build", created the file Bullet.Build.cs

    Bullet.Build.cs
    Code:
    using System.IO;
    using System;
    using UnrealBuildTool;
    
    public class Bullet : ModuleRules
    {
    
        enum BulletLibraryMode{
            Debug,
            Shipping
        }
    
        BulletLibraryMode GetPhysXLibraryMode(UnrealTargetConfiguration Config)
        {
            switch (Config)
            {
                case UnrealTargetConfiguration.Shipping:
                case UnrealTargetConfiguration.Test:
                    return BulletLibraryMode.Shipping;
                case UnrealTargetConfiguration.Development:
                case UnrealTargetConfiguration.DebugGame:
                case UnrealTargetConfiguration.Unknown:
                case UnrealTargetConfiguration.Debug:
                default:
                    return BulletLibraryMode.Debug;
            }
        }
    
        static string GetBulletLibrarySuffix(BulletLibraryMode Mode){
            switch (Mode){
                case BulletLibraryMode.Debug:
                    return "_Debug";
                case BulletLibraryMode.Shipping:
                default:
                    return "";
            }
        }
    
        public Bullet(ReadOnlyTargetRules Target) : base(Target){
    
            string BulletBaseDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "Bullet/build/";
            string PlatformDir = "";
    
            bool bSupported = false;
            if (Target.Platform == UnrealTargetPlatform.Win64)
            {
                bSupported = true;
                PlatformDir = "Win64/";
            }
            else if(Target.Platform == UnrealTargetPlatform.Win32)
            {
                bSupported = true;
                PlatformDir = "Win32/";
            }
    
            if (bSupported)
            {
                BulletBaseDir += PlatformDir;
                string LibraryPath = BulletBaseDir + "lib/";
                string IncludePath = BulletBaseDir + "include/bullet/";
                string Suffix = GetBulletLibrarySuffix(GetPhysXLibraryMode(Target.Configuration));
    
                PublicIncludePaths.Add(IncludePath);
    
                // Load libraries
    
                string[] BulletLibs = new string[] {
                    "Bullet2FileLoader",
                    "Bullet3Collision",
                    "Bullet3Common",
                    "Bullet3Dynamics",
                    "Bullet3Geometry",
                    "Bullet3OpenCL_clew",
                    "BulletCollision",
                    "BulletDynamics",
                    "BulletInverseDynamics",
                    "BulletSoftBody",
                    "LinearMath"
                };
    
                foreach (string Lib in BulletLibs)
                {
                    PublicAdditionalLibraries.Add(LibraryPath + Lib + Suffix + ".lib");
                }
    
            }
        }
    }
    Step 3
    Then I've added AddEngineThirdPartyPrivateStaticDependencies(Target, "Bullet"); to Engine.Build.cs

    Step 4
    After Generating project file using GenerateProjectFiles.bat I've builded the engine but I get the error described above.

    Do you know what cause this error and how to fix it?

  • #2
    I noticed Bullet's CMake has a rule that force the use of /MT (Multithreaded)

    Code:
    IF (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
    		#We statically link to reduce dependancies
    		FOREACH(flag_var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO )
    			IF(${flag_var} MATCHES "/MD")
    				STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
    			ENDIF(${flag_var} MATCHES "/MD")
    			IF(${flag_var} MATCHES "/MDd")
    				STRING(REGEX REPLACE "/MDd" "/MTd" ${flag_var} "${${flag_var}}")
    			ENDIF(${flag_var} MATCHES "/MDd")
    		ENDFOREACH(flag_var)
    	ENDIF (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
    So in the VS project file I swapped from /MTd to /MDd but the problem remain.

    Comment


    • #3
      Are you building 64 bit?

      Comment


      • #4
        Do you mean Bullet? Yes I'm building 64 bit.

        This is how the CMake program look like:
        Click image for larger version

Name:	Untitled.png
Views:	1
Size:	99.8 KB
ID:	1130231

        This is the CMakeList.txt
        Code:
        cmake_minimum_required(VERSION 2.4.3)
        set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
        cmake_policy(SET CMP0017 NEW)
        #this line has to appear before 'PROJECT' in order to be able to disable incremental linking
        SET(MSVC_INCREMENTAL_DEFAULT ON)
        
        PROJECT(BULLET_PHYSICS)
        FILE (STRINGS "VERSION" BULLET_VERSION)
        
        IF(COMMAND cmake_policy)
           cmake_policy(SET CMP0003 NEW)
           if(POLICY CMP0042)
              # Enable MACOSX_RPATH by default.
              cmake_policy(SET CMP0042 NEW)
           endif(POLICY CMP0042)
        ENDIF(COMMAND cmake_policy)
        
        
        IF (NOT CMAKE_BUILD_TYPE)
        # SET(CMAKE_BUILD_TYPE "Debug")
         SET(CMAKE_BUILD_TYPE "Release")
        ENDIF (NOT CMAKE_BUILD_TYPE)
        
        SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_DEBUG")
        #MESSAGE("CMAKE_CXX_FLAGS_DEBUG="+${CMAKE_CXX_FLAGS_DEBUG})
        
        OPTION(USE_DOUBLE_PRECISION "Use double precision"	OFF)
        OPTION(USE_GRAPHICAL_BENCHMARK "Use Graphical Benchmark" ON)
        OPTION(BUILD_SHARED_LIBS "Use shared libraries" OFF)
        OPTION(USE_SOFT_BODY_MULTI_BODY_DYNAMICS_WORLD "Use btSoftMultiBodyDynamicsWorld" OFF)
        
        OPTION(BULLET2_USE_THREAD_LOCKS "Build Bullet 2 libraries with mutex locking around certain operations (required for multi-threading)" OFF)
        IF (BULLET2_USE_THREAD_LOCKS)
            OPTION(BULLET2_USE_OPEN_MP_MULTITHREADING "Build Bullet 2 with support for multi-threading with OpenMP (requires a compiler with OpenMP support)" OFF)
            OPTION(BULLET2_USE_TBB_MULTITHREADING "Build Bullet 2 with support for multi-threading with Intel Threading Building Blocks (requires the TBB library to be already installed)" OFF)
            IF (MSVC)
                OPTION(BULLET2_USE_PPL_MULTITHREADING "Build Bullet 2 with support for multi-threading with Microsoft Parallel Patterns Library (requires MSVC compiler)" OFF)
            ENDIF (MSVC)
        ENDIF (BULLET2_USE_THREAD_LOCKS)
        
        OPTION(USE_MSVC_INCREMENTAL_LINKING "Use MSVC Incremental Linking" OFF)
        OPTION(USE_CUSTOM_VECTOR_MATH "Use custom vectormath library" OFF)
        
        #statically linking VC++ isn't supported for WindowsPhone/WindowsStore
        IF (CMAKE_SYSTEM_NAME STREQUAL WindowsPhone OR CMAKE_SYSTEM_NAME STREQUAL WindowsStore)
        	OPTION(USE_MSVC_RUNTIME_LIBRARY_DLL "Use MSVC Runtime Library DLL (/MD or /MDd)" ON)
        ELSE ()
        	OPTION(USE_MSVC_RUNTIME_LIBRARY_DLL "Use MSVC Runtime Library DLL (/MD or /MDd)" OFF)
        ENDIF (CMAKE_SYSTEM_NAME STREQUAL WindowsPhone OR CMAKE_SYSTEM_NAME STREQUAL WindowsStore)
        
        #SET(CMAKE_EXE_LINKER_FLAGS_INIT    "/STACK:10000000 /INCREMENTAL:NO")
        #SET(CMAKE_EXE_LINKER_FLAGS    "/STACK:10000000 /INCREMENTAL:NO")
        
        #MESSAGE("MSVC_INCREMENTAL_YES_FLAG"+${MSVC_INCREMENTAL_YES_FLAG})
        
        IF(MSVC)
        	IF (NOT USE_MSVC_INCREMENTAL_LINKING)
        		#MESSAGE("MSVC_INCREMENTAL_DEFAULT"+${MSVC_INCREMENTAL_DEFAULT})
        		SET( MSVC_INCREMENTAL_YES_FLAG "/INCREMENTAL:NO")
        
        		STRING(REPLACE "INCREMENTAL:YES" "INCREMENTAL:NO" replacementFlags ${CMAKE_EXE_LINKER_FLAGS_DEBUG})
        		SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "/INCREMENTAL:NO ${replacementFlags}" )
        		MESSAGE("CMAKE_EXE_LINKER_FLAGS_DEBUG=${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
        
        		STRING(REPLACE "INCREMENTAL:YES" "INCREMENTAL:NO" replacementFlags2 ${CMAKE_EXE_LINKER_FLAGS})
        
        		SET(CMAKE_EXE_LINKER_FLAGS ${replacementFlag2})
        		STRING(REPLACE "INCREMENTAL:YES" "" replacementFlags3 "${CMAKE_EXTRA_LINK_FLAGS}")
        
        		SET(CMAKE_EXTRA_LINK_FLAGS ${replacementFlag3})
        
        
        		STRING(REPLACE "INCREMENTAL:YES" "INCREMENTAL:NO" replacementFlags3 "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO}")
        		SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO ${replacementFlags3})
        		SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "/INCREMENTAL:NO ${replacementFlags3}" )
        
        	ENDIF (NOT USE_MSVC_INCREMENTAL_LINKING)
        
        	IF (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
        		#We statically link to reduce dependancies
        		FOREACH(flag_var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO )
        			IF(${flag_var} MATCHES "/MD")
        				STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
        			ENDIF(${flag_var} MATCHES "/MD")
        			IF(${flag_var} MATCHES "/MDd")
        				STRING(REGEX REPLACE "/MDd" "/MTd" ${flag_var} "${${flag_var}}")
        			ENDIF(${flag_var} MATCHES "/MDd")
        		ENDFOREACH(flag_var)
        	ENDIF (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
        
        	IF (CMAKE_CL_64)
        	  ADD_DEFINITIONS(-D_WIN64)
        	ELSE()
        	  OPTION(USE_MSVC_SSE "Use MSVC /arch:sse option"	ON)
        	  option(USE_MSVC_SSE2 "Compile your program with SSE2 instructions" ON)
        
        	  IF (USE_MSVC_SSE)
        		  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:SSE")
        	  ENDIF()
        	  IF (USE_MSVC_SSE2)
        		  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:SSE2")
        	  ENDIF()
        
        	ENDIF()
        
        	option(USE_MSVC_AVX "Compile your program with AVX instructions"  OFF)
        
        	IF(USE_MSVC_AVX)
        		add_definitions(/arch:AVX)
        	ENDIF()
        
        	OPTION(USE_MSVC_FAST_FLOATINGPOINT "Use MSVC /fp:fast option"	ON)
        	IF (USE_MSVC_FAST_FLOATINGPOINT)
        		  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fp:fast")
          ENDIF()
        
        	OPTION(USE_MSVC_STRING_POOLING "Use MSVC /GF string pooling option"	ON)
        	IF (USE_MSVC_STRING_POOLING)
        		SET(CMAKE_C_FLAGS "/GF ${CMAKE_C_FLAGS}")
        		SET(CMAKE_CXX_FLAGS "/GF ${CMAKE_CXX_FLAGS}")
        	ENDIF()
        
        	OPTION(USE_MSVC_FUNCTION_LEVEL_LINKING "Use MSVC /Gy function level linking option"	ON)
        	IF(USE_MSVC_FUNCTION_LEVEL_LINKING)
        		SET(CMAKE_C_FLAGS "/Gy ${CMAKE_C_FLAGS}")
        		SET(CMAKE_CXX_FLAGS "/Gy ${CMAKE_CXX_FLAGS}")
        		set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /OPT:REF")
        		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /OPT:REF")
        	ENDIF(USE_MSVC_FUNCTION_LEVEL_LINKING)
        
        	OPTION(USE_MSVC_EXEPTIONS "Use MSVC C++ exceptions option"	OFF)
        
        
        
        	OPTION(USE_MSVC_COMDAT_FOLDING "Use MSVC /OPT:ICF COMDAT folding option"	ON)
        
        	IF(USE_MSVC_COMDAT_FOLDING)
        		set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /OPT:ICF")
        		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /OPT:ICF")
        	ENDIF()
        
        	OPTION(USE_MSVC_DISABLE_RTTI "Use MSVC /GR- disabled RTTI flags option"	ON)
        	IF(USE_MSVC_DISABLE_RTTI)
        	  STRING(REGEX REPLACE "/GR" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS}) # Disable RTTI
        		SET(CMAKE_C_FLAGS "/GR- ${CMAKE_C_FLAGS}")
        		SET(CMAKE_CXX_FLAGS "/GR- ${CMAKE_CXX_FLAGS}")
        	ENDIF(USE_MSVC_DISABLE_RTTI)
        
        	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4267")
        ENDIF(MSVC)
        
        
        
        IF (WIN32)
        OPTION(INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES "Create MSVC projectfiles that can be distributed" OFF)
        
        IF (INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
        	SET (LIBRARY_OUTPUT_PATH ${BULLET_PHYSICS_SOURCE_DIR}/lib CACHE PATH "Single output directory for building all libraries.")
        	SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${BULLET_PHYSICS_SOURCE_DIR})
        	SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${BULLET_PHYSICS_SOURCE_DIR})
        	SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${BULLET_PHYSICS_SOURCE_DIR})
        	SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${BULLET_PHYSICS_SOURCE_DIR})
        	SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${BULLET_PHYSICS_SOURCE_DIR})
        ELSE()
        	SET (LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib CACHE PATH "Single output directory for building all libraries.")
        ENDIF()
        
        
        
        OPTION(INTERNAL_CREATE_MSVC_RELATIVE_PATH_PROJECTFILES "Create MSVC projectfiles with relative paths" OFF)
        OPTION(INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES "Add MSVC postfix for executable names (_Debug)" OFF)
        
        SET(CMAKE_DEBUG_POSTFIX "_Debug" CACHE STRING "Adds a postfix for debug-built libraries.")
        SET(CMAKE_MINSIZEREL_POSTFIX "_MinsizeRel" CACHE STRING "Adds a postfix for MinsizeRelease-built libraries.")
        SET(CMAKE_RELWITHDEBINFO_POSTFIX "_RelWithDebugInfo" CACHE STRING "Adds a postfix for ReleaseWithDebug-built libraries.")
        
        
        
        
        
        IF (INTERNAL_CREATE_MSVC_RELATIVE_PATH_PROJECTFILES)
        SET(CMAKE_SUPPRESS_REGENERATION  1)
        SET(CMAKE_USE_RELATIVE_PATHS 1)
        ENDIF(INTERNAL_CREATE_MSVC_RELATIVE_PATH_PROJECTFILES)
        
        ENDIF (WIN32)
        
        
        OPTION(BUILD_CPU_DEMOS "Build original Bullet CPU examples" ON)
        
        
        
        OPTION(INTERNAL_UPDATE_SERIALIZATION_STRUCTURES "Internal update serialization structures" OFF)
        IF (INTERNAL_UPDATE_SERIALIZATION_STRUCTURES)
        ADD_DEFINITIONS( -DBT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES)
        ENDIF (INTERNAL_UPDATE_SERIALIZATION_STRUCTURES)
        
        IF (USE_DOUBLE_PRECISION)
        ADD_DEFINITIONS( -DBT_USE_DOUBLE_PRECISION)
        SET( BULLET_DOUBLE_DEF "-DBT_USE_DOUBLE_PRECISION")
        ENDIF (USE_DOUBLE_PRECISION)
        
        IF (USE_SOFT_BODY_MULTI_BODY_DYNAMICS_WORLD)
        ADD_DEFINITIONS(-DUSE_SOFT_BODY_MULTI_BODY_DYNAMICS_WORLD)
        ENDIF (USE_SOFT_BODY_MULTI_BODY_DYNAMICS_WORLD)
        
        IF(USE_GRAPHICAL_BENCHMARK)
        ADD_DEFINITIONS( -DUSE_GRAPHICAL_BENCHMARK)
        ENDIF (USE_GRAPHICAL_BENCHMARK)
        
        IF(BULLET2_USE_THREAD_LOCKS)
        	ADD_DEFINITIONS( -DBT_THREADSAFE=1 )
        	IF (NOT MSVC)
        		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
        	ENDIF (NOT MSVC)
        ENDIF (BULLET2_USE_THREAD_LOCKS)
        
        IF (BULLET2_USE_OPEN_MP_MULTITHREADING)
            ADD_DEFINITIONS("-DBT_USE_OPENMP=1")
            IF (MSVC)
                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /openmp")
            ELSE (MSVC)
                # GCC, Clang
                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
            ENDIF (MSVC)
        ENDIF (BULLET2_USE_OPEN_MP_MULTITHREADING)
        
        IF (BULLET2_USE_TBB_MULTITHREADING)
            SET (BULLET2_TBB_INCLUDE_DIR "not found" CACHE PATH "Directory for Intel TBB includes.")
            SET (BULLET2_TBB_LIB_DIR "not found" CACHE PATH "Directory for Intel TBB libraries.")
            find_library(TBB_LIBRARY tbb PATHS ${BULLET2_TBB_LIB_DIR})
            find_library(TBBMALLOC_LIBRARY tbbmalloc PATHS ${BULLET2_TBB_LIB_DIR})
            ADD_DEFINITIONS("-DBT_USE_TBB=1")
            INCLUDE_DIRECTORIES( ${BULLET2_TBB_INCLUDE_DIR} )
            LINK_LIBRARIES( ${TBB_LIBRARY} ${TBBMALLOC_LIBRARY} )
        ENDIF (BULLET2_USE_TBB_MULTITHREADING)
        
        IF (BULLET2_USE_PPL_MULTITHREADING)
            ADD_DEFINITIONS("-DBT_USE_PPL=1")
        ENDIF (BULLET2_USE_PPL_MULTITHREADING)
        
        IF (WIN32)
        OPTION(USE_GLUT "Use Glut"	ON)
        ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
        ADD_DEFINITIONS( -D_CRT_SECURE_NO_DEPRECATE )
        ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
        
        IF (USE_GLUT AND MSVC)
        	string (REPLACE "/D_WINDOWS" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
        	remove_definitions(-D_WINDOWS )
        ENDIF()
        
        
        
        ELSE(WIN32)
        OPTION(USE_GLUT "Use Glut"	ON)
        ENDIF(WIN32)
        
        
        IF(COMMAND cmake_policy)
           cmake_policy(SET CMP0003 NEW)
        ENDIF(COMMAND cmake_policy)
        
        
        # This is the shortcut to finding GLU, GLUT and OpenGL if they are properly installed on your system
        # This should be the case.
        
        FIND_PACKAGE(OpenGL)
        IF (OPENGL_FOUND)
        	MESSAGE("OPENGL FOUND")
        	MESSAGE(${OPENGL_LIBRARIES})
        ELSE (OPENGL_FOUND)
        	MESSAGE("OPENGL NOT FOUND")
        	SET(OPENGL_gl_LIBRARY opengl32)
        	SET(OPENGL_glu_LIBRARY glu32)
        ENDIF (OPENGL_FOUND)
        
        
        #FIND_PACKAGE(GLU)
        
        
        IF (APPLE)
          FIND_LIBRARY(COCOA_LIBRARY Cocoa)
        ENDIF()
        
        OPTION(BUILD_BULLET3 "Set when you want to build Bullet 3" ON)
        
        # Optional Python configuration
        # builds pybullet automatically if all the requirements are met
        SET(PYTHON_VERSION_PYBULLET "2.7" CACHE STRING "Python version pybullet will use.")
        SET(Python_ADDITIONAL_VERSIONS 2.7 2.7.3 3 3.0 3.1 3.2 3.3 3.4 3.5 3.6)
        SET_PROPERTY(CACHE PYTHON_VERSION_PYBULLET PROPERTY STRINGS ${Python_ADDITIONAL_VERSIONS})
        SET(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/build3/cmake ${CMAKE_MODULE_PATH})
        OPTION(EXACT_PYTHON_VERSION "Require Python and match PYTHON_VERSION_PYBULLET exactly, e.g. 2.7.3" OFF)
        IF(EXACT_PYTHON_VERSION)
          set(EXACT_PYTHON_VERSION_FLAG EXACT REQUIRED)
        ENDIF(EXACT_PYTHON_VERSION)
        # first find the python interpreter
        FIND_PACKAGE(PythonInterp ${PYTHON_VERSION_PYBULLET} ${EXACT_PYTHON_VERSION_FLAG})
        # python library should exactly match that of the interpreter
        FIND_PACKAGE(PythonLibs ${PYTHON_VERSION_STRING} EXACT)
        SET(DEFAULT_BUILD_PYBULLET OFF)
        IF(PYTHONLIBS_FOUND)
        	SET(DEFAULT_BUILD_PYBULLET ON)
        ENDIF(PYTHONLIBS_FOUND)
        OPTION(BUILD_PYBULLET "Set when you want to build pybullet (Python bindings for Bullet)" ${DEFAULT_BUILD_PYBULLET})
        
        OPTION(BUILD_ENET "Set when you want to build apps with enet UDP networking support" ON)
        OPTION(BUILD_CLSOCKET "Set when you want to build apps with enet TCP networking support" ON)
        
        
        IF(BUILD_PYBULLET)
        
        	OPTION(BUILD_PYBULLET_NUMPY "Set when you want to build pybullet with NumPy support" ON)
        	OPTION(BUILD_PYBULLET_ENET "Set when you want to build pybullet with enet UDP networking support" ON)
        	OPTION(BUILD_PYBULLET_CLSOCKET "Set when you want to build pybullet with enet TCP networking support" ON)
        
        	OPTION(BUILD_PYBULLET_MAC_USE_PYTHON_FRAMEWORK "Set when you want to use the Python Framework on Mac" OFF)
        
        	IF(BUILD_PYBULLET_NUMPY)
        		#include(FindNumPy)
        		FIND_PACKAGE(NumPy)
        		if (PYTHON_NUMPY_FOUND)
        			message("NumPy found")
        			add_definitions(-DPYBULLET_USE_NUMPY)
        		else()
        			message("NumPy not found")
        		endif()
        	ENDIF()
        
        	IF(WIN32)
        		SET(BUILD_SHARED_LIBS OFF CACHE BOOL "Shared Libs" FORCE)
        	ELSE(WIN32)
        		SET(BUILD_SHARED_LIBS ON CACHE BOOL "Shared Libs" FORCE)
        	ENDIF(WIN32)
        
        	IF(APPLE)
        		OPTION(BUILD_PYBULLET_MAC_USE_PYTHON_FRAMEWORK "Set when you want to use the Python Framework on Mac" ON)
        		IF(NOT BUILD_PYBULLET_MAC_USE_PYTHON_FRAMEWORK)
        			add_definitions(-DB3_NO_PYTHON_FRAMEWORK)
        		ENDIF(NOT BUILD_PYBULLET_MAC_USE_PYTHON_FRAMEWORK)
        		OPTION(BUILD_PYBULLET_SHOW_PY_VERSION "Set when you want to show the PY_MAJOR_VERSION and PY_MAJOR_VERSION using #pragme message." OFF)
        		IF(BUILD_PYBULLET_SHOW_PY_VERSION)
        			add_definitions(-DB3_DUMP_PYTHON_VERSION)
        		ENDIF()
        
        	ENDIF(APPLE)
        
        ENDIF(BUILD_PYBULLET)
        
        IF(BUILD_BULLET3)
        	 IF(APPLE)
        		MESSAGE("Mac OSX Version is ${_CURRENT_OSX_VERSION}")
        		IF(_CURRENT_OSX_VERSION  VERSION_LESS 10.9)
        			MESSAGE("Mac OSX below 10.9 has no OpenGL 3 support so please disable the BUILD_OPENGL3_DEMOS option")
        			#unset(BUILD_OPENGL3_DEMOS CACHE)
        
        			OPTION(BUILD_OPENGL3_DEMOS "Set when you want to build the OpenGL3+ demos" OFF)
        		ELSE()
        			OPTION(BUILD_OPENGL3_DEMOS "Set when you want to build the OpenGL3+ demos" ON)
        		ENDIF()
        	ELSE()
        		OPTION(BUILD_OPENGL3_DEMOS "Set when you want to build Bullet 3 OpenGL3+ demos" ON)
        	ENDIF()
        ELSE(BUILD_BULLET3)
        	unset(BUILD_OPENGL3_DEMOS CACHE)
        	OPTION(BUILD_OPENGL3_DEMOS "Set when you want to build Bullet 3 OpenGL3+ demos" OFF)
        ENDIF(BUILD_BULLET3)
        IF(BUILD_OPENGL3_DEMOS)
        	IF(EXISTS ${BULLET_PHYSICS_SOURCE_DIR}/Demos3 AND IS_DIRECTORY ${BULLET_PHYSICS_SOURCE_DIR}/Demos3)
        		SUBDIRS(Demos3)
        	ENDIF()
        ELSE()
        	ADD_DEFINITIONS(-DNO_OPENGL3)
        ENDIF(BUILD_OPENGL3_DEMOS)
        
        OPTION(BUILD_BULLET2_DEMOS "Set when you want to build the Bullet 2 demos" ON)
        IF(BUILD_BULLET2_DEMOS)
        
        	IF(EXISTS ${BULLET_PHYSICS_SOURCE_DIR}/examples AND IS_DIRECTORY ${BULLET_PHYSICS_SOURCE_DIR}/examples)
        		SUBDIRS(examples)
        	ENDIF()
        
        ENDIF(BUILD_BULLET2_DEMOS)
        
        
        
        OPTION(BUILD_EXTRAS "Set when you want to build the extras" ON)
        IF(BUILD_EXTRAS)
          SUBDIRS(Extras)
        ENDIF(BUILD_EXTRAS)
        
        
        #Maya Dynamica plugin is moved to http://dynamica.googlecode.com
        
        SUBDIRS(src)
        
        IF("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles")
        	OPTION(INSTALL_LIBS "Set when you want to install libraries" ON)
        ELSE()
        	IF(APPLE AND FRAMEWORK)
        		OPTION(INSTALL_LIBS "Set when you want to install libraries" ON)
        	ELSE()
        #by default, don't enable the 'INSTALL' option for Xcode and MSVC projectfiles
        		OPTION(INSTALL_LIBS "Set when you want to install libraries" OFF)
        	ENDIF()
        ENDIF()
        
        IF(INSTALL_LIBS)
        	SET (LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)" )
        	SET (LIB_DESTINATION "lib${LIB_SUFFIX}" CACHE STRING "Library directory name")
        	## the following are directories where stuff will be installed to
        	SET(INCLUDE_INSTALL_DIR "include/bullet/" CACHE PATH "The subdirectory to the header prefix")
        	SET(PKGCONFIG_INSTALL_PREFIX "lib${LIB_SUFFIX}/pkgconfig/" CACHE STRING "Base directory for pkgconfig files")
        	IF(NOT MSVC)
        	  CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/bullet.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/bullet.pc @ONLY)
          	INSTALL(
        		FILES
        		${CMAKE_CURRENT_BINARY_DIR}/bullet.pc
        		DESTINATION
        		${PKGCONFIG_INSTALL_PREFIX})
        	ENDIF(NOT MSVC)
        ENDIF(INSTALL_LIBS)
        
        #INSTALL of other files requires CMake 2.6
        IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
        	OPTION(INSTALL_EXTRA_LIBS "Set when you want extra libraries installed" OFF)
        ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
        
        OPTION(BUILD_UNIT_TESTS "Build Unit Tests"	ON)
        
        IF (BUILD_UNIT_TESTS)
        	ENABLE_TESTING()
        	SUBDIRS(test)
        ENDIF()
        
        set (BULLET_CONFIG_CMAKE_PATH lib${LIB_SUFFIX}/cmake/bullet )
        list (APPEND BULLET_LIBRARIES LinearMath)
        IF(BUILD_BULLET3)
            list (APPEND BULLET_LIBRARIES BulletInverseDynamics)
        ENDIF(BUILD_BULLET3)
        list (APPEND BULLET_LIBRARIES BulletCollision)
        list (APPEND BULLET_LIBRARIES BulletDynamics)
        list (APPEND BULLET_LIBRARIES BulletSoftBody)
        set (BULLET_USE_FILE ${BULLET_CONFIG_CMAKE_PATH}/UseBullet.cmake)
        configure_file 	( ${CMAKE_CURRENT_SOURCE_DIR}/BulletConfig.cmake.in
        					${CMAKE_CURRENT_BINARY_DIR}/BulletConfig.cmake
        					@ONLY ESCAPE_QUOTES
        				)
        install ( FILES ${CMAKE_CURRENT_SOURCE_DIR}/UseBullet.cmake
        		${CMAKE_CURRENT_BINARY_DIR}/BulletConfig.cmake
        		DESTINATION ${BULLET_CONFIG_CMAKE_PATH}
        	)

        Comment

        Working...
        X