Allow opening projects through Tesseratos

CHANGELOG.md

@@ -25,6 +25,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Cascaded shadow maps (#1187, **@tomas7770**).
 - Global telemetry level (for tracing/logging) (#1265, **@roby2014**).
 - Spans for tracing and profiling (#1265, **@roby2014**).
+- Simple cross-platform multi-process utilities (**@RiscadoA**).
+- Project opening and closing on Tesseratos (#1218, **@RiscadoA**).
 
 ### Changed
 

core/CMakeLists.txt

@@ -33,6 +33,7 @@ set(CUBOS_CORE_SOURCE
 	"src/tel/level.cpp"
 
 	"src/thread/pool.cpp"
+	"src/thread/process.cpp"
 	"src/thread/task.cpp"
 
 	"src/memory/stream.cpp"

core/include/cubos/core/data/fs/standard_archive.hpp

@@ -35,6 +35,10 @@ namespace cubos::core::data
         /// @param readOnly True if the archive is read-only, false otherwise.
         StandardArchive(const std::filesystem::path& osPath, bool isDirectory, bool readOnly);
 
+        /// @brief Checks if the archive was successfully initialized.
+        /// @return True if the archive was successfully initialized, false otherwise.
+        bool initialized() const;
+
         std::size_t create(std::size_t parent, std::string_view name, bool directory = false) override;
         bool destroy(std::size_t id) override;
         std::string name(std::size_t id) const override;

core/include/cubos/core/thread/process.hpp

@@ -0,0 +1,58 @@
+/// @file
+/// @brief Class @ref cubos::core::thread::Process.
+/// @ingroup core-thread
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <cubos/core/reflection/reflect.hpp>
+
+namespace cubos::core::thread
+{
+    /// @brief Provides a cross-platform way to spawn child processes.
+    /// @ingroup core-thread
+    class Process final
+    {
+    public:
+        CUBOS_REFLECT;
+
+        ~Process();
+
+        /// @brief Default constructor.
+        Process() = default;
+
+        /// @brief Move constructor.
+        Process(Process&& other) noexcept;
+
+        /// @brief Move assignment operator.
+        Process& operator=(Process&& other) noexcept;
+
+        /// @brief Starts a new process.
+        /// @param command Command to execute.
+        /// @param args Arguments to pass to the command.
+        /// @param cwd Working directory for the new process.
+        /// @return Whether the process was started successfully.
+        bool start(const std::string& command, const std::vector<std::string>& args = {}, const std::string& cwd = "");
+
+        /// @brief Kills the process.
+        void kill();
+
+        /// @brief Waits for the process to finish.
+        /// @return Whether the process exited normally.
+        bool wait();
+
+        /// @brief Waits for the process to finish.
+        /// @param status Exit code of the process, if it exited normally.
+        /// @return Whether the process exited normally.
+        bool wait(int& status);
+
+        /// @brief Checks whether the process has been started.
+        /// @return Whether the process has been started.
+        bool started() const;
+
+    private:
+        void* mHandle{nullptr};
+    };
+} // namespace cubos::core::thread

core/include/cubos/core/thread/task.hpp

@@ -29,6 +29,15 @@ namespace cubos::core::thread
             mData = new Data();
         }
 
+        /// @brief Constructs a finished task.
+        /// @param value Task result.
+        /// @return Task.
+        Task(T value)
+            : Task{}
+        {
+            this->finish(std::move(value));
+        }
+
         /// @brief Copy constructs.
         /// @param other Task.
         Task(const Task& other)

core/src/data/fs/standard_archive.cpp

@@ -109,6 +109,11 @@ void StandardArchive::generate(std::size_t parent)
     }
 }
 
+bool StandardArchive::initialized() const
+{
+    return !mFiles.empty();
+}
+
 std::size_t StandardArchive::create(std::size_t parent, std::string_view name, bool directory)
 {
     INIT_OR_RETURN(0);

core/src/thread/process.cpp

@@ -0,0 +1,197 @@
+#include <cubos/core/reflection/external/cstring.hpp>
+#include <cubos/core/reflection/external/primitives.hpp>
+#include <cubos/core/reflection/external/string.hpp>
+#include <cubos/core/reflection/traits/constructible.hpp>
+#include <cubos/core/reflection/type.hpp>
+#include <cubos/core/tel/logging.hpp>
+#include <cubos/core/thread/process.hpp>
+
+using cubos::core::thread::Process;
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#else
+#include <csignal>
+#include <cstring>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+
+CUBOS_REFLECT_IMPL(Process)
+{
+    return reflection::Type::create("cubos::core::thread::Process")
+        .with(reflection::ConstructibleTrait::typed<Process>().withDefaultConstructor().withMoveConstructor().build());
+}
+
+Process::~Process()
+{
+    this->kill();
+    this->wait();
+}
+
+Process::Process(Process&& other) noexcept
+    : mHandle{other.mHandle}
+{
+    other.mHandle = nullptr;
+}
+
+Process& Process::operator=(Process&& other) noexcept
+{
+    if (this == &other)
+    {
+        return *this;
+    }
+
+    this->wait();
+    mHandle = other.mHandle;
+    other.mHandle = nullptr;
+    return *this;
+}
+
+bool Process::start(const std::string& command, const std::vector<std::string>& args, const std::string& cwd)
+{
+    this->wait();
+
+#ifdef _WIN32
+    // Launch the binary with appropriate arguments.
+    std::string finalCommand = command;
+    for (const auto& arg : args)
+    {
+        finalCommand += " " + arg;
+    }
+    STARTUPINFOA si = {sizeof(si)};
+    PROCESS_INFORMATION pi;
+    if (!CreateProcessA(nullptr, const_cast<char*>(finalCommand.c_str()), nullptr, nullptr, FALSE, 0, nullptr,
+                        cwd.empty() ? nullptr : cwd.c_str(), &si, &pi))
+    {
+        CUBOS_ERROR("Failed to start process {} with error {}", command, GetLastError());
+        return false;
+    }
+
+    mHandle = new PROCESS_INFORMATION{pi};
+    CUBOS_INFO("Started process {} with PID {}", command, pi.dwProcessId);
+#else
+    auto pid = fork();
+    if (pid == -1)
+    {
+        CUBOS_ERROR("Failed to fork process");
+        return false;
+    }
+
+    if (pid == 0) // Are we the child process?
+    {
+        if (!cwd.empty())
+        {
+            // Change the working directory.
+            if (chdir(cwd.c_str()) == -1)
+            {
+                CUBOS_CRITICAL("Failed to change working directory to {}", cwd);
+                exit(1);
+            }
+        }
+
+        // Launch the binary with appropriate arguments.
+        std::vector<std::string> argsCopy = args;
+        argsCopy.insert(argsCopy.begin(), command);
+        std::vector<char*> argv{};
+        argv.reserve(argsCopy.size() + 1);
+        for (const auto& arg : argsCopy)
+        {
+            argv.push_back(const_cast<char*>(arg.c_str()));
+        }
+        argv.push_back(nullptr);
+        execvp(command.c_str(), argv.data());
+
+        // If we reach this point, execv failed. Get the error message and log it.
+        CUBOS_CRITICAL("Failed to start process {} with error {}", command, strerror(errno));
+        exit(1);
+    }
+
+    // We are the parent process.
+    mHandle = new pid_t{pid};
+    CUBOS_INFO("Started process {} with PID {}", command, pid);
+#endif
+
+    return true;
+}
+
+void Process::kill()
+{
+    if (mHandle == nullptr)
+    {
+        return;
+    }
+
+#ifdef _WIN32
+    auto* pi = static_cast<PROCESS_INFORMATION*>(mHandle);
+    ::TerminateProcess(pi->hProcess, 1);
+    CUBOS_DEBUG("Process {} killed", pi->dwProcessId);
+#else
+    auto* pid = static_cast<pid_t*>(mHandle);
+    ::kill(*pid, SIGKILL);
+    CUBOS_DEBUG("Process {} killed", *pid);
+#endif
+}
+
+bool Process::wait()
+{
+    int status;
+    return this->wait(status);
+}
+
+bool Process::wait(int& status)
+{
+    if (mHandle == nullptr)
+    {
+        return false;
+    }
+
+#ifdef _WIN32
+    auto* pi = static_cast<PROCESS_INFORMATION*>(mHandle);
+    mHandle = nullptr;
+
+    ::WaitForSingleObject(pi->hProcess, INFINITE);
+
+    DWORD exitCode;
+    GetExitCodeProcess(pi->hProcess, &exitCode);
+    status = static_cast<int>(exitCode);
+    CUBOS_DEBUG("Process {} exited with status {}", pi->dwProcessId, status);
+
+    ::CloseHandle(pi->hProcess);
+    ::CloseHandle(pi->hThread);
+    delete pi;
+
+    return true;
+#else
+    auto pid = *static_cast<pid_t*>(mHandle);
+    delete static_cast<pid_t*>(mHandle);
+    mHandle = nullptr;
+
+    int waitStatus;
+    ::waitpid(pid, &waitStatus, 0);
+
+    if (WIFEXITED(waitStatus))
+    {
+        status = WEXITSTATUS(waitStatus);
+        CUBOS_DEBUG("Process {} exited with status {}", pid, status);
+        return true;
+    }
+
+    if (WIFSIGNALED(waitStatus))
+    {
+        CUBOS_WARN("Process {} terminated by signal {}", pid, WTERMSIG(waitStatus));
+        return false;
+    }
+
+    CUBOS_WARN("Process {} terminated abnormally", pid);
+    return false;
+#endif
+}
+
+bool Process::started() const
+{
+    return mHandle != nullptr;
+}

core/tests/data/fs/standard_archive.cpp

@@ -16,6 +16,7 @@ using cubos::core::memory::Stream;
 static void assertInitializationFailed(StandardArchive& archive)
 {
     REQUIRE_FALSE(archive.directory(1)); // Independently of it was created as a directory or not.
+    REQUIRE_FALSE(archive.initialized());
     REQUIRE(archive.parent(1) == 0);
     REQUIRE(archive.sibling(1) == 0);
     REQUIRE(archive.child(1) == 0);
@@ -62,6 +63,7 @@ TEST_CASE("data::StandardArchive") // NOLINT(readability-function-size)
 
         // Check if the structure is correct.
         CHECK(archive.readOnly() == readOnly);
+        CHECK(archive.initialized());
         CHECK(archive.parent(1) == 0);
         CHECK(archive.sibling(1) == 0);
         CHECK(archive.child(1) == 0);
@@ -133,6 +135,7 @@ TEST_CASE("data::StandardArchive") // NOLINT(readability-function-size)
         {
             archive = std::make_unique<StandardArchive>(path, true, false);
             CHECK_FALSE(archive->readOnly());
+            CHECK(archive->initialized());
 
             // Check initial structure.
             CHECK(archive->parent(1) == 0);
@@ -220,6 +223,7 @@ TEST_CASE("data::StandardArchive") // NOLINT(readability-function-size)
             // Create a read-only archive on the generated directory.
             archive = std::make_unique<StandardArchive>(path, true, true);
             CHECK(archive->readOnly());
+            CHECK(archive->initialized());
 
             // Check root.
             CHECK(archive->directory(1));

core/tests/thread/task.cpp

@@ -10,6 +10,13 @@ using cubos::core::thread::Task;
 
 TEST_CASE("thread::Task")
 {
+    SUBCASE("finished task")
+    {
+        Task<int> task{42};
+        REQUIRE(task.isDone());
+        REQUIRE(task.result() == 42);
+    }
+
     SUBCASE("task which produces an int")
     {
         Task<int> task{};

engine/include/cubos/engine/assets/assets.hpp

@@ -98,6 +98,14 @@ namespace cubos::engine
         /// @param path Path to load metadata from.
         void loadMeta(std::string_view path);
 
+        /// @brief Unloads all asset metadata from assets within the given path.
+        ///
+        /// If an asset from the given path is currently loaded, it will not be unloaded, but it will be dissociated
+        /// from its original metadata path.
+        ///
+        /// @param path Path to unload metadata from.
+        void unloadMeta(std::string_view path);
+
         /// @brief Loads the asset with the given handle, upgrading the handle to a strong one.
         ///
         /// This method doesn't block, thus the asset may have not yet been loaded when it returns.

engine/include/cubos/engine/collisions/shapes/box.hpp

@@ -19,6 +19,6 @@ namespace cubos::engine
 
         cubos::core::geom::Box box; ///< Box shape.
 
-        bool changed = true;
+        bool changed{true};
     };
 } // namespace cubos::engine