indra/cmake/GLEXT.cmake

-# -*- cmake -*-
-include(Prebuilt)
-
-if (NOT USESYSTEMLIBS)
-  if (WINDOWS OR LINUX)
-    use_prebuilt_binary(glext)
-  endif (WINDOWS OR LINUX)
-  use_prebuilt_binary(glh-linear)
-  set(GLEXT_INCLUDE_DIR ${LIBS_PREBUILT_DIR}/include)
-endif (NOT USESYSTEMLIBS)

indra/cmake/GLH.cmake

-# -*- cmake -*-
-include(Prebuilt)
-
-set(GLH_FIND_REQUIRED TRUE)
-set(GLH_FIND_QUIETLY TRUE)
-
-if (USESYSTEMLIBS)
-  include(FindGLH)
-else (USESYSTEMLIBS)
-  use_prebuilt_binary(glh-linear)
-endif (USESYSTEMLIBS)

indra/cmake/GLM.cmake

+# -*- cmake -*-
+include(Prebuilt)
+
+if (NOT USESYSTEMLIBS)
+  use_prebuilt_binary(glm)
+  set(GLM_INCLUDE_DIR "${LIBS_PREBUILT_DIR}/include")
+endif (NOT USESYSTEMLIBS)
\ No newline at end of file

indra/cmake/GeneratePrecompiledHeader.cmake

+# -*- cmake -*-
+
+# Distributed under the MIT Software License
+# Copyright (c) 2015-2017 Borislav Stanimirov
+# Modifications Copyright (c) 2019 Cinder Roxley. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of 
+# this software and associated documentation files (the "Software"), to deal in 
+# the Software without restriction, including without limitation the rights to 
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+# of the Software, and to permit persons to whom the Software is furnished to do 
+# so, subject to the following conditions:
+# The above copyright notice and this permission notice shall be included in all 
+# copies or substantial portions of the Software.
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+# SOFTWARE.
+
+# target_precompiled_header
+#
+# Sets a precompiled header for a given target
+# Args:
+#   TARGET_NAME - Name of the target. Only valid after add_library or add_executable
+#   PRECOMPILED_HEADER - Header file to precompile
+#   PRECOMPILED_SOURCE - MSVC specific source to do the actual precompilation. Ignored on other platforms
+#
+
+macro(target_precompiled_header TARGET_NAME PRECOMPILED_HEADER PRECOMPILED_SOURCE)
+    get_filename_component(PRECOMPILED_HEADER_NAME ${PRECOMPILED_HEADER} NAME)
+
+    if(MSVC)
+        get_filename_component(PRECOMPILED_SOURCE_NAME ${PRECOMPILED_SOURCE} NAME)
+        get_filename_component(PRECOMPILED_HEADER_PATH ${PRECOMPILED_HEADER} DIRECTORY)
+        target_include_directories(${TARGET_NAME} PRIVATE ${PRECOMPILED_HEADER_PATH}) # fixes occasional IntelliSense glitches
+
+        get_filename_component(PRECOMPILED_HEADER_WE ${PRECOMPILED_HEADER} NAME_WE)
+        if(GEN_IS_MULTI_CONFIG)
+            set(PRECOMPILED_BINARY "$(IntDir)/${PRECOMPILED_HEADER_WE}.pch")
+        else()
+            set(PRECOMPILED_BINARY "${CMAKE_CURRENT_BINARY_DIR}/${PRECOMPILED_HEADER_WE}.pch")
+        endif()
+        
+        set_source_files_properties(${PRECOMPILED_SOURCE} PROPERTIES 
+             COMPILE_OPTIONS "/Yc${PRECOMPILED_HEADER_NAME};/Fp${PRECOMPILED_BINARY}"
+             OBJECT_OUTPUTS "${PRECOMPILED_BINARY}")
+
+        get_target_property(TARGET_SOURCES ${TARGET_NAME} SOURCES)
+        foreach(src ${TARGET_SOURCES})
+            if(${src} MATCHES \\.\(cpp|cxx|cc\)$)
+                set_source_files_properties("${CMAKE_CURRENT_SOURCE_DIR}/${src}" PROPERTIES
+                    COMPILE_OPTIONS "/Yu${PRECOMPILED_HEADER_NAME};/FI${PRECOMPILED_HEADER_NAME};/Fp${PRECOMPILED_BINARY}"
+                    OBJECT_DEPENDS "${PRECOMPILED_BINARY}"
+                    )
+            endif()
+        endforeach()
+        #set_target_properties(${TARGET_NAME} PROPERTIES 
+        #     COMPILE_OPTIONS "/Yu${PRECOMPILED_HEADER_NAME};/FI${PRECOMPILED_HEADER_NAME};/Fp${PRECOMPILED_BINARY}")
+
+        target_sources(${TARGET_NAME} PRIVATE ${PRECOMPILED_SOURCE} ${PRECOMPILED_HEADER})
+    elseif(CMAKE_GENERATOR STREQUAL "Xcode")
+        set_target_properties(
+            ${TARGET_NAME}
+            PROPERTIES
+            XCODE_ATTRIBUTE_GCC_PREFIX_HEADER "${PRECOMPILED_HEADER}"
+            XCODE_ATTRIBUTE_GCC_PRECOMPILE_PREFIX_HEADER "YES"
+            )
+    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        # Create and set output directory.
+        set(OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/${PRECOMPILED_HEADER_NAME}.gch")
+        make_directory(${OUTPUT_DIR})
+        set(OUTPUT_NAME "${OUTPUT_DIR}/${PRECOMPILED_HEADER_NAME}.gch")
+
+    # Export compiler flags via a generator to a response file
+        set(PCH_FLAGS_FILE "${OUTPUT_DIR}/${PRECOMPILED_HEADER_NAME}.rsp")
+        set(_include_directories "$<TARGET_PROPERTY:${TARGET_NAME},INCLUDE_DIRECTORIES>")
+        set(_compile_definitions "$<TARGET_PROPERTY:${TARGET_NAME},COMPILE_DEFINITIONS>")
+        set(_compile_flags "$<TARGET_PROPERTY:${TARGET_NAME},COMPILE_FLAGS>")
+        set(_compile_options "$<TARGET_PROPERTY:${TARGET_NAME},COMPILE_OPTIONS>")
+        set(_include_directories "$<$<BOOL:${_include_directories}>:-I$<JOIN:${_include_directories},\n-I>\n>")
+        set(_compile_definitions "$<$<BOOL:${_compile_definitions}>:-D$<JOIN:${_compile_definitions},\n-D>\n>")
+        set(_compile_flags "$<$<BOOL:${_compile_flags}>:$<JOIN:${_compile_flags},\n>\n>")
+        set(_compile_options "$<$<BOOL:${_compile_options}>:$<JOIN:${_compile_options},\n>\n>")
+        file(GENERATE OUTPUT "${PCH_FLAGS_FILE}" CONTENT "${_compile_definitions}${_include_directories}${_compile_flags}${_compile_options}\n")
+
+        # Gather global compiler options, definitions, etc.
+        string(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" CXX_FLAGS)
+        set(COMPILER_FLAGS "${${CXX_FLAGS}} ${CMAKE_CXX_FLAGS}")
+        separate_arguments(COMPILER_FLAGS)
+
+        # Add a custom target for building the precompiled header.
+        add_custom_command(
+            OUTPUT ${OUTPUT_NAME}
+            COMMAND ${CMAKE_CXX_COMPILER} @${PCH_FLAGS_FILE} ${COMPILER_FLAGS} -x c++-header -std=${CXX_STD} -o ${OUTPUT_NAME} ${PRECOMPILED_HEADER}
+            DEPENDS ${PRECOMPILED_HEADER})
+        add_custom_target(${TARGET_NAME}_gch DEPENDS ${OUTPUT_NAME})
+        add_dependencies(${TARGET_NAME} ${TARGET_NAME}_gch)
+
+        # set_target_properties(${TARGET_NAME} PROPERTIES COMPILE_FLAGS "-include ${PRECOMPILED_HEADER_NAME} -Winvalid-pch")
+        get_target_property(SOURCE_FILES ${TARGET_NAME} SOURCES)
+        get_target_property(asdf ${TARGET_NAME} COMPILE_FLAGS)
+        foreach(SOURCE_FILE ${SOURCE_FILES})
+            if(SOURCE_FILE MATCHES \\.\(c|cc|cxx|cpp\)$)
+                set_source_files_properties(${SOURCE_FILE} PROPERTIES
+                   COMPILE_FLAGS "-include ${OUTPUT_DIR}/${PRECOMPILED_HEADER_NAME} -Winvalid-pch"
+                )
+            endif()
+        endforeach()
+    else()
+        message(FATAL_ERROR "Unknown generator for target_precompiled_header. [${CMAKE_CXX_COMPILER_ID}]")
+    endif()
+endmacro(target_precompiled_header)

indra/cmake/Glui.cmake

-# -*- cmake -*-
-include(Linking)
-include(Prebuilt)
-
-if (USESYSTEMLIBS)
-    set(GLUI OFF CACHE BOOL
-        "GLUI support for the llplugin/llmedia test apps.")
-else (USESYSTEMLIBS)
-    use_prebuilt_binary(glui)
-    set(GLUI ON CACHE BOOL
-        "GLUI support for the llplugin/llmedia test apps.")
-endif (USESYSTEMLIBS)
-
-if (LINUX)
-    set(GLUI ON CACHE BOOL
-        "llplugin media apps HACK for Linux.")
-endif (LINUX)
-
-if (DARWIN OR LINUX)
-    set(GLUI_LIBRARY
-        glui)
-endif (DARWIN OR LINUX)
-
-if (WINDOWS)
-    if (WORD_SIZE EQUAL 64)
-    set(GLUI_LIBRARY
-        debug glui64.lib
-        optimized glui64.lib)
-    else (WORD_SIZE EQUAL 64)
-    set(GLUI_LIBRARY
-        debug glui32.lib
-        optimized glui32.lib)
-    endif (WORD_SIZE EQUAL 64)
-endif (WINDOWS)

indra/cmake/Glut.cmake

-# -*- cmake -*-
-include(Linking)
-include(Prebuilt)
-
-if (WINDOWS)
-    use_prebuilt_binary(freeglut)
-    set(GLUT_LIBRARY
-        debug freeglut_static.lib
-        optimized freeglut_static.lib)
-endif (WINDOWS)
-
-if (LINUX)
-  FIND_LIBRARY(GLUT_LIBRARY glut)
-endif (LINUX)
-
-if (DARWIN)
-  include(CMakeFindFrameworks)
-  find_library(GLUT_LIBRARY GLUT)
-endif (DARWIN)

indra/cmake/GoogleBreakpad.cmake

-# -*- cmake -*-
-include(Prebuilt)
-
-if (USESYSTEMLIBS)
-  set(BREAKPAD_EXCEPTION_HANDLER_FIND_REQUIRED ON)
-  include(FindGoogleBreakpad)
-else (USESYSTEMLIBS)
-  use_prebuilt_binary(google_breakpad)
-  if (DARWIN)
-    set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES exception_handler)
-  endif (DARWIN)
-  if (LINUX)
-    set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES breakpad_client)
-  endif (LINUX)
-  if (WINDOWS)
-    set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES exception_handler crash_generation_client crash_generation_server common)
-  endif (WINDOWS)
-  # yes, this does look dumb, no, it's not incorrect
-  #
-  set(BREAKPAD_INCLUDE_DIRECTORIES "${LIBS_PREBUILT_DIR}/include/google_breakpad" "${LIBS_PREBUILT_DIR}/include/google_breakpad/google_breakpad")
-endif (USESYSTEMLIBS)
-

indra/cmake/Hunspell.cmake

@@ -10,10 +10,11 @@ else (USESYSTEMLIBS)
   use_prebuilt_binary(libhunspell)
   if (WINDOWS)
     set(HUNSPELL_LIBRARY libhunspell)
+    add_definitions(-DHUNSPELL_STATIC)
   elseif(DARWIN)
-    set(HUNSPELL_LIBRARY hunspell-1.3)
+    set(HUNSPELL_LIBRARY hunspell-1.6)
   elseif(LINUX)
-    set(HUNSPELL_LIBRARY hunspell-1.3)
+    set(HUNSPELL_LIBRARY hunspell-1.6)
   else()
     message(FATAL_ERROR "Invalid platform")
   endif()

indra/cmake/IntelTBB.cmake

-# -*- cmake -*-
-include(Prebuilt)
-
-if(USE_TBBMALLOC)
-  if(STANDALONE)
-  else(STANDALONE)
-    use_prebuilt_binary(inteltbb)
-    if(WINDOWS)
-      set(TBBMALLOC_LIBRARIES 
-          debug tbbmalloc_proxy_debug
-          optimized tbbmalloc_proxy
-          )
-      if(WORD_SIZE EQUAL 64)
-         set(TBBMALLOC_LINK_FLAGS  "/INCLUDE:__TBB_malloc_proxy")
-      else(WORD_SIZE EQUAL 64) 
-         set(TBBMALLOC_LINK_FLAGS  "/INCLUDE:___TBB_malloc_proxy")
-      endif(WORD_SIZE EQUAL 64)
-    elseif(LINUX)
-      set(TBBMALLOC_LIBRARIES 
-          debug tbbmalloc_proxy_debug
-          optimized tbbmalloc_proxy
-          )
-    endif(WINDOWS)
-  endif(STANDALONE)
-else(USE_TBBMALLOC)
-  set(TBBMALLOC_LIBRARIES "")
-  set(TBBMALLOC_LINK_FLAGS "")
-endif(USE_TBBMALLOC)

indra/cmake/JPEG.cmake

@@ -8,13 +8,16 @@ set(JPEG_FIND_REQUIRED ON)
 if (USESYSTEMLIBS)
   include(FindJPEG)
 else (USESYSTEMLIBS)
-  use_prebuilt_binary(jpeglib)
+
   if (LINUX)
+    use_prebuilt_binary(jpeglib)
     set(JPEG_LIBRARIES jpeg)
   elseif (DARWIN)
+    use_prebuilt_binary(libjpeg-turbo)
     set(JPEG_LIBRARIES jpeg)
   elseif (WINDOWS)
-    set(JPEG_LIBRARIES jpeglib)
+    use_prebuilt_binary(libjpeg-turbo)
+    set(JPEG_LIBRARIES jpeg-static)
   endif (LINUX)
   set(JPEG_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/include)
 endif (USESYSTEMLIBS)

indra/cmake/JsonCpp.cmake

-# -*- cmake -*-
-
-include(Prebuilt)
-
-set(JSONCPP_FIND_QUIETLY ON)
-set(JSONCPP_FIND_REQUIRED ON)
-
-if (USESYSTEMLIBS)
-  include(FindJsonCpp)
-else (USESYSTEMLIBS)
-  use_prebuilt_binary(jsoncpp)
-  if (WINDOWS)
-    set(JSONCPP_LIBRARIES
-      debug jsoncppd.lib
-      optimized jsoncpp.lib)
-  elseif (DARWIN OR LINUX)
-    set(JSONCPP_LIBRARIES libjsoncpp.a)
-  endif (WINDOWS)
-  set(JSONCPP_INCLUDE_DIR "${LIBS_PREBUILT_DIR}/include")
-endif (USESYSTEMLIBS)

indra/cmake/LLAppearance.cmake

 # -*- cmake -*-
 
 include(Variables)
+include(Boost)
+include(LLMessage)
+include(LLCoreHttp)
 
 set(LLAPPEARANCE_INCLUDE_DIRS
     ${LIBS_OPEN_DIR}/llappearance
@@ -12,6 +15,13 @@ if (BUILD_HEADLESS)
     )
 endif (BUILD_HEADLESS)
 
-set(LLAPPEARANCE_LIBRARIES llappearance)
+set(LLAPPEARANCE_LIBRARIES llappearance
+    llmessage
+    llcorehttp
+    ${BOOST_COROUTINE_LIBRARY}
+    ${BOOST_CONTEXT_LIBRARY}
+    ${BOOST_SYSTEM_LIBRARY}
+    )
+
 
 

indra/cmake/LLAppearanceUtility.cmake

 # -*- cmake -*-
 include(Prebuilt)
+include(Boost)
 
 # Linux proprietary build only
 if (INSTALL_PROPRIETARY)
@@ -10,3 +11,4 @@ if (INSTALL_PROPRIETARY)
     endif (LINUX)
 endif (INSTALL_PROPRIETARY)
 
+

indra/cmake/LLCA.cmake

+# -*- cmake -*-
+include(Prebuilt)
+
+use_prebuilt_binary(llca)