cmake_minimum_required(VERSION 2.4)

if( COMMAND cmake_policy)
  IF( POLICY CMP0003 )
    cmake_policy( SET CMP0003 OLD)
  ENDIF( POLICY CMP0003 )
endif( COMMAND cmake_policy)

PROJECT(H3DPhysics)

# set the install directory on Windows
IF( WIN32 AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND NOT H3D_CMAKE_INSTALL_PREFIX_ALREADY_SET )
  SET( CMAKE_INSTALL_PREFIX ${H3DPhysics_SOURCE_DIR}/.. CACHE PATH "Install path prefix, prepended onto install directories." FORCE )
  SET( H3D_CMAKE_INSTALL_PREFIX_ALREADY_SET TRUE )
ENDIF( WIN32 AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND NOT H3D_CMAKE_INSTALL_PREFIX_ALREADY_SET )

# Add a cache variable GENERATE_CPACK_PROJECT to have the choice of generating a project
# for packaging H3DPhysics. Default is NO since most people will not use this.
IF( NOT DEFINED GENERATE_CPACK_PROJECT )
SET( GENERATE_CPACK_PROJECT "NO" CACHE BOOL "Decides if a cpack project should be generated. The project in the first loaded CMakeLists will configure CPack." )
MARK_AS_ADVANCED(GENERATE_CPACK_PROJECT)
ENDIF( NOT DEFINED GENERATE_CPACK_PROJECT )

# Add a cache variable GENERATE_NODEROUTESTODOTFILE_BUILD that should be
# set to yes if NodeRoutesToDotFile project should be run against this
# build of H3DAPI.
IF( NOT DEFINED GENERATE_NODEROUTESTODOTFILE_BUILD )
  SET( GENERATE_NODEROUTESTODOTFILE_BUILD "NO" CACHE BOOL "Breaks H3DAPI for normal use but this flag must be set to yes when using the NodeRoutesToDotFile project, located in ${H3DAPI_SOURCE_DIR}/../Util/NodeRoutesToDotFile." )
  MARK_AS_ADVANCED(GENERATE_NODEROUTESTODOTFILE_BUILD)
ENDIF( NOT DEFINED GENERATE_NODEROUTESTODOTFILE_BUILD )

INCLUDE( "${H3DPhysics_SOURCE_DIR}/H3DPhysicsSourceFiles.txt" )
# Add the H3DPhysics.rc resource file if Visual Studio
IF(MSVC)
  SET( H3DPhysics_SRCS ${H3DPhysics_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/H3DPhysics.rc )
ENDIF(MSVC)

SET(optionalLibs)

# Add the directory to INCLUDE_DIRECTORIES before any other statement to make sure that this header file is found first.
# This assumes that we always use "#include <path/include_header.h>" in our code even if the file is actually found in
# the same directory as the file that contains the include statement.
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR}/include )
SET( H3DPHYSICS_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include ${H3DPhysics_SOURCE_DIR}/../include CACHE INTERNAL "Set to internal to propagate change" )

INCLUDE_DIRECTORIES( ../include )

SET(requiredLibs)

IF( WIN32 AND MSVC )
  SET(requiredLibs ${requiredLibs} DelayImp.lib )
ENDIF( WIN32 AND MSVC )

# Version of H3DPhysics
SET( H3DPHYSICS_MAJOR_VERSION 1 )
SET( H3DPHYSICS_MINOR_VERSION 3 )
SET( H3DPHYSICS_BUILD_VERSION 0 )

SET(CMAKE_MODULE_PATH  ${H3DPhysics_SOURCE_DIR}/modules $ENV{H3D_ROOT}/build/modules ${H3DPhysics_SOURCE_DIR}/../../H3DAPI/build/modules/)

IF( H3D_USE_DEPENDENCIES_ONLY )
  # The variables set here must be set by the CMakeLists.txt that sets H3D_USE_DEPENDENCIES_ONLY to true.
  INCLUDE_DIRECTORIES( ${EXTERNAL_INCLUDE_DIR} ) 
  INCLUDE_DIRECTORIES( ${H3DUTIL_INCLUDE_DIR} ) 
  INCLUDE_DIRECTORIES( ${HAPI_INCLUDE_DIR} ) 
  INCLUDE_DIRECTORIES( ${H3DAPI_INCLUDE_DIR} ) 
  INCLUDE_DIRECTORIES( ${H3DPHYSICS_INCLUDE_DIR} ) 
  
  SET( requiredLibs ${requiredLibs} H3DUtil HAPI H3DAPI)
ELSE( H3D_USE_DEPENDENCIES_ONLY )
  #H3DUtil
  FIND_PACKAGE(H3DUtil REQUIRED)

  IF(H3DUTIL_FOUND)
    INCLUDE_DIRECTORIES( ${H3DUTIL_INCLUDE_DIR} ) 
    SET(requiredLibs ${requiredLibs} ${H3DUTIL_LIBRARIES} )
  ENDIF(H3DUTIL_FOUND)

  #HAPI
  FIND_PACKAGE(HAPI REQUIRED)

  IF(HAPI_FOUND)
    INCLUDE_DIRECTORIES( ${HAPI_INCLUDE_DIR} ) 
    SET(requiredLibs ${requiredLibs} ${HAPI_LIBRARIES} )
  ENDIF(HAPI_FOUND)

  #H3DAPI
  FIND_PACKAGE(H3DAPI REQUIRED)

  IF(H3DAPI_FOUND)
    INCLUDE_DIRECTORIES( ${H3DAPI_INCLUDE_DIR} ) 
    SET(requiredLibs ${requiredLibs} ${H3DAPI_LIBRARIES} )
  ENDIF(H3DAPI_FOUND)
ENDIF( H3D_USE_DEPENDENCIES_ONLY )

# Optional extra library. Without this H3D API can not load scenes defined with X3D syntax.
FIND_PACKAGE(Xerces)
IF(XERCES_FOUND)
  SET(HAVE_XERCES 1)
  INCLUDE_DIRECTORIES( ${XERCES_INCLUDE_DIR} ) 
  SET(optionalLibs ${optionalLibs} ${XERCES_LIBRARIES} )
ENDIF(XERCES_FOUND)

#SOFA
FIND_PACKAGE( SOFA COMPONENTS   core 
                                helper
                                simulation 
                                tree 
                                base_visual
                                defaulttype
                                gui
                                guimain
                                guiglut
                                guiqt
                                component 
                                component_base
                                component_common
                                component_general
                                component_misc
                                component_advanced
                                haptics
                                validation
                                exporter
                                engine
                                graph_component
                                topology_mapping
                                boundary_condition
                                user_interaction
                                constraint
                                dense_solver
                                sparse_solver
                                preconditioner
                                opengl_visual
                                base_collision
                                loader
                                mesh_collision
                                base_topology
                                deformable
                                simple_fem
                                explicit_ode_solver
                                implicit_ode_solver
                                base_linear_solver
                                base_mechanics
                                rigid
                                sph_fluid
                                object_interaction )

#FIND_PACKAGE( Boost )
IF(SOFA_FOUND)
  SET( HAVE_SOFA 1 )
  INCLUDE_DIRECTORIES( ${SOFA_INCLUDE_DIR} ) 
#  INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIRS} ) 
  SET(optionalLibs ${optionalLibs} ${SOFA_LIBRARIES} )

  # only needed for some debugging, disabled for now
  # # Pull in external SOFA API source to compile with our project
  # file(TO_CMAKE_PATH "${SOFA_INSTALL_DIR}/applications/projects/SofaPhysicsAPI" SOFA_API_DIR)
  
  # INCLUDE_DIRECTORIES( ${SOFA_API_DIR} ) 
  # SET( H3DPhysics_SRCS ${H3DPhysics_SRCS}
                             # "${SOFA_API_DIR}/SofaPhysicsDataController.cpp"
                             # "${SOFA_API_DIR}/SofaPhysicsDataMonitor.cpp"
                             # "${SOFA_API_DIR}/SofaPhysicsOutputMesh.cpp"
                             # "${SOFA_API_DIR}/SofaPhysicsSimulation.cpp"
                             # "${SOFA_API_DIR}/fakegui.cpp" )
  # # Group all Sagentia code in IDE
  # SOURCE_GROUP("SofaAPI" "${SOFA_API_DIR}")
  
ENDIF(SOFA_FOUND)


#ODE
FIND_PACKAGE(ODE)
IF(ODE_FOUND)
  SET( HAVE_ODE 1 )
  INCLUDE_DIRECTORIES( ${ODE_INCLUDE_DIR} ) 
  SET(optionalLibs ${optionalLibs} ${ODE_LIBRARIES} )
  ADD_DEFINITIONS( ${ODE_FLAGS} )

ENDIF(ODE_FOUND)

#PHYSX
FIND_PACKAGE(PhysX)
IF(PHYSX_FOUND)
  SET( HAVE_PHYSX 1 )
  INCLUDE_DIRECTORIES( ${PHYSX_INCLUDE_DIR} ) 
  SET(optionalLibs ${optionalLibs} ${PHYSX_LIBRARIES} )
ENDIF(PHYSX_FOUND)

#PHYSX3
FIND_PACKAGE(PhysX3)
IF(PHYSX3_FOUND)
  SET( HAVE_PHYSX3 1 )
  INCLUDE_DIRECTORIES( ${PHYSX3_INCLUDE_DIR} ) 
  SET(optionalLibs ${optionalLibs} ${PHYSX3_LIBRARIES} )
ENDIF(PHYSX3_FOUND)

#HACD
FIND_PACKAGE(HACD)
IF(HACD_FOUND)
  SET( HAVE_HACD 1 )
  INCLUDE_DIRECTORIES( ${HACD_INCLUDE_DIR} ) 
  SET(optionalLibs ${optionalLibs} ${HACD_LIBRARIES} )
ENDIF(HACD_FOUND)

#Bullet
FIND_PACKAGE(Bullet)
IF(BULLET_FOUND)
  SET( HAVE_BULLET 1 )
  INCLUDE_DIRECTORIES( ${BULLET_INCLUDE_DIR} ) 
  SET(optionalLibs ${optionalLibs} ${BULLET_LIBRARIES} )
ENDIF(BULLET_FOUND)

# Optional extra library. Add python bindings to H3D API, allow for extended prototyping without using C++.
FIND_PACKAGE(PythonLibs)
IF( PYTHON_INCLUDE_PATH AND PYTHON_LIBRARIES)
  SET(PYTHON_FOUND 1)
ELSE(PYTHON_INCLUDE_PATH AND PYTHON_LIBRARIES)
  SET(PYTHON_FOUND 0)
ENDIF(PYTHON_INCLUDE_PATH AND PYTHON_LIBRARIES)

# Report the results.
IF(NOT PYTHON_FOUND)
  SET(PYTHON_DIR_MESSAGE
    "PYTHON was not found. Make sure PYTHON_LIBRARY and PYTHON_INCLUDE_PATH are set.")
  IF(NOT PYTHON_FIND_QUIETLY)
    MESSAGE(STATUS "${PYTHON_DIR_MESSAGE}")
  ELSE(NOT PYTHON_FIND_QUIETLY)
    IF(PYTHON_FIND_REQUIRED) 
      MESSAGE(FATAL_ERROR "${PYTHON_DIR_MESSAGE}")
    ENDIF(PYTHON_FIND_REQUIRED)
  ENDIF(NOT PYTHON_FIND_QUIETLY)
ENDIF(NOT PYTHON_FOUND)

IF(PYTHON_FOUND)
  SET(HAVE_PYTHON 1)
  INCLUDE_DIRECTORIES( ${PYTHON_INCLUDE_PATH} ) 
IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  # pyconfig.h is put in different directory from Ubuntu 13.04 (raring) 
  # and CMake FindPythonLibs module is not updated for this yet. 
  # Adding it explicitly here in the mean time.
  INCLUDE_DIRECTORIES( /usr/include/${CMAKE_LIBRARY_ARCHITECTURE}/python2.7 ) 
ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  SET(optionalLibs ${optionalLibs} ${PYTHON_LIBRARIES} )
ENDIF(PYTHON_FOUND)

# autogenerate H3DPhysics.h depending on the libraries available.
IF( EXISTS ${H3DPhysics_SOURCE_DIR}/../include/H3D/H3DPhysics/H3DPhysics.h )
  FILE( REMOVE ${H3DPhysics_SOURCE_DIR}/../include/H3D/H3DPhysics/H3DPhysics.h )
ENDIF( EXISTS ${H3DPhysics_SOURCE_DIR}/../include/H3D/H3DPhysics/H3DPhysics.h )
CONFIGURE_FILE( ${H3DPhysics_SOURCE_DIR}/../include/H3D/H3DPhysics/H3DPhysics.cmake ${CMAKE_CURRENT_BINARY_DIR}/include/H3D/H3DPhysics/H3DPhysics.h )

IF( NOT GENERATE_CPACK_PROJECT )
  # Install header files on non-windows system (e.g. Unix).
  INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/include/H3D/H3DPhysics/H3DPhysics.h
           DESTINATION ${H3DPhysics_SOURCE_DIR}/../include/H3D/H3DPhysics )
ENDIF( NOT GENERATE_CPACK_PROJECT )

ADD_LIBRARY(H3DPhysics SHARED ${H3DPhysics_SRCS}
                                    ${H3DPhysics_HEADERS} )

# make sure that the H3DPhysics.rc contains the correct svn-version
IF( MSVC )
  SET( H3DPHYSICS_SVN_VERSION "0" )
  # Find SubWCRev.exe
  FIND_FILE( SubWCRev
             NAMES "SubWCRev.exe"
             DOC   "Set to SubWCRev.exe that comes with TortoiseSVN. Used to find svn revision number." )
  MARK_AS_ADVANCED( SubWCRev )

  SET( H3DPhysics_is_working_copy 10 )
  IF( SubWCRev )
		EXECUTE_PROCESS( COMMAND ${SubWCRev} ${H3DPhysics_SOURCE_DIR}/../
										 RESULT_VARIABLE H3DPhysics_is_working_copy )
		IF( ${H3DPhysics_is_working_copy} EQUAL 0 )
		  SET( H3DPHYSICS_SVN_VERSION "$WCREV$" )
		ENDIF( ${H3DPhysics_is_working_copy} EQUAL 0 )
  ENDIF( SubWCRev )

  # autogenerate H3DPhysics.rc depending on the version
  CONFIGURE_FILE( H3DPhysics.rc.cmake ${CMAKE_CURRENT_BINARY_DIR}/H3DPhysics.rc )
  
  ADD_CUSTOM_COMMAND( TARGET H3DPhysics
											PRE_BUILD
											COMMAND ${H3DPhysics_SOURCE_DIR}/UpdateResourceFile 
											ARGS H3DPHYSICS ${CMAKE_CURRENT_BINARY_DIR}/H3DPhysics.rc ${H3DPhysics_SOURCE_DIR}/H3DPhysics.rc.cmake
											${H3DPHYSICS_MAJOR_VERSION} ${H3DPHYSICS_MINOR_VERSION}
											${H3DPHYSICS_BUILD_VERSION} "${H3DPHYSICS_SVN_VERSION}"
											"H3DPHYSICS_Output_Name"
											"$(TargetFileName)" )

  IF( SubWCRev AND ${H3DPhysics_is_working_copy} EQUAL 0 )
    # Update SVN revision in file.
    EXECUTE_PROCESS( COMMAND ${SubWCRev} ${H3DPhysics_SOURCE_DIR}/../ ${CMAKE_CURRENT_BINARY_DIR}/H3DPhysics.rc ${CMAKE_CURRENT_BINARY_DIR}/H3DPhysics.rc )

    ADD_CUSTOM_COMMAND( TARGET H3DPhysics 
                        PRE_BUILD 
                        COMMAND ${SubWCRev} 
                        ARGS ${H3DPhysics_SOURCE_DIR}/../ ${CMAKE_CURRENT_BINARY_DIR}/H3DPhysics.rc ${CMAKE_CURRENT_BINARY_DIR}/H3DPhysics.rc )
  ENDIF( SubWCRev AND ${H3DPhysics_is_working_copy} EQUAL 0 )
ENDIF(MSVC)

TARGET_LINK_LIBRARIES( H3DPhysics ${requiredLibs} ${optionalLibs} )

foreach( H3DUTIL_INCLUDE_DIR_TMP ${H3DUTIL_INCLUDE_DIR} )
  IF( EXISTS ${H3DUTIL_INCLUDE_DIR_TMP}/H3DUtil/H3DUtil.h )
    FILE( STRINGS ${H3DUTIL_INCLUDE_DIR_TMP}/H3DUtil/H3DUtil.h list_of_defines REGEX "#define THREAD_LOCK_DEBUG"  )
    LIST( LENGTH list_of_defines list_of_defines_length )
    IF( list_of_defines_length )
      if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
        execute_process( COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
        if (GCC_VERSION VERSION_GREATER 4.7 OR GCC_VERSION VERSION_EQUAL 4.7)
          add_definitions("-std=gnu++11")
        elseif(GCC_VERSION VERSION_GREATER 4.3 OR GCC_VERSION VERSION_EQUAL 4.3)
          add_definitions("-std=gnu++0x")
        else ()
          message(FATAL_ERROR "Enabling ENABLE_THREAD_LOCK_DEBUG requires C++11 support. This compiler lacks such support.")
        endif ()
      elseif (${MSVC_VERSION} LESS 1600 )
        message(FATAL_ERROR "Enabling ENABLE_THREAD_LOCK_DEBUG requires C++11 support. This compiler lacks such support.")
      endif ()
    ENDIF( list_of_defines_length )
  ENDIF( EXISTS ${H3DUTIL_INCLUDE_DIR_TMP}/H3DUtil/H3DUtil.h )
endforeach( H3DUTIL_INCLUDE_DIR_TMP )

# make sure symbols are exported.
ADD_DEFINITIONS( -DH3DPHYSICS_EXPORTS )

SET( H3DPHYSICS_FULL_VERSION ${H3DPHYSICS_MAJOR_VERSION}.${H3DPHYSICS_MINOR_VERSION}.${H3DPHYSICS_BUILD_VERSION} )
SET_TARGET_PROPERTIES( H3DPhysics PROPERTIES VERSION ${H3DPHYSICS_FULL_VERSION} )

# Debug version should have _d postfix.
SET_TARGET_PROPERTIES( H3DPhysics PROPERTIES DEBUG_POSTFIX "_d" )

SET( H3DPhysics_COMPILE_FLAGS "" )

IF(SOFA_FOUND)
  SET( H3DPhysics_COMPILE_FLAGS "${H3DPhysics_COMPILE_FLAGS} -DSOFA_HAVE_GLEW -DTIXML_USE_STL" )
ENDIF(SOFA_FOUND)


IF(UNIX) 
  SET_TARGET_PROPERTIES( H3DPhysics PROPERTIES OUTPUT_NAME h3dphysics )
ENDIF(UNIX)		 

SET( DEFAULT_BIN_INSTALL "bin" )
SET( DEFAULT_LIB_INSTALL "lib" )

IF( WIN32 )
  SET( DEFAULT_BIN_INSTALL "bin32" )
  SET( DEFAULT_LIB_INSTALL "lib32" )
  IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
    SET( DEFAULT_BIN_INSTALL "bin64" )
    SET( DEFAULT_LIB_INSTALL "lib64" )
  ENDIF( CMAKE_SIZEOF_VOID_P EQUAL 8 )

  SET( H3DPhysics_LINK_FLAGS "" )

  IF( MSVC )
    SET( H3D_MSVC_VERSION 6 )
    SET( TEMP_MSVC_VERSION 1299 )
    WHILE( ${MSVC_VERSION} GREATER ${TEMP_MSVC_VERSION} )
      MATH( EXPR H3D_MSVC_VERSION "${H3D_MSVC_VERSION} + 1" )
      MATH( EXPR TEMP_MSVC_VERSION "${TEMP_MSVC_VERSION} + 100" )
    ENDWHILE( ${MSVC_VERSION} GREATER ${TEMP_MSVC_VERSION} )

    # change the name depending on compiler to be able to tell them apart
    # since they are not compatible with each other. 
    SET_TARGET_PROPERTIES( H3DPhysics PROPERTIES OUTPUT_NAME ${PROJECT_NAME}_vc${H3D_MSVC_VERSION} )

    # Treat wchar_t as built in type for all visual studio versions.
    # This is default for every version above 7 ( so far ) but we still set it for all.
    SET( H3DPhysics_COMPILE_FLAGS "${H3DPhysics_COMPILE_FLAGS} /Zc:wchar_t")
  ENDIF( MSVC )

  IF( MSVC80 )
    # This might be useful for visual studio 2005 users that often recompile the api.
    IF( NOT DEFINED USE_VC8_MP_FLAG )
      SET( USE_VC8_MP_FLAG "NO" CACHE BOOL "In visual studio 8 the MP flag exists but is not documented. Maybe it is unsafe to use. If you want to use it then set this flag to yes." )
    ENDIF( NOT DEFINED USE_VC8_MP_FLAG )

    IF( USE_VC8_MP_FLAG )
      SET( H3DPhysics_COMPILE_FLAGS "${H3DPhysics_COMPILE_FLAGS} /MP" )
    ENDIF( USE_VC8_MP_FLAG )
  ENDIF( MSVC80 )

  IF( MSVC )
    IF( ${MSVC_VERSION} GREATER 1399 )
      # Remove compiler warnings about deprecation for visual studio versions 8 and above.
      SET( H3DPhysics_COMPILE_FLAGS "${H3DPhysics_COMPILE_FLAGS} -D_CRT_SECURE_NO_DEPRECATE" )
    ENDIF( ${MSVC_VERSION} GREATER 1399 )

    IF( ${MSVC_VERSION} GREATER 1499 )
      # Build using several threads for visual studio versions 9 and above.
      SET( H3DPhysics_COMPILE_FLAGS "${H3DPhysics_COMPILE_FLAGS} /MP" )
    ENDIF( ${MSVC_VERSION} GREATER 1499 )
  ENDIF( MSVC )

  # Delayload ode.
  IF(ODE_FOUND AND MSVC)
    SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"ode_double.dll\" /DELAYLOAD:\"ode_single.dll\"")
  ENDIF(ODE_FOUND AND MSVC)

  # Delayload physx.
  IF(PHYSX_FOUND AND MSVC)
    SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysXLoader.dll\" /DELAYLOAD:\"PhysXLoader64.dll\"")
  ENDIF(PHYSX_FOUND AND MSVC)
  
  # Delayload physx3.
  IF(PHYSX3_FOUND AND MSVC)
    IF ( CMAKE_CL_64 )
      SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysX3_x64.dll\"" )
      SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysX3Common_x64.dll\"" )
      SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysX3Cooking_x64.dll\"" )
      SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysX3Extensions.dll\"" )
    ELSE( CMAKE_CL_64 )
      SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysX3_x86.dll\"" )
      SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysX3Common_x86.dll\"" )
      SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysX3Cooking_x86.dll\"" )
      SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"PhysX3Extensions.dll\"" )
    ENDIF( CMAKE_CL_64 )
  ENDIF(PHYSX3_FOUND AND MSVC)
  
  # Delayload bullet.
  IF(BULLET_FOUND AND MSVC)
    SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"libbulletcollision.dll\" /DELAYLOAD:\"libbulletdynamics.dll\" /DELAYLOAD:\"libbulletmath.dll\"")
  ENDIF(BULLET_FOUND AND MSVC)

	# Delayload sofa. Does not work, therefore disabled at the moment. Would be nice to get this to work.
  #IF(SOFA_FOUND)
	#	foreach( sofa_delayload_name ${SOFA_LIBRARY_NAMES} )
  #    SET( H3DPhysics_LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /DELAYLOAD:\"sofa_${sofa_delayload_name}.dll\" /DELAYLOAD:\"sofa${sofa_delayload_name}.dll\"")
	#	endforeach( sofa_delayload_name ${SOFA_LIBRARY_NAMES} )
  #ENDIF(SOFA_FOUND)

  # set link flags for H3DPhysics project
  # Seems like H3DPhysics needs to have incremental linking shut off for vc8. Since this is
  # not the most important feature it is shut off for all visual studio versions.
  IF( MSVC )
    SET_TARGET_PROPERTIES( H3DPhysics PROPERTIES LINK_FLAGS "${H3DPhysics_LINK_FLAGS} /INCREMENTAL:NO" )
  ENDIF( MSVC )
ENDIF( WIN32 )

IF( GENERATE_NODEROUTESTODOTFILE_BUILD )
  SET( H3DPhysics_COMPILE_FLAGS "${H3DPhysics_COMPILE_FLAGS} -DH3D_GENERATE_DOTROUTE_FILES" )
ENDIF( GENERATE_NODEROUTESTODOTFILE_BUILD )

# set compile flags for H3DPhysics project
SET_TARGET_PROPERTIES( H3DPhysics PROPERTIES COMPILE_FLAGS "${H3DPhysics_COMPILE_FLAGS}" )

IF( UNIX )
  # Install header files on non-windows system (e.g. Unix).
  INSTALL( FILES ${H3DPhysics_HEADERS}
           DESTINATION include/H3D/H3DPhysics )

ENDIF( UNIX )

# Intall directories.
INSTALL( TARGETS H3DPhysics
         LIBRARY DESTINATION ${DEFAULT_LIB_INSTALL} COMPONENT H3DPhysics_cpack_runtime
         RUNTIME DESTINATION ${DEFAULT_BIN_INSTALL} COMPONENT H3DPhysics_cpack_runtime
         ARCHIVE DESTINATION ${DEFAULT_LIB_INSTALL} COMPONENT H3DPhysics_cpack_libraries)

IF( H3D_USE_DEPENDENCIES_ONLY )
  SET( INSTALL_RUNTIME_AND_LIBRARIES_ONLY_DEPENDENCIES ${INSTALL_RUNTIME_AND_LIBRARIES_ONLY_DEPENDENCIES} PARENT_SCOPE )
ELSE( H3D_USE_DEPENDENCIES_ONLY )
  INCLUDE( ${H3DPhysics_SOURCE_DIR}/H3DPhysicsCPack.cmake)
ENDIF( H3D_USE_DEPENDENCIES_ONLY )
