Applets: NAP applications inside Napkin

cmake/framework_release_packaging.cmake

@@ -766,5 +766,9 @@ function(package_path_mappings)
     install(DIRECTORY ${NAP_ROOT}/tools/buildsystem/path_mappings/${MAPPINGS_PREFIX}/
             DESTINATION tools/buildsystem/path_mappings
             PATTERN "source.json" EXCLUDE)
+
+    install(DIRECTORY ${NAP_ROOT}/tools/buildsystem/path_mappings/applet
+            DESTINATION tools/buildsystem/path_mappings
+            PATTERN "framework_release.json" EXCLUDE)
 endfunction()
 

cmake/install_napkin_with_app.cmake

@@ -5,7 +5,17 @@ endif()
 include(${CMAKE_CURRENT_LIST_DIR}/macros_and_functions.cmake)
 
 # NAP modules which Napkin uses (as a minimum)
-set(NAPKIN_DEPENDENT_NAP_MODULES napscene napmath)
+set(NAPKIN_DEPENDENT_NAP_MODULES napscene
+        napcolor
+        napfont
+        naprender
+        napcameracontrol
+        napapp
+        napinput
+        napsdlinput
+        napimgui
+        napapi
+        naprenderadvanced)
 
 # Qt frameworks which Napkin uses
 set(NAPKIN_QT_INSTALL_FRAMEWORKS QtCore QtGui QtWidgets QtOpenGL)
@@ -24,10 +34,21 @@ if(pybind11_FOUND)
 endif()
 
 if(WIN32)
-    add_custom_command(TARGET ${PROJECT_NAME}
-                       POST_BUILD
-                       COMMAND ${CMAKE_COMMAND} -E copy_directory "${NAP_ROOT}/tools/napkin" "$<TARGET_FILE_DIR:${PROJECT_NAME}>/napkin"
-                       COMMENT "Copy Napkin")
+    # Copy napkin directory -> exclude path mapping
+    install(DIRECTORY ${NAP_ROOT}/tools/napkin/
+        DESTINATION napkin
+        PATTERN "*/path_mapping.json" EXCLUDE
+        PATTERN "*/napkin.ini" EXCLUDE)
+
+    # Napkin has dependencies the application might not have -> we must include the (shared) data for those.
+    # For example: renderadvanced is required by Napkin but not by most demos -> it requires those shaders to run
+    foreach(NAP_MODULE ${NAPKIN_DEPENDENT_NAP_MODULES})
+        set(MODULE_EXTRA_CMAKE_PATH ${NAP_ROOT}/system_modules/${NAP_MODULE}/module_extra.cmake)
+        if(EXISTS ${MODULE_EXTRA_CMAKE_PATH})
+            include(${MODULE_EXTRA_CMAKE_PATH})
+        endif()
+    endforeach()
+
 elseif(APPLE)
     list(APPEND NAPKIN_QT_INSTALL_FRAMEWORKS QtDBus)
 
@@ -123,5 +144,10 @@ else()
     unset(INSTALLING_MODULE_FOR_NAPKIN)
 endif()
 
+# Install path mapping for applets running in packaged app context
+install(FILES ${NAP_ROOT}/tools/buildsystem/path_mappings/applet/packaged_app.json
+    DESTINATION napkin/resources/applets
+    RENAME path_mapping.json)
+
 # Install Qt licenses into packaged app
 install(DIRECTORY ${THIRDPARTY_DIR}/Qt/licenses/ DESTINATION licenses/Qt)

cmake/version.cmake

@@ -1,6 +1,6 @@
 set(NAP_MAJOR_VERSION 0)
-set(NAP_MINOR_VERSION 7)
-set(NAP_PATCH_VERSION 7)
+set(NAP_MINOR_VERSION 8)
+set(NAP_PATCH_VERSION 0)
 set(NAP_VERSION "${NAP_MAJOR_VERSION}.${NAP_MINOR_VERSION}.${NAP_PATCH_VERSION}")
 # Be careful updating this as it's currently parsed during packaging by package.py
 message(STATUS "NAP version: ${NAP_VERSION}")

core/CMakeLists.txt

@@ -18,21 +18,21 @@ if(APPLE)
                 src/nap/osx/directorywatcher.cpp
                 src/nap/osx/module.cpp
                 src/nap/osx/core_env.cpp
-                src/nap/native/modulemanager_ext.cpp
                 src/nap/native/logger_ext.cpp
                 src/nap/native/core_ext.cpp
                 src/nap/native/resourcemanager_ext.cpp
+                src/nap/native/modulecache_ext.cpp
                 )
 elseif(MSVC)
     add_library(${PROJECT_NAME} SHARED 
                 ${SOURCES}
                 src/nap/win32/directorywatcher.cpp
                 src/nap/win32/module.cpp
                 src/nap/win32/core_env.cpp
-                src/nap/native/modulemanager_ext.cpp
                 src/nap/native/logger_ext.cpp
                 src/nap/native/core_ext.cpp
                 src/nap/native/resourcemanager_ext.cpp
+                src/nap/native/modulecache_ext.cpp
                 )
 elseif(UNIX)
     file(GLOB FILEWATCHER_SOURCES
@@ -44,10 +44,10 @@ elseif(UNIX)
                 src/nap/linux/directorywatcher.cpp
                 src/nap/linux/module.cpp
                 src/nap/linux/core_env.cpp
-                src/nap/native/modulemanager_ext.cpp
                 src/nap/native/logger_ext.cpp
                 src/nap/native/core_ext.cpp
                 src/nap/native/resourcemanager_ext.cpp
+                src/nap/native/modulecache_ext.cpp
                 )
 endif()
 

core/src/nap/core.cpp

@@ -40,7 +40,7 @@ namespace nap
 		// Initialize timer
 		mTimer.reset();
 		mResourceManager = std::make_unique<ResourceManager>(*this);
-		mModuleManager = std::make_unique<ModuleManager>(*this);
+		mModuleManager = std::make_unique<ModuleManager>();
 	}
 
 
@@ -89,11 +89,6 @@ namespace nap
 		if (!loadProjectInfo(projectInfofile, context, error))
 			return false;
 
-		// Ensure our current working directory is where the executable is.
-		// Works around issues with the current working directory not being set as
-		// expected when apps are launched directly from macOS Finder and probably other things too.
-		nap::utility::changeDir(nap::utility::getExecutableDir());
-
 		// Setup our Python environment
 #ifdef NAP_ENABLE_PYTHON
 		setupPythonEnvironment();
@@ -443,6 +438,7 @@ namespace nap
 			return false;
 
 		// Initialize it
+		nap::Logger::debug("Initializing project '%s'", mProjectInfo->mTitle.c_str());
 		if (!mProjectInfo->init(projectFilename, context, err))
 		{
 			err.fail("Failed to initialize project");

core/src/nap/core.h

@@ -265,6 +265,15 @@ namespace nap
 		template <typename T>
 		const T& getExtension() const;
 
+		/**
+		 * Returns the extension associated with this instance of core as T. 
+		 * Note that an extension is given explicitly to core on construction.
+		 * When using the default constructor core has no interface associated with it!
+		 * @return extension associated with core as type T
+		 */
+		template <typename T>
+		T& getExtension();
+
 		/**
 		 * @return if core has an extension of type T	
 		 */
@@ -520,6 +529,18 @@ const T& nap::Core::getExtension() const
 }
 
 
+/**
+ * Returns the core extension as an extension of type T
+ */
+template <typename T>
+T& nap::Core::getExtension()
+{
+	T* core_ext = rtti_cast<T>(mExtension.get());
+	assert(core_ext != nullptr);
+	return *core_ext;
+}
+
+
 /**
  * Returns if core has an extension of type T
  */

core/src/nap/event.h

@@ -31,4 +31,5 @@ namespace nap
 	 * Most events are wrapped in a unique pointer to manage lifetime automatically
 	 */
 	using EventPtr = std::unique_ptr<nap::Event>;
+	using EventPtrList = std::vector<EventPtr>;
 }

core/src/nap/linux/module.cpp

@@ -4,26 +4,59 @@
 
 // Local Includes
 #include <nap/module.h>
+#include <nap/logger.h>
 
 // External Includes
-#include <utility/fileutils.h>
-#include <assert.h>
 #include <dlfcn.h> // Posix shared object loading
+#include <linux/limits.h>
 
 namespace nap
 {
 	void initModules()
 	{ }
 
 
- 	void* loadModule(const nap::ModuleInfo& modInfo, const std::string& modulePath, std::string& errorString)
+ 	void* loadModule(const nap::ModuleInfo& modInfo, const std::string& library, std::string& outLocation, std::string& errorString)
 	{
-		// If we failed to load the module, get the error string
-		void* result = dlopen(modulePath.c_str(), RTLD_LAZY);
-		if (result == nullptr)
-			errorString = dlerror();
+		// Attempt to load the library using default OS system mapping
+		// If that fails attempt to locate it using library search paths
+		void* handle = dlopen(library.c_str(), RTLD_LAZY);
+		if (handle == nullptr)
+		{
+			for (const auto& path : modInfo.mLibSearchPaths)
+			{
+				// Find it
+				std::string full_path = utility::forceSeparator(utility::stringFormat("%s/%s",
+					path.c_str(), library.c_str()));
+				if (!utility::fileExists(full_path))
+					continue;
 
-		return result;
+				// Load it
+				Logger::debug("Explicitly loading library: %s", full_path.c_str());
+				handle = dlopen(full_path.c_str(), RTLD_LAZY);
+				if (handle != nullptr)
+					break;
+			}
+		}
+
+		// Ensure we have a handle
+		if (handle == nullptr)
+		{
+			errorString = utility::stringFormat("dlopen for library '%s' failed:\n%s", library.c_str(), dlerror());
+			return nullptr;
+		}
+
+		// Get library load origin
+		char path[PATH_MAX];
+		if (dlinfo(handle, RTLD_DI_ORIGIN, &path) == -1)
+		{
+			errorString = utility::stringFormat("origin resolve for '%s' failed:\n%s", library.c_str(), dlerror());
+			return nullptr;
+		}
+
+		// Set out location
+		outLocation = path;
+		return handle;
 	}
 
 

core/src/nap/logger.cpp

@@ -126,6 +126,7 @@ namespace nap
 		: LogHandler(),  mFilename(mFilename)
 	{
 		// Set the default formatter to use a timestamp
+		setLogLevel(Logger::debugLevel());
 		setFormatter(&timestampLogMessageFormatter);
 
 		// Kick off the writing thread
@@ -144,8 +145,8 @@ namespace nap
 
 	FileLogHandler::~FileLogHandler()
 	{
-		mRunning = false;
 		// Wait for the stream to close
+		mRunning = false;
 		if (mWriteThread->joinable())
 			mWriteThread->join();
 	}

core/src/nap/logger.h

@@ -305,12 +305,13 @@ namespace nap
 
 
 	/**
-	 * Log handler that will print to the console
+	 * Log handler that will print to the console.
+	 * By default, messages with an info level and higher are included.
 	 */
 	class ConsoleLogHandler : public LogHandler
 	{
 	public:
-		ConsoleLogHandler() = default;
+		ConsoleLogHandler() { setLogLevel(Logger::infoLevel()); }
 
 		/**
 		 * Write the contents to the outputstream
@@ -324,15 +325,16 @@ namespace nap
 
 	/**
 	 * Log handler that will write log messages to a file.
+	 * By default, messages with a debug level and higher are included.
 	 * Upon construction, it will open a file stream to write to
 	 * and will remain open for the lifetime of the handler.
-	 * The file writer runs another thread to keep the call site unburdened
+	 * The file writer runs another thread to keep the call site unburdened.
 	 */
 	class FileLogHandler : public LogHandler
 	{
 	public:
 		FileLogHandler(const std::string& mFilename);
-		~FileLogHandler();
+		~FileLogHandler() override;
 
 		/**
 		 * Write a message to the provided file

core/src/nap/module.h

@@ -18,11 +18,12 @@ namespace nap
 	/**
 	 * Platform-wrapper function to load a shared library
 	 * @param modInfo The moduleInfo, used to add additional dll search paths
-	 * @param modulePath The path to the shared library to load
-	 * @param errorString If the module failed to load, the error string
+	 * @param library The name of the library to load, including extension
+	 * @param outLocation the location the loaded module, if loading succeeds
+	 * @param error Holds the error if loading fails
 	 * @return Handle to the loaded module
 	 */
-	NAPAPI void* loadModule(const nap::ModuleInfo& modInfo, const std::string& modulePath, std::string& errorString);
+	NAPAPI void* loadModule(const nap::ModuleInfo& modInfo, const std::string& library, std::string& outLocation, std::string& error);
 
 	/**
 	 * Platform-wrapper function to unload a shared library

core/src/nap/modulecache.cpp

@@ -0,0 +1,79 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// Local includes
+#include "modulecache.h"
+#include "module.h"
+
+// External includes
+#include <utility/fileutils.h>
+
+namespace nap
+{
+	//////////////////////////////////////////////////////////////////////////
+	// Module
+	//////////////////////////////////////////////////////////////////////////
+
+	std::string Module::findAsset(const std::string& name) const
+	{
+		return utility::findFileInDirectories(name, this->getInformation().mDataSearchPaths);
+	}
+
+
+	//////////////////////////////////////////////////////////////////////////
+	// Module Cache
+	//////////////////////////////////////////////////////////////////////////
+
+	ModuleCache::Handle::Handle(nap::ModuleCache& cache, std::mutex& mutex) : mLock(mutex),
+		mCache(&cache)
+	{ }
+
+
+	ModuleCache::Handle::Handle(Handle&& other) noexcept
+	{
+		mLock = std::move(other.mLock);
+		mCache = std::move(other.mCache);
+	}
+
+
+	nap::ModuleCache::Handle& ModuleCache::Handle::operator=(Handle&& other) noexcept
+	{
+		mLock = std::move(other.mLock);
+		mCache = std::move(other.mCache);
+		return *this;
+	}
+
+
+	nap::ModuleCache::Handle ModuleCache::getHandle()
+	{
+		// Create unique cache, local to unit
+		static ModuleCache cache;
+		static std::mutex mutex;
+		static std::once_flag init_flag;
+
+		// Platform specific initialization
+		std::call_once(init_flag, [&]() {
+				initModules();
+			});
+
+		// Create cache handle, lock and return
+		return ModuleCache::Handle(cache, mutex);
+	}
+
+
+	const nap::Module* ModuleCache::findModule(const std::string& moduleName) const
+	{
+		auto found_it = std::find_if(mModules.begin(), mModules.end(), [&](const auto& it) {
+			return it->mName == moduleName;
+			});
+		return found_it == mModules.end() ? nullptr : found_it->get();
+	}
+
+
+	const nap::Module* ModuleCache::Handle::sourceModule(const ProjectInfo& projectinfo, const std::string& moduleName, utility::ErrorState& err)
+	{
+		assert(mCache != nullptr);
+		return mCache->sourceModule(projectinfo, moduleName, err);
+	}
+}