cmake_minimum_required(VERSION 2.8.3)

project(dbot)

option(DBOT_BUILD_GPU "Compile CUDA enabled trackers" ON)

add_definitions(-std=c++11 -fno-omit-frame-pointer -fPIC)

add_definitions(-DPROFILING_ON=1) #print profiling output

set(CMAKE_EXPORT_COMPILE_COMMANDS 1)

set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)

set(dbot_LIBRARY ${PROJECT_NAME})

set(dbot_LIBRARY_GPU ${dbot_LIBRARY}_gpu)

set(dbot_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/source)

set(dbot_LIBRARIES ${dbot_LIBRARY})

find_package(Eigen3 3.2 EXACT REQUIRED)

include_directories(${EIGEN3_INCLUDE_DIR})

find_package(Boost REQUIRED COMPONENTS system filesystem)

include_directories(${Boost_INCLUDE_DIRS})

set(GLEW_DIR ${CMAKE_MODULE_PATH})

find_package(CUDA QUIET)

find_package(GLEW QUIET)

find_package(OpenGL QUIET)

if(DBOT_BUILD_GPU AND CUDA_FOUND AND GLEW_FOUND AND OPENGL_FOUND)

include_directories(${GLEW_INCLUDE_DIRS})

include_directories(${OpenGL_INCLUDE_DIRS})

link_directories(${OpenGL_LIBRARY_DIRS})

link_directories(${GLEW_LIBRARY_DIRS})

add_definitions(${OpenGL_DEFINITIONS})

add_definitions(${GLEW_DEFINITIONS})

# enable cuda debug information with -g -G -O0, to use with cuda-dbg use

# --ptxas-options=-v to see number of registers, local, shared and constant

# memory used in kernels

set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -O2 -arch=sm_30)

list(APPEND dbot_LIBRARIES ${dbot_LIBRARY_GPU} ${CUDA_CUDART_LIBRARY})

# activate gpu implementations

add_definitions(-DDBOT_BUILD_GPU=1)

set(DBOT_GPU_SUPPORT "YES")

message(STATUS "Found CUDA version ${CUDA_VERSION_STRING}")

else(DBOT_BUILD_GPU AND CUDA_FOUND AND GLEW_FOUND AND OPENGL_FOUND)

set(DBOT_GPU_SUPPORT "NO")

if(DBOT_BUILD_GPU)

message(WARNING "No CUDA support. Deactivating GPU implementation")

endif(DBOT_BUILD_GPU)

set(DBOT_BUILD_GPU OFF)

endif(DBOT_BUILD_GPU AND CUDA_FOUND AND GLEW_FOUND AND OPENGL_FOUND)

find_package(catkin QUIET COMPONENTS fl)

if(DBOT_BUILD_GPU)

list(APPEND dbot_INCLUDE_DIRS ${CUDA_INCLUDE_DIRS})

list(APPEND dbot_INCLUDE_DIRS ${CUDA_CUT_INCLUDE_DIRS})

list(APPEND dbot_INCLUDE_DIRS ${GLEW_INCLUDE_DIRS})

list(APPEND dbot_INCLUDE_DIRS ${OpenGL_INCLUDE_DIR})

endif(DBOT_BUILD_GPU)

if(catkin_FOUND)

message(STATUS "Using catkin")

catkin_package(

INCLUDE_DIRS

${dbot_INCLUDE_DIRS}

LIBRARIES

${dbot_LIBRARIES}

CATKIN_DEPENDS

fl

DEPENDS

Boost

# CUDA

)

list(APPEND dbot_INCLUDE_DIRS ${catkin_INCLUDE_DIRS})

else(catkin_FOUND)

find_package(fl REQUIRED)

find_package(osr REQUIRED)

list(APPEND dbot_INCLUDE_DIRS ${fl_INCLUDE_DIRS})

list(APPEND dbot_INCLUDE_DIRS ${osr_INCLUDE_DIRS})

endif(catkin_FOUND)

include_directories(${dbot_INCLUDE_DIRS})

set(dbot_SOURCE_DIR source/${PROJECT_NAME})

set(dbot_SOURCES

${dbot_SOURCE_DIR}/camera_data.cpp

${dbot_SOURCE_DIR}/object_model.cpp

${dbot_SOURCE_DIR}/object_file_reader.cpp

${dbot_SOURCE_DIR}/rigid_body_renderer.cpp

${dbot_SOURCE_DIR}/object_resource_identifier.cpp

${dbot_SOURCE_DIR}/simple_camera_data_provider.cpp

${dbot_SOURCE_DIR}/virtual_camera_data_provider.cpp

${dbot_SOURCE_DIR}/simple_wavefront_object_loader.cpp

${dbot_SOURCE_DIR}/simple_shader_provider.cpp

${dbot_SOURCE_DIR}/default_shader_provider.cpp

${dbot_SOURCE_DIR}/file_shader_provider.cpp

${dbot_SOURCE_DIR}/tracker/tracker.cpp

${dbot_SOURCE_DIR}/tracker/particle_tracker.cpp

${dbot_SOURCE_DIR}/tracker/gaussian_tracker.cpp

${dbot_SOURCE_DIR}/builder/rb_sensor_builder.cpp

${dbot_SOURCE_DIR}/builder/particle_tracker_builder.cpp

${dbot_SOURCE_DIR}/builder/gaussian_tracker_builder.cpp

)

add_library(${dbot_LIBRARY} SHARED

${dbot_SOURCES})

target_link_libraries(${dbot_LIBRARY}

${catkin_LIBRARIES}

${Boost_LIBRARIES})

if(DBOT_BUILD_GPU)

cuda_add_library(${dbot_LIBRARY_GPU} SHARED

${dbot_SOURCE_DIR}/gpu/cuda_likelihood_evaluator.cu

${dbot_SOURCE_DIR}/gpu/shader.cpp

${dbot_SOURCE_DIR}/gpu/object_rasterizer.cpp

${dbot_SOURCE_DIR}/gpu/buffer_configuration.cpp)

target_link_libraries(${dbot_LIBRARY_GPU}

${catkin_LIBRARIES}

${OPENGL_LIBRARIES}

${GLFW_LIBRARY}

${GLEW_LIBRARIES})

# ${CUDA_CUDART_LIBRARY})

endif(DBOT_BUILD_GPU)

enable_testing()

include(${CMAKE_MODULE_PATH}/gtest.cmake)

include(utests.cmake)