Merge branch 'master' into release

Author: febret

Authors.txt

@@ -23,6 +23,7 @@ Contributors:
     Arthur Nishimoto
     JD Pirtle
     Qi Sun
+    Luolei Zhao
 
 Module Contributors:
     Caroline Grace Alexander
@@ -34,7 +35,6 @@ Module Contributors:
     Jason Leigh
     Matt McCrory
     Alex Simes
-    Luolei Zhao
 
 Patch Contributors:
     J Markus Maunus

CMakeModules/FindOmegalib.cmake

@@ -32,10 +32,10 @@ else()
 endif()
 
 if(OMEGA_BINARY_DIR)
-	set(OMICRON_DEFAULT_BINARY_DIR ${OMEGA_BINARY_DIR}/omicron/omicron)
+	set(OMICRON_DEFAULT_BINARY_DIR ${OMEGA_BINARY_DIR}/src/omicron/omicron)
 	#set(OMICRON_BIN_DIR ${OMEGA_BINARY_DIR}/bin)
 	#set(OMICRON_LIB_DIR ${OMEGA_BINARY_DIR}/lib)
-	include(${OMEGA_SOURCE_DIR}/omicron/CMakeModules/FindOmicron.cmake)
+	include(${OMEGA_SOURCE_DIR}/src/omicron/CMakeModules/FindOmicron.cmake)
 
 	# the following are the include directories needed to build a 3rd party omegalib application.
 	# in the future, just ${OMEGA_ROOT_DIR}/include will be needed, but for now, multiple paths 
@@ -45,6 +45,7 @@ if(OMEGA_BINARY_DIR)
 		${OMICRON_INCLUDE_DIRS} 
 		${OMEGA_BINARY_DIR}/include 
 		${OMEGA_SOURCE_DIR}/include 
+		${OMEGA_SOURCE_DIR}/src/glew 
 		${OMEGA_SOURCE_DIR}/external/include  
 		${OMEGA_SOURCE_DIR}/modules
 		${OSG_INCLUDES} 

CMakeModules/ModuleUtils.cmake

@@ -31,14 +31,19 @@ function(module_def MODULE_NAME URL DESCRIPTION)
 			message(STATUS "Module ${MODULE_NAME} installed")
 		endif()
 
-        select_module_branch(${GIT_BRANCH} ${CMAKE_SOURCE_DIR}/modules/${MODULE_NAME} ${MODULE_NAME})
-                
+        if(NOT PACK_APP_MODE)
+            select_module_branch(${GIT_BRANCH} ${CMAKE_SOURCE_DIR}/modules/${MODULE_NAME} ${MODULE_NAME})
+        endif()
+        
 		# substitute dashes with underscores in macro module names ('-' is
 		# not a valid character
 		string(REPLACE "-" "_" MACRO_MODULE_NAME ${MODULE_NAME})
 		string(REPLACE "." "_" MACRO_MODULE_NAME ${MACRO_MODULE_NAME})
-		file(APPEND ${MODULES_CONFIG_FILE} "#define ${MACRO_MODULE_NAME}_ENABLED\n")
-
+		
+		if(NOT PACK_APP_MODE)
+		    file(APPEND ${MODULES_CONFIG_FILE} "#define ${MACRO_MODULE_NAME}_ENABLED\n")
+        endif()
+        
 		# find dependencies
 		file(STRINGS ${CMAKE_SOURCE_DIR}/modules/${MODULE_NAME}/CMakeLists.txt 
 			${MODULE_NAME}_DEPS_RAW
@@ -118,7 +123,6 @@ function(add_module MODULE_ID)
             endif()
         endif()
     endif()
-    
     set(MODULES_${MODULE_NAME} true CACHE BOOL ${MODULES_${MODULE_NAME}_DESCRIPTION})
     #module_def(${MODULE_NAME} https://github.com/${MODULE_GIT_ORG}/${MODULE_NAME}.git ${MODULES_${MODULE_NAME}_DESCRIPTION})
 endfunction()
@@ -155,13 +159,13 @@ function(request_dependency MODULE_FULLNAME)
 endfunction()
 
 #-------------------------------------------------------------------------------
-# Entry point for module processing, used by src/CMakeLists.txt
-macro(process_modules)
+# updated the enabled modules list (MODULES) based on the MODULES_ADD and 
+# MODULES_REMOVE variables
+macro(update_enabled_modules)
     # MODULES_LIST = modules that the user wants installed
     # REQUESTED_MODULES = modules requested by the user + all resolved dependencies
     set(MODULES "" CACHE STRING "The list of enabled modules")
     set(REQUESTED_MODULES "")
-    set(REGENERATE_REQUESTED true CACHE BOOL "" FORCE)
 
     # Add modules from the MODULES_ADD variable to the list of initial modules
     # remove modules from the MODULES_REMOVE variable from the list of initial modules
@@ -174,6 +178,43 @@ macro(process_modules)
     list(REMOVE_DUPLICATES MODULES)
     set(MODULES ${MODULES} CACHE STRING "The list of enabled modules" FORCE)
 
+    separate_arguments(MODULES_LIST WINDOWS_COMMAND "${MODULES}")
+    string(REPLACE " " ";" MODULES_LIST "${MODULES_LIST}")
+    string(REPLACE "\"" "" MODULES_LIST "${MODULES_LIST}")
+endmacro()
+
+#-------------------------------------------------------------------------------
+# creates the initial modulesConfig.h file
+macro(create_modules_config_header)
+    set(MODULES_CONFIG_FILE ${CMAKE_BINARY_DIR}/include/modulesConfig.h)
+    file(REMOVE ${MODULES_CONFIG_FILE})
+    file(APPEND ${MODULES_CONFIG_FILE} "//auto-generated file\n")
+endmacro()
+
+#-------------------------------------------------------------------------------
+# creates the initial pack script file
+macro(create_pack_file)
+    # create the pack.cmake file. This file contains the commands to create
+    # packaged modules for the omegalib installer. Each module will append
+    # its own pack.cmake file to this one.
+    if(PACK_APP_MODE)
+        set(PACK_FILE ${PACKAGE_DIR}/pack.cmake)
+    else()
+        set(PACK_FILE ${CMAKE_SOURCE_DIR}/install/pack.cmake)
+    endif()
+    file(REMOVE ${PACK_FILE}.in)
+    file(READ ${CMAKE_SOURCE_DIR}/src/pack_header.cmake PACK_HEADER_FILE_CONTENTS)
+    file(READ ${CMAKE_SOURCE_DIR}/src/pack_core.cmake PACK_CORE_FILE_CONTENTS)
+    file(APPEND ${PACK_FILE}.in "${PACK_HEADER_FILE_CONTENTS} ${PACK_CORE_FILE_CONTENTS}")
+endmacro()
+
+#-------------------------------------------------------------------------------
+# Entry point for module processing, used by src/CMakeLists.txt
+macro(process_modules)
+    set(REGENERATE_REQUESTED true CACHE BOOL "" FORCE)
+    
+    update_enabled_modules()
+
     if(NOT "${MODULES}" STREQUAL "")
         # First step: request modules that the user wants. 
         separate_arguments(MODULES_LIST WINDOWS_COMMAND "${MODULES}")
@@ -182,38 +223,31 @@ macro(process_modules)
             string(REPLACE "\"" "" UNQUOTEDMODULE "${MODULE}")
             request_dependency(${UNQUOTEDMODULE})
         endforeach()
-
+        
         # Keep running until all module dependencies are resolved.
         while(REGENERATE_REQUESTED)
             set(REGENERATE_REQUESTED false CACHE BOOL "" FORCE)
 
-            # delete the modulesConfig.h file, it will be regenerated by module_def
-            # for native modules.
-            set(MODULES_CONFIG_FILE ${CMAKE_BINARY_DIR}/include/modulesConfig.h)
-            file(REMOVE ${MODULES_CONFIG_FILE})
-            file(APPEND ${MODULES_CONFIG_FILE} "//auto-generated file\n")
-
-            # create the pack.cmake file. This file contains the commands to create
-            # packaged modules for the omegalib installer. Each module will append
-            # its own pack.cmake file to this one.
-            set(PACK_FILE ${CMAKE_SOURCE_DIR}/install/pack.cmake)
-            file(REMOVE ${PACK_FILE}.in)
-            file(READ pack_header.cmake PACK_HEADER_FILE_CONTENTS)
-            file(READ pack_core.cmake PACK_CORE_FILE_CONTENTS)
-            file(APPEND ${PACK_FILE}.in "${PACK_HEADER_FILE_CONTENTS} ${PACK_CORE_FILE_CONTENTS}")
+            if(NOT PACK_APP_MODE)
+                create_modules_config_header()
+            endif()
+            
+            create_pack_file()
 
             # Loop through all the requested modules, loading the module definitions.
-            # The module_def call will process dependencies for each module,
-            # adding missing dependencies to REQUESTED_MODULES until all dependencies are
+            # The module_def call will process dependencies for each module, adding
+            # missing dependencies to REQUESTED_MODULES until all dependencies are
             # resolved and REGENERATE_REQUESTED stays false.
             list(REMOVE_DUPLICATES REQUESTED_MODULES)
+
             foreach(MODULE_ID ${REQUESTED_MODULES})
+                # Split module id into module name and (optional) git organization
                 get_filename_component(MODULE_GIT_ORG ${MODULE_ID} DIRECTORY)
                 get_filename_component(MODULE_NAME ${MODULE_ID} NAME)
-                
                 if("${MODULE_GIT_ORG}" STREQUAL "")
                     set(MODULE_GIT_ORG ${OMEGA_DEFAULT_MODULE_ORGANIZATION})
                 endif()
+                
                 # Local module support
                 if("${MODULE_GIT_ORG}" STREQUAL ".")
                     module_def(
@@ -228,17 +262,17 @@ macro(process_modules)
 
             configure_file(${PACK_FILE}.in ${PACK_FILE} @ONLY)
         endwhile()
-
-        # Add the modules subdirectory. This will include cmake scripts for all native modules
-        #add_subdirectory(${CMAKE_SOURCE_DIR}/modules ${CMAKE_BINARY_DIR}/modules)
-        list(REMOVE_DUPLICATES REQUESTED_MODULES)
-        list(REVERSE REQUESTED_MODULES)
-        foreach(MODULE ${REQUESTED_MODULES})
-                get_filename_component(MODULE_GIT_ORG ${MODULE} DIRECTORY)
-                get_filename_component(MODULE_NAME ${MODULE} NAME)
-            message("processing module ${MODULE_NAME}")
-            add_subdirectory(${CMAKE_SOURCE_DIR}/modules/${MODULE_NAME} ${CMAKE_BINARY_DIR}/modules/${MODULE_NAME})
-        endforeach()
+        
+        if(NOT PACK_APP_MODE)
+            list(REMOVE_DUPLICATES REQUESTED_MODULES)
+            list(REVERSE REQUESTED_MODULES)
+            foreach(MODULE ${REQUESTED_MODULES})
+                    get_filename_component(MODULE_GIT_ORG ${MODULE} DIRECTORY)
+                    get_filename_component(MODULE_NAME ${MODULE} NAME)
+                message("processing module ${MODULE_NAME}")
+                add_subdirectory(${CMAKE_SOURCE_DIR}/modules/${MODULE_NAME} ${CMAKE_BINARY_DIR}/modules/${MODULE_NAME})
+            endforeach()
+        endif()
     endif()
 endmacro()
 
@@ -262,7 +296,7 @@ macro(declare_native_module MODULE_NAME)
 endmacro()
 
 # Copy a list of files from one directory to another. Relative files paths are maintained.
-macro(postbuild_copy_files target file_list source_dir target_dir)
+macro(copy_files target file_list source_dir target_dir)
   foreach(FILENAME ${file_list})
     set(source_file ${source_dir}/${FILENAME})
     set(target_file ${target_dir}/${FILENAME})
@@ -287,10 +321,21 @@ endmacro()
 macro(copy_shared_libs target libs source_dir)
     foreach(LIB ${libs})
         if(OMEGA_OS_WIN)
-          postbuild_copy_files("${target}" "${LIB}.dll" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG}")
-          postbuild_copy_files("${target}" "${LIB}.dll" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE}")
+          copy_files("${target}" "${LIB}.dll" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG}")
+          copy_files("${target}" "${LIB}.dll" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE}")
+        elseif(OMEGA_OS_OSX)
+          copy_files("${target}" "lib${LIB}.dylib" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
         else()
-          postbuild_copy_files("${target}" "${LIB}.so" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+          copy_files("${target}" "lib${LIB}.so" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
         endif()
     endforeach()
 endmacro()
+
+macro(copy_files_to_bin target file_list source_dir)
+	if(OMEGA_OS_WIN)
+	  copy_files("${target}" "${file_list}" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG}")
+	  copy_files("${target}" "${file_list}" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE}")
+	else()
+	  copy_files("${target}" "${file_list}" "${source_dir}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+	endif()
+endmacro()

default.cfg

@@ -1,5 +1,6 @@
 config:
 {
+	orun: {initScript="default_init.py";};
 	systemConfig = "system/desktop.cfg";
 	//systemConfig = "system/desktop-omicron.cfg";
 	//systemConfig = "evl/lyra-xinerama.cfg";

etc/mtools/choose.cmake

@@ -8,6 +8,7 @@ set(CHOOSE_FILE ${CMAKE_CURRENT_LIST_DIR}/../../../choose_${ARG2}.bat)
 file(REMOVE ${CHOOSE_FILE})
 file(APPEND ${CHOOSE_FILE} "set OMEGA_HOME=${CMAKE_CURRENT_LIST_DIR}/../../\n")
 file(APPEND ${CHOOSE_FILE} "set PATH=${CMAKE_CURRENT_LIST_DIR}/../../build/bin/release;%PATH%\n")
+file(APPEND ${CHOOSE_FILE} "cmd")
 
 message("Choose script prepared")
 message("call choose_${ARG2}.bat to switch your omegalib environment to ${ARG2}")

etc/mtools/pack.app.cmake

@@ -3,66 +3,73 @@ if("${ARG2}" STREQUAL "")
     return()
 endif()
 
-if(NOT WIN32)
-    message("ERROR: omega pack.app is currently only supported on windows")
-    return()
-endif()
+# ARG2 - distribution
+# ARG3 - app name (also name of the module in distribution)
+
+include(${ARG2}/CMakeModules/ModuleUtils.cmake)
 
 if(WIN32)
     set(BIN_DIR ${ARG2}/build/bin/release)
 else()
     set(BIN_DIR ${ARG2}/build/bin)
 endif()
 
-set(PACKAGE_DIR pack/${ARG3})
-
-# By default the app directory is apps/<appname>
-# If we can't find it, we assume the application is inside the omegalib modules directory
-set(APP_DIR apps/${ARG3})
-if(NOT EXISTS ${APP_DIR})
-    set(APP_DIR ${ARG2}/modules/${ARG3})
-endif()
-set(SOURCE_DIR ${ARG2})
-set(PACKAGED_MODULES "")
-
-function(pack_module MODULE_NAME MODULE_DIR)
-        message("Packing dependent module ${MODULE_NAME}")
-        list(APPEND PACKAGED_MODULES ${MODULE_NAME})
-        message(${PACKAGED_MODULES})
-        
-        #Run the pack commands for the module
-        include("${MODULE_DIR}/pack.cmake")
-        
-		# find dependencies and pack them
-		file(STRINGS "${MODULE_DIR}/CMakeLists.txt"
-			${MODULE_NAME}_DEPS_RAW
-			REGEX "^request_dependency([a-zA-Z0-9_]*)")
+set(CALLING_DIR ${CMAKE_SOURCE_DIR})
+set(PACKAGE_DIR packs/${ARG3})
+set(CMAKE_SOURCE_DIR ${ARG2})
+set(CMAKE_BINARY_DIR ${ARG2}/build)
+set(CMAKE_INSTALL_PREFIX ${PACKAGE_DIR})
 
-		if(NOT "${${MODULE_NAME}_DEPS_RAW}" STREQUAL "")
-			string(REGEX REPLACE "request_dependency\\(([a-zA-Z0-9_]*)\\)" "\\1 " ${MODULE_NAME}_DEPS_STR ${${MODULE_NAME}_DEPS_RAW})
-			separate_arguments(${MODULE_NAME}_DEPS_LIST WINDOWS_COMMAND "${${MODULE_NAME}_DEPS_STR}")
-			foreach(dependency ${${MODULE_NAME}_DEPS_LIST})
-                list(FIND PACKAGED_MODULES ${dependency} _i)
-                if(${_i} EQUAL -1)
-                    pack_module(${dependency} "${ARG2}/modules/${dependency}")
-                endif()
-			endforeach()
-		endif()
-endfunction()
+# copy the core install files to the package target dir
+file(INSTALL DESTINATION ${PACKAGE_DIR}
+    TYPE DIRECTORY
+    FILES
+        ${CMAKE_SOURCE_DIR}/install/config
+    )
+file(INSTALL DESTINATION ${PACKAGE_DIR}/packages/core
+    TYPE DIRECTORY
+    FILES
+        ${CMAKE_SOURCE_DIR}/install/packages/core/meta
+    )
+    
+# Prepare to run process_modules in pack-app mode. Set all the 
+# required variables
+set(PACK_APP_MODE TRUE)
+set(MODULES_ADD ${ARG3})
 
-endmacro()
+process_modules()
+include(${ARG2}/src/pack_functions.cmake)
+include(${PACKAGE_DIR}/pack.cmake)
 
+if(NOT EXISTS cmake/qtifw)
+    file(MAKE_DIRECTORY cmake/qtifw)
+    message("Downloading the Qt Installer Framework tools")
+    if(WIN32)
+		set(TOOLS "archivegen.exe;binarycreator.exe;installerbase.exe;repogen.exe")
+		foreach(S IN LISTS TOOLS)
+			message("...${S}")
+			file(DOWNLOAD ${OPM_URL}/qtifw-1.5.0-win/${S} cmake/qtifw/${S})
+		endforeach()
+    elseif(APPLE)
+		set(TOOLS "archivegen;binarycreator;installerbase;repogen")
+		foreach(S IN LISTS TOOLS)
+			message("...${S}")
+			file(DOWNLOAD ${OPM_URL}/qtifw-2.0.0-osx/${S} cmake/qtifw/${S})
+			execute_process(COMMAND chmod +x ${S} WORKING_DIRECTORY cmake/qtifw)
+		endforeach()
+    endif()
+endif()
 
-#set the default configuration for packages
-set(PACK_EXAMPLES false CACHE INTERNAL "")
-set(PACK_CORE_EQUALIZER true CACHE INTERNAL "")
-set(PACK_CORE_UI true CACHE INTERNAL "")
-
-#include file with functions used by packaging scripts
-include("${ARG2}/src/pack_functions.cmake")
+# Delete the local repositoryor the repogen command will fail
+#file(REMOVE_RECURSE ${ARG2}/install/repository)
 
-# pack the application and all its dependencies
-pack_module(${ARG3} ${APP_DIR})
-message(${PACK_CORE_EQUALIZER})
-# pack the omegalib runtime core
-include("${ARG2}/src/pack_core.cmake")
+message("---- Building offline installer")
+if(WIN32)
+    execute_process(COMMAND ${CALLING_DIR}/cmake/qtifw/binarycreator.exe 
+        -c config/config-offline.xml -p packages ${ARG3}Setup.exe
+        WORKING_DIRECTORY ${CALLING_DIR}/packs/${ARG3})
+else()
+    execute_process(COMMAND ${CALLING_DIR}/cmake/qtifw/binarycreator
+        -c config/config-offline.xml -p packages ${ARG3}Setup
+        WORKING_DIRECTORY ${CALLING_DIR}/packs/${ARG3})
+endif()