CMakeLists.txt

   1 cmake_minimum_required(VERSION 2.8.5)
   2
   3 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
   4
   5 INCLUDE (GNUInstallDirs)
   6 INCLUDE (CheckCCompilerFlag)
   7 INCLUDE (CheckCSourceCompiles)
   8 INCLUDE (CheckCXXCompilerFlag)
   9 INCLUDE (CheckFunctionExists)
  10 INCLUDE (CheckIncludeFile)
  11 INCLUDE (FindPkgConfig)
  12
  13 # http://www.cmake.org/cmake/help/v3.0/policy/CMP0042.html
  14 if (POLICY CMP0042)
  15         cmake_policy (SET CMP0042 NEW)
  16 endif()
  17
  18 project (piglit)
  19
  20 # Require MSVC 2013 U4
  21 if (MSVC)
  22         if (${CMAKE_C_COMPILER_VERSION} VERSION_LESS 18.00.31101.0)
  23                 message (FATAL_ERROR "Visual Studio 2013 Update 4 or later required")
  24         endif ()
  25 endif ()
  26
  27 find_package(Threads)
  28 find_package(PNG)
  29 if(PNG_FOUND)
  30         add_definitions(-DPIGLIT_HAS_PNG)
  31 endif(PNG_FOUND)
  32 find_package(X11)
  33 if(X11_FOUND)
  34         set(PIGLIT_HAS_X11 True)
  35         add_definitions(-DPIGLIT_HAS_X11)
  36 endif()
  37
  38 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
  39         set(PIGLIT_BUILD_GLES_TESTS_DEFAULT ON)
  40 else()
  41         set(PIGLIT_BUILD_GLES_TESTS_DEFAULT OFF)
  42 endif()
  43
  44 option(PIGLIT_BUILD_GL_TESTS "Build tests for OpenGL" ON)
  45 option(PIGLIT_BUILD_GLES1_TESTS "Build tests for OpenGL ES1" ${PIGLIT_BUILD_GLES_TESTS_DEFAULT})
  46 option(PIGLIT_BUILD_GLES2_TESTS "Build tests for OpenGL ES2" ${PIGLIT_BUILD_GLES_TESTS_DEFAULT})
  47 option(PIGLIT_BUILD_GLES3_TESTS "Build tests for OpenGL ES3" ${PIGLIT_BUILD_GLES_TESTS_DEFAULT})
  48 option(PIGLIT_BUILD_CL_TESTS "Build tests for OpenCL" OFF)
  49
  50 if(PIGLIT_BUILD_GL_TESTS)
  51         find_package(OpenGL REQUIRED)
  52 endif()
  53
  54 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  55         option(PIGLIT_USE_WAFFLE "Use Waffle in place of GLUT" ON)
  56 else()
  57         option(PIGLIT_USE_WAFFLE "Use Waffle in place of GLUT" OFF)
  58 endif()
  59
  60 if(PIGLIT_USE_WAFFLE)
  61         if (NOT WIN32)
  62                 pkg_check_modules(Waffle REQUIRED waffle-1)
  63
  64                 if(NOT Waffle_FOUND)
  65                         message(FATAL_ERROR "Failed to find Waffle. If Waffle "
  66                         "is not packaged for your distribution, you can get "
  67                         "it at http://www.waffle-gl.org."
  68                 )
  69                 endif()
  70
  71                 # Check the installed waffle version.
  72                 #
  73                 # We cannot reliably check the version with pkg_check_modules(), but
  74                 # instead must check the version manually as below. The problem is that,
  75                 # if one passes a required version to pkg_check_modules(), CMake
  76                 # validates the required version at most once for the lifetime of the
  77                 # source tree.  If someone changes the required version by editing the
  78                 # CMakeLists, CMake fails to detect the new requirement.
  79                 set(Waffle_REQUIRED_VERSION "1.5.0")
  80                 if(Waffle_VERSION VERSION_LESS Waffle_REQUIRED_VERSION)
  81                         message(FATAL_ERROR "Found waffle-${Waffle_VERSION}, but "
  82                         "piglit requires waffle-${Waffle_REQUIRED_VERSION}")
  83                 endif()
  84         else ()
  85                 find_path(Waffle_INCLUDE_DIRS waffle.h)
  86                 find_library(Waffle_LDFLAGS waffle-1)
  87                 if(Waffle_INCLUDE_DIRS AND Waffle_LDFLAGS)
  88                         set(Waffle_FOUND TRUE)
  89                 else()
  90                         message(FATAL_ERROR "Failed to find Waffle. Get and build Waffle from "
  91                                 "http://www.waffle-gl.org and set Waffle_INCLUDE_DIRS and "
  92                                 "Waffle_LDFLAGS variables accordingly."
  93                         )
  94                 endif()
  95         endif ()
  96
  97         add_definitions(-DPIGLIT_USE_WAFFLE)
  98         add_definitions(-DWAFFLE_API_VERSION=0x0103)
  99 else()
 100         find_package(GLUT REQUIRED)
 101
 102         # The 'REQUIRED' above correctly produces an error for
 103         # OpenGL, but there's a bug involving FindGLUT.cmake
 104         # that fails to produce the error as of CMake 2.8.5.
 105         #
 106         # Instead, CMake keeps going and eventually spams
 107         # the console with a message for every target that used
 108         # e.g. the ${GLUT_INCLUDE_DIR} variable. So it
 109         # prints a line for basically every single test in piglit.
 110         #
 111         # Work around the bug and error out quickly here instead.
 112         if (NOT GLUT_FOUND)
 113                 message(FATAL_ERROR "GLUT library not found")
 114         endif()
 115 endif(PIGLIT_USE_WAFFLE)
 116
 117 if(PIGLIT_BUILD_GLES1_TESTS AND NOT PIGLIT_USE_WAFFLE)
 118         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES1_TESTS requires PIGLIT_USE_WAFFLE")
 119 endif(PIGLIT_BUILD_GLES1_TESTS AND NOT PIGLIT_USE_WAFFLE)
 120
 121 if(PIGLIT_BUILD_GLES2_TESTS AND NOT PIGLIT_USE_WAFFLE)
 122         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES2_TESTS requires PIGLIT_USE_WAFFLE")
 123 endif(PIGLIT_BUILD_GLES2_TESTS AND NOT PIGLIT_USE_WAFFLE)
 124
 125 if(PIGLIT_BUILD_GLES3_TESTS AND NOT PIGLIT_USE_WAFFLE)
 126         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES3_TESTS requires PIGLIT_USE_WAFFLE")
 127 endif(PIGLIT_BUILD_GLES3_TESTS AND NOT PIGLIT_USE_WAFFLE)
 128
 129 if(PIGLIT_BUILD_CL_TESTS)
 130         find_package(OpenCL REQUIRED)
 131 endif(PIGLIT_BUILD_CL_TESTS)
 132
 133 IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 134         if(X11_FOUND AND OPENGL_gl_LIBRARY)
 135                 # Assume the system has GLX. In the future, systems may exist
 136                 # with libGL and libX11 but no GLX, but that world hasn't
 137                 # arrived yet.
 138                 set(PIGLIT_HAS_GLX True)
 139                 add_definitions(-DPIGLIT_HAS_GLX)
 140         endif()
 141
 142         pkg_check_modules(GBM QUIET gbm)
 143         if(GBM_FOUND)
 144                 set(PIGLIT_HAS_GBM True)
 145                 add_definitions(-DPIGLIT_HAS_GBM)
 146         endif(GBM_FOUND)
 147
 148         pkg_check_modules(WAYLAND QUIET wayland-client wayland-egl)
 149         if (WAYLAND_FOUND)
 150                 set(PIGLIT_HAS_WAYLAND True)
 151                 add_definitions(-DPIGLIT_HAS_WAYLAND)
 152         endif()
 153
 154         pkg_check_modules(LIBDRM QUIET libdrm)
 155         pkg_check_modules(LIBDRM_INTEL QUIET libdrm_intel)
 156         pkg_check_modules(XCB_DRI2 QUIET xcb-dri2)
 157         pkg_check_modules(GLPROTO QUIET glproto)
 158 ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 159         if (PIGLIT_USE_WAFFLE)
 160                 set(PIGLIT_HAS_WGL True)
 161                 add_definitions(-DPIGLIT_HAS_WGL)
 162         endif()
 163 ENDIF()
 164
 165 IF(PIGLIT_HAS_GLX)
 166         option(PIGLIT_BUILD_GLX_TESTS "Build tests that require GLX" ON)
 167 ELSE()
 168         option(PIGLIT_BUILD_GLX_TESTS "Build tests that require GLX" OFF)
 169 ENDIF()
 170
 171 # Choose to build tests that use dma_buf.
 172 #
 173 # Piglit's dma_buf utilities require xcb-dri2 to gain DRM authentication.
 174 #
 175 # The presence of libdrm is not sufficient. At least one libdrm_${hardware}
 176 # library is also needed.
 177 #
 178 # When building for Intel, libdrm_intel>=2.4.38 is required because support for
 179 # drm-prime arrived in that version.
 180 #
 181 if(LIBDRM_FOUND AND XCB_DRI2_FOUND AND
 182    (LIBDRM_INTEL_VERSION VERSION_GREATER "2.4.37"))
 183         set(PIGLIT_BUILD_DMA_BUF_TESTS_IS_VALID true)
 184 else()
 185         set(PIGLIT_BUILD_DMA_BUF_TESTS_IS_VALID false)
 186 endif()
 187
 188 if(PIGLIT_BUILD_DMA_BUF_TESTS_IS_VALID)
 189         option(PIGLIT_BUILD_DMA_BUF_TESTS "Build tests that use dma_buf" ON)
 190 else()
 191         option(PIGLIT_BUILD_DMA_BUF_TESTS "Build tests that use dma_buf" OFF)
 192 endif()
 193
 194 # If the users has updated PIGLIT_BUILD_DMA_BUF_TESTS in the CMakeCache, then
 195 # we need to validate it.
 196 if(PIGLIT_BUILD_DMA_BUF_TESTS AND NOT PIGLIT_BUILD_DMA_BUF_TESTS_IS_VALID)
 197         message(FATAL_ERROR
 198                 "PIGLIT_BUILD_DMA_BUF_TESTS require libdrm, "
 199                 "libdrm_intel>=2.4.38, and xcb-dri2")
 200 endif()
 201
 202 IF(PIGLIT_BUILD_GLX_TESTS)
 203         pkg_check_modules(GLPROTO REQUIRED glproto)
 204 ENDIF()
 205
 206 find_package(PythonInterp 2.7 REQUIRED)
 207 find_package(PythonNumpy 1.6.2 REQUIRED)
 208 find_package(PythonMako 0.8.0 REQUIRED)
 209 find_package(PythonSix 1.4.0 REQUIRED)
 210
 211 # Default to compiling with debug information (`gcc -g`):
 212 if(NOT CMAKE_BUILD_TYPE)
 213         SET(CMAKE_BUILD_TYPE Debug CACHE STRING
 214         "May be one of: None Debug RelWithDebInfo Release MinSizeRel" FORCE)
 215 endif(NOT CMAKE_BUILD_TYPE)
 216
 217 if (NOT MSVC)
 218         CHECK_C_COMPILER_FLAG("-Wall" C_COMPILER_FLAG_WALL)
 219         IF (C_COMPILER_FLAG_WALL)
 220                 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
 221         ENDIF (C_COMPILER_FLAG_WALL)
 222         CHECK_CXX_COMPILER_FLAG("-Wall" CXX_COMPILER_FLAG_WALL)
 223         IF (CXX_COMPILER_FLAG_WALL)
 224                 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 225         ENDIF (CXX_COMPILER_FLAG_WALL)
 226
 227         # MSVC does not support C99 variable length arrays
 228         CHECK_C_COMPILER_FLAG("-Werror=vla" C_COMPILER_FLAG_WEVLA)
 229         IF (C_COMPILER_FLAG_WEVLA)
 230                 SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=vla")
 231         ENDIF ()
 232         # GCC allows void pointer arithmetic, but it is not part of ISO C and
 233         # in particular MSVC will throw `C2036: 'void *' : unknown size`
 234         check_c_compiler_flag ("-Werror=pointer-arith" C_COMPILER_FLAG_WEPOINTER_ARITH)
 235         if (C_COMPILER_FLAG_WEPOINTER_ARITH)
 236                 set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=pointer-arith")
 237         endif ()
 238         # MSVC only supports C99 variadic macros.  It doesn't support the
 239         # non-standard GNU named variadic macro syntax that's documented in
 240         # https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html
 241         #
 242         # XXX: on older GCC version this option has no effect unless -Wpedantic
 243         # is set, but this should be fixed on future GCC versions, per
 244         # https://gcc.gnu.org/ml/gcc-patches/2014-04/msg01459.html
 245         check_c_compiler_flag ("-Werror=variadic-macros" C_COMPILER_FLAG_WVARIADIC_MACROS)
 246         if (C_COMPILER_FLAG_WVARIADIC_MACROS)
 247                 set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=variadic-macros")
 248         endif ()
 249
 250         CHECK_CXX_COMPILER_FLAG("-Wno-narrowing" CXX_COMPILER_FLAG_WNO_NARROWING)
 251         IF (CXX_COMPILER_FLAG_WNO_NARROWING)
 252                 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-narrowing")
 253         ENDIF (CXX_COMPILER_FLAG_WNO_NARROWING)
 254 else ()
 255         # Adjust warnings
 256         add_definitions (-W3)
 257         add_definitions (-wd4018) # signed/unsigned mismatch
 258         add_definitions (-wd4244) # conversion from 'type1' to 'type2', possible loss of data
 259         add_definitions (-wd4305) # truncation from 'type1' to 'type2'
 260         add_definitions (-wd4800) # forcing value to bool 'true' or 'false' (performance warning)
 261
 262         add_definitions (-D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS)
 263         add_definitions (-D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS)
 264 endif ()
 265
 266 if (MINGW)
 267         # Match MSVC default stack size
 268         set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,1048576")
 269
 270         # Avoid depending on MinGW runtime DLLs
 271         check_cxx_compiler_flag (-static-libgcc HAVE_STATIC_LIBGCC_FLAG)
 272         if (HAVE_STATIC_LIBGCC_FLAG)
 273                 set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc")
 274                 set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-libgcc")
 275                 set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -static-libgcc")
 276         endif ()
 277         check_cxx_compiler_flag (-static-libstdc++ HAVE_STATIC_LIBSTDCXX_FLAG)
 278         if (HAVE_STATIC_LIBSTDCXX_FLAG)
 279                 set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++")
 280                 set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-libstdc++")
 281                 set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -static-libstdc++")
 282         endif ()
 283 endif ()
 284
 285 if (${CMAKE_C_COMPILER_ID} STREQUAL "SunPro")
 286         # Use C++ to link C files.
 287         # http://developers.sun.com/solaris/articles/mixing.html#linking
 288         # Modified rule from Modules/CMakeCInformation.cmake.
 289         set (CMAKE_C_LINK_EXECUTABLE
 290                 "<CMAKE_CXX_COMPILER> <FLAGS> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
 291 endif()
 292
 293 # Always enable GNU C extensions.  Non-GNU platforms will need to
 294 # define wrappers for them.
 295 add_definitions(-D_GNU_SOURCE)
 296
 297 if (WIN32)
 298         # MSVC & MinGW only define & use APIENTRY
 299         add_definitions (-DGLAPIENTRY=__stdcall)
 300
 301         # Avoid namespace pollution when including windows.h
 302         # http://support.microsoft.com/kb/166474
 303         add_definitions (-DWIN32_LEAN_AND_MEAN=1)
 304
 305         # Don't define min/max macros
 306         add_definitions (-DNOMINMAX)
 307
 308         # Define M_PI and others
 309         add_definitions (-D_USE_MATH_DEFINES)
 310 endif (WIN32)
 311
 312 if (APPLE)
 313         # Don't warn about using deprecated OpenGL/GLUT functions.
 314         # TODO: It would be nice to silence just the deprecation macros from
 315         # OpenGLAvailability.h as opposed to all deprecated functions.
 316         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
 317         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
 318 endif ()
 319
 320 if (OPENGL_FOUND)
 321         if (APPLE)
 322                 find_path(GLEXT_INCLUDE_DIR
 323                         NAMES OpenGL/glext.h
 324                         PATHS ${OPENGL_INCLUDE_DIR}
 325                         DOC "Include for OpenGL/glext.h on OSX"
 326                 )
 327         else (APPLE)
 328                 find_path(GLEXT_INCLUDE_DIR
 329                         NAMES GL/glext.h
 330                         PATHS ${OPENGL_INCLUDE_DIR}
 331                         DOC "Include for GL/glext.h"
 332                 )
 333         endif (APPLE)
 334 endif()
 335
 336 if(CMAKE_USE_PTHREADS_INIT)
 337         set(PIGLIT_HAS_PTHREADS true)
 338         add_definitions(-DPIGLIT_HAS_PTHREADS)
 339 endif()
 340
 341 FIND_LIBRARY(HAVE_LIBRT NAMES rt)
 342 if(HAVE_LIBRT)
 343         set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} rt)
 344 endif()
 345
 346 check_c_source_compiles(
 347         "
 348         #define _POSIX_C_SOURCE 199309L
 349         #include <time.h>
 350         int main() { return clock_gettime(CLOCK_MONOTONIC, NULL); }
 351         "
 352         PIGLIT_HAS_POSIX_CLOCK_MONOTONIC
 353 )
 354
 355 if(PIGLIT_HAS_PTHREADS AND PIGLIT_HAS_POSIX_CLOCK_MONOTONIC)
 356         check_c_source_compiles(
 357                 "
 358                 #include <signal.h>
 359                 #include <time.h>
 360                 static void timeout(union sigval val) { }
 361                 int main() {
 362                         struct sigevent sev = {
 363                                 .sigev_notify = SIGEV_THREAD,
 364                                 .sigev_notify_function = timeout,
 365                         };
 366                         timer_t timerid;
 367                         return timer_create(CLOCK_MONOTONIC, &sev, &timerid);
 368                 }
 369                 "
 370                 PIGLIT_HAS_POSIX_TIMER_NOTIFY_THREAD
 371         )
 372 endif()
 373
 374 set(CMAKE_REQUIRED_LIBRARIES)
 375
 376 if(PIGLIT_HAS_POSIX_CLOCK_MONOTONIC)
 377         add_definitions(-DPIGLIT_HAS_POSIX_CLOCK_MONOTONIC)
 378 endif()
 379
 380 if(PIGLIT_HAS_POSIX_TIMER_NOTIFY_THREAD)
 381         add_definitions(-DPIGLIT_HAS_POSIX_TIMER_NOTIFY_THREAD)
 382 endif()
 383
 384 if(GBM_FOUND)
 385 FIND_LIBRARY(HAVE_LIBCACA NAMES caca)
 386 if(HAVE_LIBCACA)
 387         set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} caca)
 388         add_definitions(-DPIGLIT_HAS_LIBCACA)
 389 endif(HAVE_LIBCACA)
 390 endif(GBM_FOUND)
 391
 392 if(PIGLIT_USE_WAFFLE AND ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
 393         pkg_check_modules(EGL egl)
 394 endif()
 395
 396 if(EGL_FOUND)
 397         add_definitions(-DPIGLIT_HAS_EGL)
 398         include_directories(${EGL_INCLUDE_DIRS})
 399 endif()
 400
 401 if(PIGLIT_BUILD_GLES1_TESTS AND NOT EGL_FOUND)
 402         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES1_TESTS requires EGL. "
 403                             "Failed to find EGL library.")
 404 endif()
 405
 406 if(PIGLIT_BUILD_GLES2_TESTS AND NOT EGL_FOUND)
 407         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES2_TESTS requires EGL. "
 408                             "Failed to find EGL library.")
 409 endif()
 410
 411 if(PIGLIT_BUILD_GLES3_TESTS AND NOT EGL_FOUND)
 412         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES3_TESTS requires EGL. "
 413                             "Failed to find EGL library.")
 414 endif()
 415
 416 # Put all executables into the bin subdirectory
 417 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${piglit_BINARY_DIR}/bin)
 418 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${piglit_BINARY_DIR}/lib)
 419
 420 # Do the same for MSVC, regardless of the build type. This only works correctly
 421 # for CMake 2.8.1 and above.
 422 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${piglit_BINARY_DIR}/bin)
 423 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${piglit_BINARY_DIR}/bin)
 424 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${piglit_BINARY_DIR}/bin)
 425 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${piglit_BINARY_DIR}/bin)
 426
 427 check_function_exists(asprintf  HAVE_ASPRINTF)
 428 check_function_exists(ffs       HAVE_FFS)
 429 check_function_exists(strchrnul HAVE_STRCHRNUL)
 430 check_function_exists(strndup   HAVE_STRNDUP)
 431 if(NOT MINGW)
 432 check_function_exists(fopen_s   HAVE_FOPEN_S)
 433 endif()
 434 check_function_exists(setrlimit HAVE_SETRLIMIT)
 435
 436 check_include_file(sys/time.h  HAVE_SYS_TIME_H)
 437 check_include_file(sys/types.h HAVE_SYS_TYPES_H)
 438 check_include_file(sys/resource.h  HAVE_SYS_RESOURCE_H)
 439 check_include_file(sys/stat.h  HAVE_SYS_STAT_H)
 440 check_include_file(unistd.h    HAVE_UNISTD_H)
 441 check_include_file(fcntl.h     HAVE_FCNTL_H)
 442
 443 if(DEFINED PIGLIT_INSTALL_VERSION)
 444         set(PIGLIT_INSTALL_VERSION_SUFFIX
 445             "-${PIGLIT_INSTALL_VERSION}")
 446 else()
 447         set(PIGLIT_INSTALL_VERSION_SUFFIX "")
 448 endif()
 449 set(PIGLIT_INSTALL_LIBDIR
 450     "${CMAKE_INSTALL_LIBDIR}/piglit${PIGLIT_INSTALL_VERSION_SUFFIX}")
 451 if(NOT IS_ABSOLUTE ${PIGLIT_INSTALL_LIBDIR})
 452         set(PIGLIT_INSTALL_FULL_LIBDIR "${CMAKE_INSTALL_PREFIX}/${PIGLIT_INSTALL_LIBDIR}")
 453 else()
 454         set(PIGLIT_INSTALL_FULL_LIBDIR "${PIGLIT_INSTALL_LIBDIR}")
 455 endif()
 456
 457 SET(CMAKE_INSTALL_RPATH "${PIGLIT_INSTALL_FULL_LIBDIR}/lib")
 458
 459 configure_file(
 460         "${piglit_SOURCE_DIR}/tests/util/config.h.in"
 461         "${piglit_BINARY_DIR}/tests/util/config.h"
 462 )
 463
 464 include(cmake/piglit_util.cmake)
 465 include(cmake/piglit_dispatch.cmake)
 466
 467 include_directories(src)
 468 add_subdirectory(cmake/target_api)
 469 add_subdirectory(generated_tests)
 470
 471
 472 ##############################################################################
 473 # Packaging
 474
 475 install (
 476         FILES
 477                 COPYING
 478                 README
 479                 RELEASE
 480         DESTINATION share/doc/piglit${PIGLIT_INSTALL_VERSION_SUFFIX}
 481 )
 482
 483 install (
 484         DIRECTORY framework
 485         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 486         FILES_MATCHING PATTERN "*.py"
 487 )
 488
 489 install (
 490         DIRECTORY templates
 491         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 492 )
 493
 494 install (
 495         DIRECTORY tests
 496         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 497         FILES_MATCHING REGEX ".*\\.(py|program_test|shader_test|frag|vert|geom|tesc|tese|ktx|cl|txt|inc)$"
 498         REGEX "CMakeFiles|CMakeLists" EXCLUDE
 499 )
 500
 501 install (
 502         DIRECTORY ${CMAKE_BINARY_DIR}/generated_tests
 503         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 504         FILES_MATCHING REGEX ".*\\.(shader_test|program_test|frag|vert|geom|tesc|tese|cl|txt)$"
 505         REGEX "CMakeFiles|CMakeLists" EXCLUDE
 506 )
 507
 508 install (
 509         DIRECTORY generated_tests
 510         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 511         FILES_MATCHING REGEX ".*\\.inc$"
 512         REGEX "CMakeFiles|CMakeLists" EXCLUDE
 513 )
 514
 515 if (WIN32)
 516         set (PYTHON_SUFFIX ".py")
 517 else ()
 518         set (PYTHON_SUFFIX "")
 519 endif ()
 520 install (
 521         PROGRAMS piglit RENAME piglit${PIGLIT_INSTALL_VERSION_SUFFIX}${PYTHON_SUFFIX}
 522         DESTINATION ${CMAKE_INSTALL_BINDIR}
 523 )
 524
 525
 526 set (CPACK_PACKAGE_VERSION_MAJOR "1")
 527 set (CPACK_PACKAGE_VERSION_MINOR "0")
 528
 529 # Use current date in YYYYMMDD format as patch number
 530 execute_process (
 531         COMMAND ${PYTHON_EXECUTABLE} -c "import time, sys; sys.stdout.write(time.strftime('%Y%m%d'))"
 532         OUTPUT_VARIABLE CPACK_PACKAGE_VERSION_PATCH
 533 )
 534
 535 # cpack mistakenly detects Mingw-w64 as win32
 536 if (MINGW)
 537         if (CMAKE_SIZEOF_VOID_P EQUAL 8)
 538                 set (CPACK_SYSTEM_NAME win64)
 539         endif ()
 540 endif ()
 541
 542 # See http://www.vtk.org/Wiki/CMake:CPackPackageGenerators
 543 if (WIN32)
 544         set (CPACK_GENERATOR "ZIP")
 545 else ()
 546         set (CPACK_GENERATOR "TBZ2")
 547 endif ()
 548
 549 include(CPack)