Announcement

Collapse
No announcement yet.

Static Linking error for Bullet Physics Engine

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

  • replied
    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}
    	)

    Leave a comment:


  • replied
    Are you building 64 bit?

    Leave a comment:


  • replied
    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.

    Leave a comment:


  • started a topic Static Linking error for Bullet Physics Engine

    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?
Working...
X