added dev/MinGfx/

1 files changed, 395 insertions, 0 deletions

diff --git a/dev/MinGfx/CMakeLists.txt b/dev/MinGfx/CMakeLists.txt
new file mode 100644
index 0000000..e3da874
--- /dev/null
+++ b/dev/MinGfx/CMakeLists.txt
@@ -0,0 +1,395 @@
+# Copyright (c) 2017,2018 Regents of the University of Minnesota.
+# All rights reserved.
+#
+# Original Author(s) of this File: 
+#   Daniel Keefe, Jan 2018, University of Minnesota -- This build system is inspired by
+#   the AUTOBUILD_DEPENDENCY approach I developed for the MinVR Open Source project.  
+#   Tom Sgouros (Brown Univ.) and Dan Orban (Univ. of Minn.) also contributed to earlier 
+#   versions of MinVR's build system and the use of cmake in other research software used
+#   in the IV/LAB.  So, this is also at least loosly inspired by their contributions.  
+#   See minvr.org for a full list of contributors to that project.
+#  
+# Author(s) of Significant Updates/Modifications to the File:
+#   ...
+
+
+
+
+#### BASIC PROJECT SETUP ####
+
+# Depends on cmake 3.9+ for its more advanced FindOpenGL.cmake module
+cmake_minimum_required (VERSION 3.9)
+
+# Search path for cmake support scripts
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
+
+# Version is <major>.<minor>.<patch>
+cmake_policy(SET CMP0048 NEW)  # Required for setting version number as part of the project() command
+project(MinGfx_Toolkit VERSION 1.0.0)
+
+# This will be appended to the install destinations so that multiple versions of MinGfx
+# can be safely installed on the same system.  This intentionally does not include a
+# patch number because patches should be small changes that do not change the API.
+set(MINGFX_VERSION_STR -${MinGfx_Toolkit_VERSION_MAJOR}.${MinGfx_Toolkit_VERSION_MINOR})
+
+# Organize folder structure for Xcode, Visual Studio, etc.
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# For better formatting of output while configuring with cmake
+include(MessageMacros)
+
+# If you "autobuild" external dependencies as part of the cmake configure process, then they will be
+# downloaded to this directory.
+set(AUTOBUILD_DOWNLOAD_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external" CACHE STRING "Location for external project sources downloaded by AutoBuild.")
+
+
+set(CMAKE_INSTALL_MESSAGE ALWAYS)
+
+include(AutoBuild)
+AutoBuild_init()
+
+
+#### ADJUST NAMES OF OUTPUT FILES BASED ON BUILD TYPE ####
+
+h1("CONFIGURING BUILD TYPES")
+
+# To distinguish between debugging, release, and other builds, we'll
+# add a postfix to the name of the lib or exe that we generate.
+
+set(CMAKE_DEBUG_POSTFIX "d")
+set(CMAKE_RELEASE_POSTFIX "")
+set(CMAKE_RELWITHDEBINFO_POSTFIX "rd")
+set(CMAKE_MINSIZEREL_POSTFIX "s")
+
+if (CMAKE_BUILD_TYPE MATCHES "Release")
+  set(CMAKE_BUILD_POSTFIX "${CMAKE_RELEASE_POSTFIX}")
+elseif (CMAKE_BUILD_TYPE MATCHES "MinSizeRel")
+  set(CMAKE_BUILD_POSTFIX "${CMAKE_MINSIZEREL_POSTFIX}")
+elseif (CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
+  set(CMAKE_BUILD_POSTFIX "${CMAKE_RELWITHDEBINFO_POSTFIX}")
+elseif (CMAKE_BUILD_TYPE MATCHES "Debug")
+  set(CMAKE_BUILD_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
+else()
+  set(CMAKE_BUILD_POSTFIX "")
+endif()
+
+
+
+
+#### SETUP DIRECTORIES FOR BUILDING AND INSTALLING ####
+
+h1("CONFIGURING BUILD/INSTALL LOCATIONS")
+
+h2("Configuring build directories.")
+
+message(STATUS "Tests, other binaries: ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+message(STATUS "Libraries: ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+
+
+h2("Configuring installation directories.")
+if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    set (CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "default install path" FORCE )
+endif()
+
+# When we autobuild dependencies, we install them in CMAKE_INSTALL_PREFIX, and then look for them
+# there using find_package().  So, this makes sure the install prefix is in the path that 
+# find_package() searches.
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_INSTALL_PREFIX})
+list(APPEND CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX})
+
+# These are relative to ${CMAKE_INSTALL_PREFIX}
+set(INSTALL_BIN_DEST           bin)
+set(INSTALL_LIB_DEST           lib/MinGfx${MINGFX_VERSION_STR})
+set(INSTALL_INCLUDE_DEST       include/MinGfx${MINGFX_VERSION_STR})
+set(INSTALL_SHADERS_DEST       share/MinGfx${MINGFX_VERSION_STR}/shaders)
+set(INSTALL_DATA_DEST          share/MinGfx${MINGFX_VERSION_STR}/data)
+set(INSTALL_DOC_DEST           share/MinGfx${MINGFX_VERSION_STR}/docs)
+set(INSTALL_CMAKECONFIG_DEST   lib/cmake/MinGfx${MINGFX_VERSION_STR})
+
+message(STATUS "Tests, other binaries: ${CMAKE_INSTALL_PREFIX}/${INSTALL_BIN_DEST}")
+message(STATUS "MinGfx library: ${CMAKE_INSTALL_PREFIX}/${INSTALL_LIB_DEST}")
+message(STATUS "MinGfx header files: ${CMAKE_INSTALL_PREFIX}/${INSTALL_INCLUDE_DEST}")
+message(STATUS "MinGfx shader programs: ${CMAKE_INSTALL_PREFIX}/${INSTALL_SHADERS_DEST}")
+message(STATUS "MinGfx data files: ${CMAKE_INSTALL_PREFIX}/${INSTALL_DATA_DEST}")
+message(STATUS "MinGfx documentation files: ${CMAKE_INSTALL_PREFIX}/${INSTALL_DOC_DEST}")
+message(STATUS "CMake Config Package for including MinGfx in other projects: ${CMAKE_INSTALL_PREFIX}/${INSTALL_CMAKECONFIG_DEST}")
+
+# Configure a header file to pass some of the CMake settings to the source code
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/mingfx_config.h.in
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/mingfx_config.h
+)
+
+
+#### SET ANY COMPILER FLAGS ####
+
+h1("CONFIGURING COMPLIER FLAGS")
+
+
+
+message(STATUS "Building for " ${CMAKE_SYSTEM_NAME} ".")
+message(STATUS "Compiler supported features = ${CMAKE_CXX_COMPILE_FEATURES}")
+
+
+# Linux specific
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  add_definitions(-DLINUX)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
+endif()
+
+
+# Apple specific
+if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  add_definitions(-DOSX)
+
+  # Since for some stupid reason Apple has now deprecated OpenGL
+  #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
+  add_definitions(-DGL_SILENCE_DEPRECATION)
+
+  # RPATH settings, see https://cmake.org/Wiki/CMake_RPATH_handling
+  set(CMAKE_MACOSX_RPATH ON)
+
+  # use, i.e. don't skip the full RPATH for the build tree
+  SET(CMAKE_SKIP_BUILD_RPATH  FALSE)
+
+  # when building, don't use the install RPATH already
+  # (but later on when installing)
+  SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) 
+
+  SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+
+  # add the automatically determined parts of the RPATH
+  # which point to directories outside the build tree to the install RPATH
+  SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+
+  # the RPATH to be used when installing, but only if it's not a system directory
+  LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
+  IF("${isSystemDir}" STREQUAL "-1")
+     SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+  ENDIF("${isSystemDir}" STREQUAL "-1")
+
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
+endif()
+
+
+# Windows specific
+if (WIN32)
+  add_definitions(-DWIN32)
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Z7")
+endif()
+
+
+
+
+#### DEFINE THE LIBRARY WE WANT TO BUILD ####
+
+h1("CONFIGURING LIBMINGFX")
+
+h2("Configuring core library source.")
+message(STATUS "Adding src to the build.")
+
+# Intentionally using include() rather than add_subdirectory() so that the MinGfx target
+# is defined in the scope of this CMakeLists.txt file.  That way, sudirs that depend
+# upon it can list it as a dependency.
+include(src/CMakeLists.txt)
+
+
+
+
+#### DEFINE ADDITIONAL BUILD TARGETS, LIKE TEST PROGRAMS, ETC. ####
+
+h1("CONFIGURING PROGRAMS AND DATA")
+
+h2("Cofiguring test programs.")
+message(STATUS "Adding all subirectories of tests to the build.")
+add_subdirectory(tests/blank_window)
+add_subdirectory(tests/gui_plus_opengl)
+
+
+h2("Cofiguring data.")
+message(STATUS "Identifying data to install.")
+install(
+    DIRECTORY data/
+    DESTINATION ${INSTALL_DATA_DEST}
+)
+
+
+
+#### OPTIONALLY, BUILD DOXYGEN-STYLE DOCUMENTATION ####
+
+h1("CONFIGURING DOCUMENTATION")
+  
+h2("Configuring Web-Based Documentation.")
+option(WITH_DOCUMENTATION "Builds web-based documentation for the library. (Requires doxygen)")
+if (WITH_DOCUMENTATION)
+  message(STATUS "ON: Will build and install MinGfx Web-Based Documentation.")
+else()
+  message(STATUS "OFF: NOT building MinGfx Web-Based Documentation.")
+endif()
+
+if (WITH_DOCUMENTATION)
+    find_package(Doxygen)
+    if(NOT DOXYGEN_FOUND)
+        message(FATAL_ERROR "Doxygen is needed to build the documentation.")
+    endif()
+
+    set(DOXY_FILES
+        doc/Doxyfile.in
+        doc/api.md
+        doc/installation.md
+        doc/mainpage.md
+        doc/header.html
+        doc/index.html
+        doc/footer.html
+        doc/customdoxygen.css
+    )
+
+    set(OTHER_DOCS
+        README.md
+        LICENSE.txt
+    )
+
+    # Process the config file and put it in the build directory.
+    set(DOXYFILE_IN ${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile.in)
+    set(DOXYFILE ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
+    configure_file(${DOXYFILE_IN} ${DOXYFILE} @ONLY)
+
+    add_custom_target(doc ALL
+        ${DOXYGEN_EXECUTABLE} ${DOXYFILE}
+        DEPENDS ${DOXY_FILES} ${OTHER_DOCS}
+        SOURCES ${DOXY_FILES} ${OTHER_DOCS}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating documentation with Doxygen" 
+        VERBATIM
+    )
+
+    set_source_files_properties(${DOXY_FILES} PROPERTIES HEADER_FILE_ONLY TRUE)
+    source_group("Doxygen Files" FILES ${DOXY_FILES})
+
+    set_source_files_properties(${OTHER_DOCS} PROPERTIES HEADER_FILE_ONLY TRUE)
+    source_group("Other Docs" FILES ${OTHER_DOCS})
+
+    install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html 
+        DESTINATION ${INSTALL_DOC_DEST}
+        COMPONENT Docs
+        OPTIONAL
+    )
+
+    install(FILES doc/index.html
+        DESTINATION ${INSTALL_DOC_DEST}
+        COMPONENT Docs
+        OPTIONAL
+    )
+endif()
+
+
+
+
+
+#### CREATE/INSTALL A CMAKE CONFIG PACKAGE TO HELP OTHERS LINK TO THE LIBRARY ####
+
+h1("WRITING CMAKE CONFIG PACKAGE")
+
+# The documentation for setting this up is so bad.  These pages all helped.  My current
+# understanding (dfk) is summarized below to help others.
+# https://cmake.org/cmake/help/git-master/manual/cmake-packages.7.html#creating-packages
+# https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#target-usage-requirements
+# http://foonathan.net/blog/2016/03/03/cmake-install.html
+# https://archive.fosdem.org/2013/schedule/event/moderncmake/attachments/slides/258/export/events/attachments/moderncmake/slides/258/cmake_fosdem_2013.pdf
+
+# CMake Package Config in a Nutshell:
+
+# CMake config packages are the newer, recommended way of distributing projects built with CMake.
+# They replace the older FindModule.cmake approach for including dependencies in a cmake project, 
+# but not everyone has yet switched over to the new approach.  Both styles can work together, and
+# this seems to often be required because many libraries are not yet distributing a *Config.cmake
+# file with their install tree.
+
+
+# 1. The Difference Between "Find Modules" (Find*.cmake) and "Config Packages" (*Config.cmake)
+
+# Whereas, Find*.cmake files are either installed on the system or written by downstream projects.
+# *Config.cmake files are created and installed by the upstream projects (e.g., we want generate
+# MinVRConfig.cmake and install it whenever the MinVR project in installed).
+
+# When you use a Find Module, it defines several variables (e.g., OPENGL_INCLUDE_DIR, OPENGL_LIBRARIES)
+# that you must then be sure to add to the include dirs and libs to link with your project.
+# Config Packages are different.  Instead, they "export" the targets defined in the original project
+# (e.g., the target MinGfx is used in this file to build libMinGfx.a) so that the client project
+# may refer to these targets directly.  This is pretty cool because we can define the MinGfx target
+# in such a way that cmake even knows which header files are associated with it, and will add the
+# required include flags whenever the MinGfx target is used.
+
+
+# 2. How to use Config Packages in a client CMakeLists.txt 
+
+# With the config package appraoch, client projects only need to include two lines to use our library:
+
+# find_package(MinGfx REQUIRED)
+# ... then, after add_executable(${PROJECT_NAME}) or add_library(${PROJECT_NAME})
+# target_link_libraries(${PROJECT_NAME} PUBLIC MinGfx)
+
+
+# 3. Finding *Config.cmake files
+
+# Config packages are files of the form MyProjNameConfig.cmake (or *-config.cmake).  Each library
+# provides and installs its own config package.  So, here we will create one to install with MinGfx.
+# If created correctly, these packages can be relocatable, i.e., not specific to the install path
+# used on a particular machine.  When you call find_package(...) cmake looks for packages in a
+# variety of locations (e.g., /usr/local/lib/cmake/*).  
+
+# Since config packages are supposed to be written by and installed by the upstream dependencies,
+# my understanding is that you should not attempt to write you own version of a config package if
+# you encounter a project that is not (yet) using the config package appraoch.  Instead, use the
+# older Find Module appraoch.  If CMake ships with a Find*.cmake file for that project, then use 
+# it.  If not, then you can write your own.  Since making this switch, many of the newer
+# Find*.cmake scripts that ship with CMake have been updated to support imported targets. They
+# are still called something like FindOpenGL.cmake, but in addition to just setting vars like
+# OPENGL_INCLUDE_DIR, they also define targets, such as OpenGL::GL.  We use these when we can
+# because they are more robust.  When you do target_link_libraries(myproj PULBIC OpenGL::GL)
+# cmake knows to not only link with the the opengl library but also to include its headers and
+# link with all dependencies.
+
+
+# This tells cmake to generate a MinGfxTargets.cmake file that works for importing all targets
+# associated with the MinGfx export group from the install tree.  This file is where all the
+# important cmake magic happens. It is auto-generated.  This call also installs the file to 
+# the appropriate location.
+install(EXPORT MinGfxTargets
+  NAMESPACE MinGfx::
+  FILE MinGfxTargets.cmake
+  DESTINATION ${INSTALL_CMAKECONFIG_DEST}
+)
+
+# This is a very small wrapper around the MinGfxTargets.cmake file.  It's possible to use this
+# configure_file() command to replace variables (e.g., special defines, install paths) in the 
+# file, but we do not currently need that functionality.
+configure_file(
+  cmake/MinGfxConfig.cmake.in
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake/MinGfxConfig.cmake"
+  COPYONLY
+)
+
+# This auto-generates a standard CMake config version file. Using this, client projects can
+# check to see if a specific version of MinGfx is installed on the system.
+include(CMakePackageConfigHelpers)
+set_property(TARGET MinGfx PROPERTY VERSION ${MinGfx_Toolkit_VERSION})
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake/MinGfxConfigVersion.cmake"
+  VERSION ${MinGfx_Toolkit_VERSION}
+  COMPATIBILITY AnyNewerVersion
+)
+
+# The two Config files also get installed
+install(
+  FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/cmake/MinGfxConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/cmake/MinGfxConfigVersion.cmake"
+  DESTINATION
+    "${INSTALL_CMAKECONFIG_DEST}"
+)
+
+
+AutoBuild_check_status()
+