nv-sgl 0.6.0__cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

sgl/include/sgl/core/enum.h

@@ -0,0 +1,201 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/error.h"
+#include "sgl/core/format.h"
+
+#include <span>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <algorithm>
+#include <vector>
+#include <concepts>
+
+namespace sgl {
+
+// Helper using ADL to find EnumInfo in other namespaces.
+template<typename T>
+using EnumInfo = decltype(find_enum_info_adl(std::declval<T>()));
+
+template<typename T>
+concept has_enum_info = requires(T v) {
+    {
+        EnumInfo<T>::name()
+    } -> std::same_as<const std::string&>;
+    {
+        EnumInfo<T>::items()
+    } -> std::same_as<std::span<std::pair<T, std::string>>>;
+};
+
+/**
+ * Convert an enum value to a string.
+ * Throws if the enum value is not found in the registered enum information.
+ */
+template<has_enum_info T>
+inline const std::string& enum_to_string(T value)
+{
+    const auto& items = EnumInfo<T>::items();
+    auto it = std::find_if(items.begin(), items.end(), [value](const auto& item) { return item.first == value; });
+    if (it == items.end())
+        SGL_THROW("Invalid enum value {}", int(value));
+    return it->second;
+}
+
+/**
+ * Convert a string to an enum value.
+ * Throws if the string is not found in the registered enum information.
+ */
+template<has_enum_info T>
+inline T string_to_enum(std::string_view name)
+{
+    const auto& items = EnumInfo<T>::items();
+    auto it = std::find_if(items.begin(), items.end(), [name](const auto& item) { return item.second == name; });
+    if (it == items.end())
+        SGL_THROW("Invalid enum name \"{}\"", name);
+    return it->first;
+}
+
+/**
+ * Check if an enum has a value with the given name.
+ */
+template<has_enum_info T>
+inline bool enum_has_value(std::string_view name)
+{
+    const auto& items = EnumInfo<T>::items();
+    auto it = std::find_if(items.begin(), items.end(), [name](const auto& item) { return item.second == name; });
+    return it != items.end();
+}
+
+/**
+ * Convert an flags enum value to a list of strings.
+ * Throws if any of the flags are not found in the registered enum information.
+ */
+template<has_enum_info T>
+inline std::vector<std::string> flags_to_string_list(T flags)
+{
+    std::vector<std::string> list;
+    const auto& items = EnumInfo<T>::items();
+    for (const auto& item : items) {
+        if (is_set(flags, item.first)) {
+            list.push_back(item.second);
+            flip_bit(flags, item.first);
+        }
+    }
+    if (flags != T(0))
+        SGL_THROW("Invalid enum flags value {}", int(flags));
+    return list;
+}
+
+/**
+ * Convert a list of strings to a flags enum value.
+ * Throws if any of the strings are not found in the registered enum information.
+ */
+template<has_enum_info T>
+inline T string_list_to_flags(const std::vector<std::string>& list)
+{
+    T flags = T(0);
+    for (const auto& name : list)
+        flags |= string_to_enum<T>(name);
+    return flags;
+}
+
+namespace detail {
+
+    /// Format an enum value.
+    /// First, we check for a single value and return "name::value" if it succeeds.
+    /// Otherwise, we check for flags and return "name::(value1 | value2 | ...)".
+    /// Any bits that are not found in the enum information are formatted as hex.
+    template<has_enum_info T>
+    inline std::string format_enum(T value)
+    {
+        const auto& items = EnumInfo<T>::items();
+        // Check for single value.
+        for (const auto& item : items)
+            if (item.first == value)
+                return item.second;
+        // Check for flags.
+        std::string str = "(";
+        uint64_t bits = uint64_t(value);
+        bool first = true;
+        for (const auto& item : items) {
+            if (bits & uint64_t(item.first)) {
+                if (!first)
+                    str += " | ";
+                str += item.second;
+                bits &= ~uint64_t(item.first);
+                first = false;
+            }
+        }
+        if (bits != 0) {
+            if (!first)
+                str += " | ";
+            str += fmt::format("0x{:x}", bits);
+        }
+        str += ")";
+        return str;
+    }
+
+} // namespace detail
+} // namespace sgl
+
+/**
+ * Define enum information. This is expected to be used as follows:
+ *
+ * enum class Foo { A, B, C };
+ * SGL_ENUM_INFO(Foo, {
+ *     { Foo::A, "A" },
+ *     { Foo::B, "B" },
+ *     { Foo::C, "C" },
+ * })
+ */
+#define SGL_ENUM_INFO(T, ...)                                                                                          \
+    struct T##_info {                                                                                                  \
+        static const std::string& name()                                                                               \
+        {                                                                                                              \
+            static const std::string name = #T;                                                                        \
+            return name;                                                                                               \
+        }                                                                                                              \
+        static std::span<std::pair<T, std::string>> items()                                                            \
+        {                                                                                                              \
+            static std::pair<T, std::string> items[] = __VA_ARGS__;                                                    \
+            return {std::begin(items), std::end(items)};                                                               \
+        }                                                                                                              \
+    };
+
+/**
+ * Register enum information to be used with helper functions.
+ * This needs to be placed outside of any structs but within the
+ * namespace of the enum:
+ *
+ * namespace ns
+ * {
+ * struct Bar
+ * {
+ *     enum class Foo { A, B, C };
+ *     SGL_ENUM_INFO(Foo, ...)
+ * };
+ *
+ * SGL_ENUM_REGISTER(Bar::Foo)
+ * } // namespace ns
+ *
+ * Registered enums can be converted to/from strings using:
+ * - enum_to_string<Enum>(Enum value)
+ * - string_to_enum<Enum>(std::string_view name)
+ */
+#define SGL_ENUM_REGISTER(T)                                                                                           \
+    constexpr T##_info find_enum_info_adl [[maybe_unused]] (T) noexcept                                                \
+    {                                                                                                                  \
+        return T##_info{};                                                                                             \
+    }
+
+/// Enum formatter.
+template<sgl::has_enum_info T>
+struct fmt::formatter<T> : formatter<std::string> {
+    template<typename FormatContext>
+    auto format(const T& e, FormatContext& ctx) const
+    {
+        return formatter<std::string>::format(sgl::detail::format_enum(e), ctx);
+    }
+};

sgl/include/sgl/core/error.h

@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+#include "sgl/core/logger.h"
+#include "sgl/core/format.h"
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+
+/**
+ * \file error.h
+ * \brief Error handling utilities.
+ *
+ * Exceptions:
+ * - SGL_THROW(msg, ...)
+ * - SGL_CHECK(cond, msg, ...)
+ * - SGL_UNIMPLEMENTED()
+ * - SGL_UNREACHABLE()
+ *
+ * Assertions:
+ * - SGL_ASSERT(cond)
+ * - SGL_ASSERT_OP(a, b, op)
+ *
+ */
+
+/// Source location information.
+/// This is similar to std::source_location which unfortunately is still not
+/// well supported on all major C++ library implementations.
+struct SourceLocation {
+    const char* file_name{nullptr};
+    const char* function_name{nullptr};
+    uint32_t line{0};
+    uint32_t column{0};
+
+    [[nodiscard]] static consteval SourceLocation current(
+        const char* file_name = __builtin_FILE(),
+        const char* function_name = __builtin_FUNCTION(),
+        uint32_t line = __builtin_LINE(),
+#if !SGL_GCC
+        uint32_t column = __builtin_COLUMN()
+#else
+        uint32_t column = 0
+#endif
+    )
+    {
+        return SourceLocation{file_name, function_name, line, column};
+    }
+};
+
+// -------------------------------------------------------------------------------------------------
+// Exceptions
+// -------------------------------------------------------------------------------------------------
+
+namespace sgl {
+
+enum class ExceptionDiagnosticFlags {
+    none = 0,
+    /// Break into debugger when throwing an exception.
+    break_debugger = 1,
+    /// Log exception message.
+    log = 2,
+};
+
+SGL_ENUM_CLASS_OPERATORS(ExceptionDiagnosticFlags);
+
+/// Set exception diagnostic options.
+void SGL_API set_exception_diagnostics(ExceptionDiagnosticFlags flags);
+
+
+/// Throw an exception.
+[[noreturn]] SGL_API void throw_exception(const SourceLocation& loc, std::string_view msg);
+
+namespace detail {
+    [[noreturn]] inline void throw_exception(const SourceLocation& loc, std::string_view msg)
+    {
+        ::sgl::throw_exception(loc, msg);
+    }
+
+    template<typename... Args>
+    [[noreturn]] inline void throw_exception(const SourceLocation& loc, fmt::format_string<Args...> fmt, Args&&... args)
+    {
+        ::sgl::throw_exception(loc, fmt::format(fmt, std::forward<Args>(args)...));
+    }
+
+} // namespace detail
+} // namespace sgl
+
+/// Helper for throwing exceptions.
+/// Logs the exception and a stack trace before throwing.
+#define SGL_THROW(...) ::sgl::detail::throw_exception(SourceLocation::current(), __VA_ARGS__)
+
+/// Helper for checking conditions and throwing exceptions.
+/// Logs the exception and a stack trace before throwing.
+#define SGL_CHECK(cond, ...)                                                                                           \
+    do {                                                                                                               \
+        if (!(cond))                                                                                                   \
+            SGL_THROW(__VA_ARGS__);                                                                                    \
+    } while (0)
+
+/// Helper for throwing an exception if a pointer is null.
+#define SGL_CHECK_NOT_NULL(arg) SGL_CHECK(arg != nullptr, "\"{}\" must not be null", #arg)
+
+#define SGL_CHECK_LT(arg, value) SGL_CHECK(arg < value, "\"{}\" must be less than {}", #arg, value)
+#define SGL_CHECK_LE(arg, value) SGL_CHECK(arg <= value, "\"{}\" must be less than or equal {}", #arg, value)
+#define SGL_CHECK_GT(arg, value) SGL_CHECK(arg > value, "\"{}\" must be greater than {}", #arg, value)
+#define SGL_CHECK_GE(arg, value) SGL_CHECK(arg >= value, "\"{}\" must be greater than or equal {}", #arg, value)
+#define SGL_CHECK_BOUNDS(arg, min, max)                                                                                \
+    SGL_CHECK(arg >= min && arg < max, "\"{}\" must be in range [{}, {}]", #arg, min, max)
+
+/// Helper for marking unimplemented functions.
+#define SGL_UNIMPLEMENTED() SGL_THROW("Unimplemented")
+
+/// Helper for marking unreachable code.
+#define SGL_UNREACHABLE() SGL_THROW("Unreachable")
+
+// -------------------------------------------------------------------------------------------------
+// Assertions
+// -------------------------------------------------------------------------------------------------
+
+namespace sgl {
+
+/// Report a failed assertion.
+[[noreturn]] SGL_API void report_assertion(const SourceLocation& loc, std::string_view cond);
+
+} // namespace sgl
+
+#if SGL_ENABLE_ASSERTS
+
+#define SGL_ASSERT(cond)                                                                                               \
+    if (!(cond)) {                                                                                                     \
+        ::sgl::report_assertion(SourceLocation::current(), #cond);                                                     \
+    }
+
+#define SGL_ASSERT_OP(a, b, op)                                                                                        \
+    if (!((a)op(b))) {                                                                                                 \
+        ::sgl::report_assertion(                                                                                       \
+            SourceLocation::current(),                                                                                 \
+            fmt::format("{} {} {} ({} {} {})", #a, #op, #b, a, #op, b)                                                 \
+        );                                                                                                             \
+    }
+
+#else // SGL_ENABLE_ASSERTS
+
+#define SGL_ASSERT(a)                                                                                                  \
+    {                                                                                                                  \
+    }
+#define SGL_ASSERT_OP(a, b, op)                                                                                        \
+    {                                                                                                                  \
+    }
+
+#endif // SGL_ENABLE_ASSERTS
+
+#define SGL_ASSERT_EQ(a, b) SGL_ASSERT_OP(a, b, ==)
+#define SGL_ASSERT_NE(a, b) SGL_ASSERT_OP(a, b, !=)
+#define SGL_ASSERT_GE(a, b) SGL_ASSERT_OP(a, b, >=)
+#define SGL_ASSERT_GT(a, b) SGL_ASSERT_OP(a, b, >)
+#define SGL_ASSERT_LE(a, b) SGL_ASSERT_OP(a, b, <=)
+#define SGL_ASSERT_LT(a, b) SGL_ASSERT_OP(a, b, <)

sgl/include/sgl/core/file_stream.h

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/stream.h"
+#include "sgl/core/enum.h"
+
+#include <exception>
+#include <filesystem>
+#include <iosfwd>
+#include <memory>
+
+namespace sgl {
+
+class SGL_API EOFException : public std::runtime_error {
+public:
+    EOFException(const std::string& what, size_t gcount)
+        : std::runtime_error(what)
+        , m_gcount(gcount)
+    {
+    }
+
+    size_t gcount() const { return m_gcount; }
+
+private:
+    size_t m_gcount;
+};
+
+class SGL_API FileStream : public Stream {
+    SGL_OBJECT(FileStream)
+public:
+    enum class Mode {
+        read,
+        write,
+        read_write,
+    };
+
+    SGL_ENUM_INFO(
+        Mode,
+        {
+            {Mode::read, "read"},
+            {Mode::write, "write"},
+            {Mode::read_write, "read_write"},
+        }
+    );
+
+    FileStream(const std::filesystem::path& path, Mode mode);
+    virtual ~FileStream();
+
+    const std::filesystem::path& path() const { return m_path; }
+    Mode mode() const { return m_mode; }
+
+    bool is_open() const override;
+    bool is_readable() const override { return m_mode == Mode::read || m_mode == Mode::read_write; }
+    bool is_writable() const override { return m_mode == Mode::write || m_mode == Mode::read_write; }
+
+    void close() override;
+
+    void read(void* p, size_t size) override;
+    void write(const void* p, size_t size) override;
+    void seek(size_t pos) override;
+    void truncate(size_t size) override;
+    size_t tell() const override;
+    size_t size() const override;
+    void flush() override;
+
+    std::string to_string() const override;
+
+private:
+    std::filesystem::path m_path;
+    Mode m_mode;
+    std::unique_ptr<std::fstream> m_stream;
+};
+
+SGL_ENUM_REGISTER(FileStream::Mode);
+
+} // namespace sgl

sgl/include/sgl/core/file_system_watcher.h

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/fwd.h"
+#include "sgl/core/stream.h"
+#include "sgl/core/enum.h"
+#include "sgl/core/platform.h"
+
+#include <atomic>
+#include <chrono>
+#include <filesystem>
+#include <functional>
+#include <map>
+#include <mutex>
+#include <thread>
+
+namespace sgl {
+
+/// Types of file system event that can be reported.
+enum class FileSystemWatcherChange {
+    invalid,
+    added,
+    removed,
+    modified,
+};
+
+/// Init options for FileSystemWatcher.
+struct FileSystemWatchDesc {
+
+    /// Directory to monitor.
+    std::filesystem::path directory;
+};
+
+/// Data reported on a given file system event to a file monitored
+/// by FileSystemWatcher.
+struct FileSystemWatchEvent {
+
+    /// Path of file that has changed relative to watcher.
+    std::filesystem::path path;
+
+    /// Absolute path of file in file system
+    std::filesystem::path absolute_path;
+
+    /// Change type.
+    FileSystemWatcherChange change{FileSystemWatcherChange::invalid};
+
+    /// System time change was recorded.
+    std::chrono::system_clock::time_point time;
+};
+
+// Declare watch state (only used internally).
+struct FileSystemWatchState;
+
+/// Monitors directories for changes and calls a callback when they're detected.
+/// The watcher automatically queues up changes until disk has been idle for
+/// a period. Relies on regular polling of update().
+class SGL_API FileSystemWatcher : public Object {
+    SGL_OBJECT(FileSystemWatcher)
+public:
+    using ChangeCallback = std::function<void(std::span<FileSystemWatchEvent>)>;
+
+    FileSystemWatcher();
+    ~FileSystemWatcher();
+
+    /// FileSystemWatch move constructor is deleted to allow for map of unique ptrs.
+    FileSystemWatcher(FileSystemWatcher&& other) = delete;
+
+    /// Add watch of a new directory.
+    uint32_t add_watch(const FileSystemWatchDesc& desc);
+
+    /// Remove existing watch.
+    void remove_watch(uint32_t id);
+
+    /// Remove existing watch.
+    void remove_watch(const std::filesystem::path& directory);
+
+    /// Get number of active watches
+    size_t watch_count() const { return m_watches.size(); }
+
+    /// Get callback for file system events.
+    ChangeCallback on_change() const { return m_on_change; }
+
+    /// Set callback for file system events.
+    void set_on_change(ChangeCallback on_change);
+
+    /// Update function to poll the watcher + report events.
+    void update();
+
+    /// Delay period before queued events are output.
+    uint32_t delay() { return m_output_delay_ms; }
+
+    /// Set delay period before queued events are output.
+    void set_delay(uint32_t milliseconds) { m_output_delay_ms = milliseconds; }
+
+    /// Internal function called when OS reports an event.
+    void _notify_change(FileSystemWatchState* state, const std::filesystem::path& path, FileSystemWatcherChange change);
+
+private:
+    /// Releases OS monitoring for a given watch.
+    void stop_watch(const std::unique_ptr<FileSystemWatchState>&);
+
+    /// Next unique id to be assigned to a given watch.
+    uint32_t m_next_id{1};
+
+    /// Delay before outputting events in milliseconds.
+    uint32_t m_output_delay_ms{1000};
+
+    /// Map of id->watch.
+    std::map<int, std::unique_ptr<FileSystemWatchState>> m_watches;
+
+    /// Watch event callback.
+    ChangeCallback m_on_change;
+
+    /// Events reported since last call to watch event callback.
+    std::vector<FileSystemWatchEvent> m_queued_events;
+
+    /// Time last event was recorded.
+    std::chrono::system_clock::time_point m_last_event;
+
+#if SGL_LINUX
+    /// File descriptor for linux inotify watcher.
+    int m_inotify_file_descriptor;
+#endif
+
+#if !SGL_LINUX
+    /// Mutex to protect the watch map.
+    std::mutex m_watches_mutex;
+
+    /// Mutex to protect the queued events.
+    std::mutex m_queued_events_mutex;
+
+    /// Thread to poll for file system changes.
+    std::thread m_thread;
+    std::atomic<bool> m_stop_thread{false};
+    void thread_func();
+#endif
+};
+
+
+} // namespace sgl

sgl/include/sgl/core/format.h

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+
+SGL_DIAGNOSTIC_PUSH
+SGL_DISABLE_MSVC_WARNING(4061 4459)
+#include <fmt/format.h>
+#include <fmt/ranges.h>
+SGL_DIAGNOSTIC_POP
+
+#include <filesystem>
+#include <optional>
+
+template<>
+struct fmt::formatter<std::filesystem::path> : formatter<std::string> {
+    template<typename FormatContext>
+    auto format(const std::filesystem::path& p, FormatContext& ctx) const
+    {
+        return formatter<std::string>::format(p.string(), ctx);
+    }
+};
+
+template<typename T>
+struct fmt::formatter<std::optional<T>> : formatter<T> {
+    template<typename FormatContext>
+    auto format(const std::optional<T>& opt, FormatContext& ctx) const
+    {
+        if (opt) {
+            formatter<T>::format(*opt, ctx);
+            return ctx.out();
+        }
+        return fmt::format_to(ctx.out(), "nullopt");
+    }
+};

sgl/include/sgl/core/fwd.h

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstdlib>
+
+namespace sgl {
+
+// bitmap.h
+
+class Bitmap;
+
+// blob.h
+
+class Blob;
+
+// file_stream.h
+
+class EOFException;
+class FileStream;
+
+// file_system_watcher.h
+
+struct FileSystemWatchDesc;
+struct FileSystemWatchEvent;
+class FileSystemWatcher;
+
+// input.h
+
+struct KeyboardEvent;
+struct MouseEvent;
+struct GamepadEvent;
+struct GamepadState;
+
+// logger.h
+
+class LoggerOutput;
+class ConsoleLoggerOutput;
+class FileLoggerOutput;
+class DebugConsoleLoggerOutput;
+class Logger;
+
+// memory_mapped_file_stream.h
+
+class MemoryMappedFileStream;
+
+// memory_mapped_file.h
+
+class MemoryMappedFile;
+
+// memory_stream.h
+
+class MemoryStream;
+
+// object.h
+
+class Object;
+template<typename>
+class ref;
+template<typename>
+class breakable_ref;
+
+// short_vector.h
+
+template<typename T, size_t N>
+class short_vector;
+
+// static_vector.h
+
+template<typename T, size_t N>
+class static_vector;
+
+// stream.h
+
+class Stream;
+
+// struct.h
+
+class Struct;
+class StructConverter;
+
+// timer.h
+
+class Timer;
+
+// window.h
+
+class Window;
+
+} // namespace sgl