Changeset 5626

Timestamp:

Aug 11, 2009, 10:22:55 PM (15 years ago)

Author:

landauf

Message:

Added a dynamic library loader (more or less a copy of Ogre::DynLibManager but with some adjustments for Orxonox). This allows us to load plugins at runtime. Plugin-libraries must be declared with the "PLUGIN" switch in ORXONOX_ADD_LIBRARY in CMake.

Location:

code/branches/libraries

Files:

• cmake/BuildConfig.cmake (modified) (1 diff)
• cmake/TargetUtilities.cmake (modified) (6 diffs)
• src/SpecialConfig.h.in (modified) (1 diff)
• src/core/CMakeLists.txt (modified) (1 diff)
• src/core/Core.cc (modified) (4 diffs)
• src/core/Core.h (modified) (1 diff)
• src/core/CorePrereqs.h (modified) (1 diff)
• src/core/DynLib.cc (added)
• src/core/DynLib.h (added)
• src/core/DynLibManager.cc (added)
• src/core/DynLibManager.h (added)

code/branches/libraries/cmake/BuildConfig.cmake

@@ -172 +172 @@
 # when building, don't use the install RPATH already
 # (but later on when installing)
-SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) 
+SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
 
 # the RPATH to be used when installing

code/branches/libraries/cmake/TargetUtilities.cmake

@@ -35 +35 @@
  #      NO_SOURCE_GROUPS:  Don't create msvc source groups
  #      STATIC/SHARED:     Inherited from ADD_LIBRARY
+ #      PLUGIN:            For dynamic plugin libraries
  #      WIN32:             Inherited from ADD_EXECUTABLE
  #      PCH_NO_DEFAULT:    Do not make precompiled header files default if
@@ -80 +81 @@
   SET(_switches   FIND_HEADER_FILES  EXCLUDE_FROM_ALL  ORXONOX_EXTERNAL
                   NO_DLL_INTERFACE   NO_SOURCE_GROUPS  ${_additional_switches}
-                  PCH_NO_DEFAULT NO_INSTALL)
+                  PCH_NO_DEFAULT     NO_INSTALL        PLUGIN)
   SET(_list_names LINK_LIBRARIES  VERSION   SOURCE_FILES  DEFINE_SYMBOL
                   TOLUA_FILES     PCH_FILE  PCH_EXCLUDE OUTPUT_NAME)
@@ -147 +148 @@
   ENDIF()
 
+  # PLUGIN A
+  IF(_arg_PLUGIN)
+    SET(_arg_PLUGIN MODULE)
+    SET(_arg_SHARED)
+    SET(_arg_STATIC)
+  ENDIF()
+
   # Add the library/executable
   IF("${_target_type}" STREQUAL "LIBRARY")
-    ADD_LIBRARY(${_target_name} ${_arg_STATIC} ${_arg_SHARED}
+    ADD_LIBRARY(${_target_name} ${_arg_STATIC} ${_arg_SHARED} ${_arg_PLUGIN}
                 ${_arg_EXCLUDE_FROM_ALL} ${_${_target_name}_files})
   ELSE()
     ADD_EXECUTABLE(${_target_name} ${_arg_WIN32} ${_arg_EXCLUDE_FROM_ALL}
                    ${_${_target_name}_files})
+  ENDIF()
+
+  # PLUGIN B
+  IF (_arg_PLUGIN)
+    SET_TARGET_PROPERTIES(${_target_name} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_PLUGIN_OUTPUT_DIRECTORY})
+    SET_TARGET_PROPERTIES(${_target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_PLUGIN_OUTPUT_DIRECTORY})
+    ADD_PLUGIN(${_target_name})
   ENDIF()
 
@@ -174 +189 @@
 
   # OUTPUT_NAME
-  IF(_arg_OUTPUT_NAME )
+  IF(_arg_OUTPUT_NAME)
     SET_TARGET_PROPERTIES(${_target_name} PROPERTIES OUTPUT_NAME  ${_arg_OUTPUT_NAME})
   ENDIF()
@@ -184 +199 @@
 
   IF(NOT _arg_STATIC AND NOT _arg_NO_INSTALL)
+    SET(_library_destination ${ORXONOX_LIBRARY_INSTALL_PATH})
+    IF (_arg_PLUGIN)
+      SET(_library_destination ${ORXONOX_PLUGIN_INSTALL_PATH})
+    ENDIF()
+
     INSTALL(TARGETS ${_target_name}
       RUNTIME DESTINATION ${ORXONOX_RUNTIME_INSTALL_PATH}
-      LIBRARY DESTINATION ${ORXONOX_LIBRARY_INSTALL_PATH}
+      LIBRARY DESTINATION ${_library_destination}
       #ARCHIVE DESTINATION ${ORXONOX_ARCHIVE_INSTALL_PATH}
     )
@@ -192 +212 @@
 
 ENDFUNCTION(TU_ADD_TARGET)
+
+
+# Creates a helper file with name <name_of_the_library>.plugin
+# This helps finding dynamically loadable plugins at runtime
+
+FUNCTION(ADD_PLUGIN _name)
+  # We use the properties to get the name because the librarys name may differ from
+  # the targets name (for example orxonox <-> liborxonox)
+
+  GET_TARGET_PROPERTY(_target_loc ${_name} LOCATION)
+  GET_FILENAME_COMPONENT(_target_name ${_target_loc} NAME_WE)
+
+  SET(_plugin_filename "${CMAKE_PLUGIN_OUTPUT_DIRECTORY}/${_target_name}.plugin")
+
+  FILE(WRITE ${_plugin_filename})
+
+  INSTALL(
+    FILES ${_plugin_filename}
+    DESTINATION ${ORXONOX_PLUGIN_INSTALL_PATH}
+  )
+ENDFUNCTION(ADD_PLUGIN)

code/branches/libraries/src/SpecialConfig.h.in

@@ -87 +87 @@
     const char ORXONOX_LOG_DEV_PATH[]         = "@CMAKE_LOG_OUTPUT_DIRECTORY@/"    BOOST_PP_STRINGIZE(CMAKE_BUILD_TYPE);
 #else
+    const char ORXONOX_PLUGIN_DEV_PATH[]      = "@CMAKE_PLUGIN_OUTPUT_DIRECTORY@";
     const char ORXONOX_CONFIG_DEV_PATH[]      = "@CMAKE_CONFIG_OUTPUT_DIRECTORY@";
     const char ORXONOX_LOG_DEV_PATH[]         = "@CMAKE_LOG_OUTPUT_DIRECTORY@";

code/branches/libraries/src/core/CMakeLists.txt

@@ -23 +23 @@
   ConfigValueContainer.cc
   Core.cc
+  DynLib.cc
+  DynLibManager.cc
   Event.cc
   Game.cc

code/branches/libraries/src/core/Core.cc

@@ -40 +40 @@
 #include <cstdlib>
 #include <cstdio>
+#include <boost/version.hpp>
 #include <boost/filesystem.hpp>
 #include <OgreRenderWindow.h>
@@ -68 +69 @@
 #include "ConfigValueIncludes.h"
 #include "CoreIncludes.h"
+#include "DynLibManager.h"
 #include "Factory.h"
 #include "GameMode.h"
@@ -80 +82 @@
 #include "input/InputManager.h"
 
+// Boost 1.36 has some issues with deprecated functions that have been omitted
+#if (BOOST_VERSION == 103600)
+#  define BOOST_LEAF_FUNCTION filename
+#else
+#  define BOOST_LEAF_FUNCTION leaf
+#endif
+
 namespace orxonox
 {
@@ -260 +269 @@
         this->setFixedPaths();
 
-        // TODO: Load plugins
+        // Create a new dynamic library manager
+        this->dynLibManager_.reset(new DynLibManager());
+
+        // Load plugins
+        try
+        {
+            // We search for helper files with the following extension
+            std::string pluginextension = ".plugin";
+            size_t pluginextensionlength = pluginextension.size();
+
+            // Search in the directory of our executable
+            boost::filesystem::path searchpath = this->getRootPath() / ORXONOX_PLUGIN_INSTALL_PATH;
+
+            boost::filesystem::directory_iterator file(searchpath);
+            boost::filesystem::directory_iterator end;
+
+            // Iterate through all files
+            while (file != end)
+            {
+                std::string filename = file->BOOST_LEAF_FUNCTION();
+
+                // Check if the file ends with the exension in question
+                if (filename.size() > pluginextensionlength)
+                {
+                    if (filename.substr(filename.size() - pluginextensionlength) == pluginextension)
+                    {
+                        // We've found a helper file - now load the library with the same name
+                        std::string library = filename.substr(0, filename.size() - pluginextensionlength);
+                        boost::filesystem::path librarypath = searchpath / library;
+
+                        this->dynLibManager_->load(librarypath.string());
+                    }
+                }
+
+                ++file;
+            }
+        }
+        catch (const std::exception& e)
+        {
+            COUT(1) << "An error occurred while loading plugins: " << e.what() << std::endl;
+        }
+        catch (...)
+        {
+            COUT(1) << "An error occurred while loading plugins." << std::endl;
+        }
 
         // Parse command line arguments AFTER the plugins have been loaded (static code!)

code/branches/libraries/src/core/Core.h

@@ -119 +119 @@
 
             // Mind the order for the destruction!
+            scoped_ptr<DynLibManager>     dynLibManager_;
             scoped_ptr<SignalHandler>     signalHandler_;
             SimpleScopeGuard              identifierDestroyer_;

code/branches/libraries/src/core/CorePrereqs.h

@@ -112 +112 @@
     class ConsoleCommand;
     class Core;
+    class DynLib;
+    class DynLibManager;
     struct Event;
     class EventContainer;