nv-sgl 0.6.0__cp313-cp313-win_amd64.whl

sgl/include/sgl/core/logger.h

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+#include "sgl/core/object.h"
+#include "sgl/core/format.h"
+
+#include <mutex>
+#include <string_view>
+#include <set>
+#include <filesystem>
+
+namespace sgl {
+
+
+/// Log level.
+enum class LogLevel {
+    none,
+    debug,
+    info,
+    warn,
+    error,
+    fatal,
+};
+
+/// Log frequency.
+enum class LogFrequency {
+    /// Log the message every time.
+    always,
+    /// Log the message only once.
+    once,
+};
+
+/// Abstract base class for logger outputs.
+class SGL_API LoggerOutput : public Object {
+    SGL_OBJECT(LoggerOutput)
+public:
+    virtual ~LoggerOutput() = default;
+
+    /// Write a log message.
+    /// \param level The log level.
+    /// \param module The module name.
+    /// \param msg The message.
+    virtual void write(LogLevel level, const std::string_view module, const std::string_view msg) = 0;
+};
+
+/// Logger output that writes to the console.
+/// Error messages are printed to stderr, all other messages to stdout.
+/// Messages are optionally colored.
+class SGL_API ConsoleLoggerOutput : public LoggerOutput {
+public:
+    ConsoleLoggerOutput(bool colored = true);
+
+    void write(LogLevel level, const std::string_view module, const std::string_view msg) override;
+
+    std::string to_string() const override;
+
+private:
+    static bool enable_ansi_control_sequences();
+
+    bool m_colored;
+};
+
+/// Logger output that writes to a file.
+class SGL_API FileLoggerOutput : public LoggerOutput {
+public:
+    FileLoggerOutput(const std::filesystem::path& path);
+    ~FileLoggerOutput();
+
+    const std::filesystem::path& path() const { return m_path; }
+
+    void write(LogLevel level, const std::string_view module, const std::string_view msg) override;
+
+    std::string to_string() const override;
+
+private:
+    std::filesystem::path m_path;
+    void* m_file;
+};
+
+/// Logger output that writes to the debug console (Windows only).
+class SGL_API DebugConsoleLoggerOutput : public LoggerOutput {
+public:
+    void write(LogLevel level, const std::string_view module, const std::string_view msg) override;
+
+    std::string to_string() const override;
+};
+
+/// Defines a family of logging functions for a given log level.
+/// The functions are:
+/// - name(msg)
+/// - name(fmt, ...)
+/// - name_once(msg)
+/// - name_once(fmt, ...)
+/// The once variants only log the message once per program run.
+#define SGL_LOG_FUNC_FAMILY(name, level, log_func)                                                                     \
+    inline void name(const std::string_view msg)                                                                       \
+    {                                                                                                                  \
+        log_func(level, msg, LogFrequency::always);                                                                    \
+    }                                                                                                                  \
+    template<typename... Args>                                                                                         \
+    inline void name(fmt::format_string<Args...> fmt, Args&&... args)                                                  \
+    {                                                                                                                  \
+        log_func(level, fmt::format(fmt, std::forward<Args>(args)...), LogFrequency::always);                          \
+    }                                                                                                                  \
+    inline void name##_once(const std::string_view msg)                                                                \
+    {                                                                                                                  \
+        log_func(level, msg, LogFrequency::once);                                                                      \
+    }                                                                                                                  \
+    template<typename... Args>                                                                                         \
+    inline void name##_once(fmt::format_string<Args...> fmt, Args&&... args)                                           \
+    {                                                                                                                  \
+        log_func(level, fmt::format(fmt, std::forward<Args>(args)...), LogFrequency::once);                            \
+    }
+
+
+class SGL_API Logger : public Object {
+    SGL_OBJECT(Logger)
+public:
+    /// Constructor.
+    /// \param level The log level to use (messages with level >= this will be logged).
+    /// \param name The name of the logger.
+    /// \param use_default_outputs Whether to use the default outputs (console + debug console on windows).
+    Logger(LogLevel level = LogLevel::info, const std::string_view name = {}, bool use_default_outputs = true);
+
+    static ref<Logger>
+    create(LogLevel level = LogLevel::info, const std::string_view name = {}, bool use_default_outputs = true)
+    {
+        return make_ref<Logger>(level, name, use_default_outputs);
+    }
+
+    /// Add a console logger output.
+    /// \param colored Whether to use colored output.
+    /// \return The created logger output.
+    ref<LoggerOutput> add_console_output(bool colored = true);
+
+    /// Add a file logger output.
+    /// \param path The path to the log file.
+    /// \return The created logger output.
+    ref<LoggerOutput> add_file_output(const std::filesystem::path& path);
+
+    /// Add a debug console logger output (Windows only).
+    /// \return The created logger output.
+    ref<LoggerOutput> add_debug_console_output();
+
+    /// Use the same outputs as the given logger.
+    /// \param other Logger to copy outputs from.
+    void use_same_outputs(const Logger& other);
+
+    /// Add a logger output.
+    /// \param output The logger output to add.
+    void add_output(ref<LoggerOutput> output);
+
+    /// Remove a logger output.
+    /// \param output The logger output to remove.
+    void remove_output(ref<LoggerOutput> output);
+
+    /// Remove all logger outputs.
+    void remove_all_outputs();
+
+    /// The name of the logger.
+    std::string name() const;
+    void set_name(std::string_view name);
+
+    /// The log level.
+    LogLevel level() const;
+    void set_level(LogLevel level);
+
+    /// Log a message.
+    /// \param level The log level.
+    /// \param msg The message.
+    /// \param frequency The log frequency.
+    void log(LogLevel level, const std::string_view msg, LogFrequency frequency = LogFrequency::always);
+
+    // Define logging functions.
+    SGL_LOG_FUNC_FAMILY(debug, LogLevel::debug, log)
+    SGL_LOG_FUNC_FAMILY(info, LogLevel::info, log)
+    SGL_LOG_FUNC_FAMILY(warn, LogLevel::warn, log)
+    SGL_LOG_FUNC_FAMILY(error, LogLevel::error, log)
+    SGL_LOG_FUNC_FAMILY(fatal, LogLevel::fatal, log)
+
+    /// Returns the global logger instance.
+    static Logger& get();
+
+    static void static_init();
+    static void static_shutdown();
+
+private:
+    /// Checks if the given message has already been logged.
+    bool is_duplicate(const std::string_view msg);
+
+    LogLevel m_level{LogLevel::info};
+    std::string m_name;
+
+    std::set<ref<LoggerOutput>> m_outputs;
+    std::set<std::string, std::less<>> m_messages;
+
+    mutable std::mutex m_mutex;
+};
+
+// Define global logging functions.
+SGL_LOG_FUNC_FAMILY(log_debug, LogLevel::debug, Logger::get().log)
+SGL_LOG_FUNC_FAMILY(log_info, LogLevel::info, Logger::get().log)
+SGL_LOG_FUNC_FAMILY(log_warn, LogLevel::warn, Logger::get().log)
+SGL_LOG_FUNC_FAMILY(log_error, LogLevel::error, Logger::get().log)
+SGL_LOG_FUNC_FAMILY(log_fatal, LogLevel::fatal, Logger::get().log)
+
+#undef SGL_LOG_FUNC_FAMILY
+
+} // namespace sgl
+
+/// Prints the given variable name and value.
+#define SGL_PRINT(var) ::sgl::Logger::get().log(::sgl::LogLevel::none, ::fmt::format("{} = {}", #var, var))

sgl/include/sgl/core/macros.h

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+// -------------------------------------------------------------------------------------------------
+// Compiler macros
+// -------------------------------------------------------------------------------------------------
+
+#define SGL_COMPILER_MSVC 1
+#define SGL_COMPILER_CLANG 2
+#define SGL_COMPILER_GCC 3
+
+/**
+ * Determine the compiler in use.
+ * http://sourceforge.net/p/predef/wiki/Compilers/
+ */
+#ifndef SGL_COMPILER
+#if defined(_MSC_VER)
+#define SGL_COMPILER SGL_COMPILER_MSVC
+#elif defined(__clang__)
+#define SGL_COMPILER SGL_COMPILER_CLANG
+#elif defined(__GNUC__)
+#define SGL_COMPILER SGL_COMPILER_GCC
+#else
+#error "Unsupported compiler"
+#endif
+#endif // SGL_COMPILER
+
+#define SGL_MSVC (SGL_COMPILER == SGL_COMPILER_MSVC)
+#define SGL_CLANG (SGL_COMPILER == SGL_COMPILER_CLANG)
+#define SGL_GCC (SGL_COMPILER == SGL_COMPILER_GCC)
+
+// -------------------------------------------------------------------------------------------------
+// Architecture macros
+// -------------------------------------------------------------------------------------------------
+
+#define SGL_ARCH_X86_64 1
+#define SGL_ARCH_ARM64 2
+
+/**
+ * Determine the target architecture in use.
+ * http://sourceforge.net/p/predef/wiki/Architectures/
+ */
+#ifndef SGL_ARCH
+#if defined(_M_X64) || defined(__x86_64__)
+#define SGL_ARCH SGL_ARCH_X86_64
+#elif defined(_M_ARM64) || defined(__aarch64__)
+#define SGL_ARCH SGL_ARCH_ARM64
+#else
+#error "Unsupported target architecture"
+#endif
+#endif // SGL_ARCH
+
+#define SGL_X86_64 (SGL_ARCH == SGL_ARCH_X86_64)
+#define SGL_ARM64 (SGL_ARCH == SGL_ARCH_ARM64)
+
+// -------------------------------------------------------------------------------------------------
+// Platform macros
+// -------------------------------------------------------------------------------------------------
+
+#define SGL_PLATFORM_WINDOWS 1
+#define SGL_PLATFORM_LINUX 2
+#define SGL_PLATFORM_MACOS 3
+
+/**
+ * Determine the target platform in use.
+ * http://sourceforge.net/p/predef/wiki/OperatingSystems/
+ */
+#ifndef SGL_PLATFORM
+#if defined(_WIN64)
+#define SGL_PLATFORM SGL_PLATFORM_WINDOWS
+#elif defined(__linux__)
+#define SGL_PLATFORM SGL_PLATFORM_LINUX
+#elif defined(__APPLE__) && defined(__MACH__)
+#define SGL_PLATFORM SGL_PLATFORM_MACOS
+#else
+#error "Unsupported target platform"
+#endif
+#endif // SGL_PLATFORM
+
+#define SGL_WINDOWS (SGL_PLATFORM == SGL_PLATFORM_WINDOWS)
+#define SGL_LINUX (SGL_PLATFORM == SGL_PLATFORM_LINUX)
+#define SGL_MACOS (SGL_PLATFORM == SGL_PLATFORM_MACOS)
+
+/**
+ * Shared library (DLL) export and import.
+ */
+#if SGL_WINDOWS
+#define SGL_API_EXPORT __declspec(dllexport)
+#define SGL_API_IMPORT __declspec(dllimport)
+#else
+#define SGL_API_EXPORT __attribute__((visibility("default")))
+#define SGL_API_IMPORT
+#endif
+
+#ifdef SGL_DLL
+#define SGL_API SGL_API_EXPORT
+#else // SGL_DLL
+#define SGL_API SGL_API_IMPORT
+#endif // SGL_DLL
+
+// -------------------------------------------------------------------------------------------------
+// Convenience macros
+// -------------------------------------------------------------------------------------------------
+
+#if SGL_MSVC
+#define SGL_INLINE __forceinline
+#elif SGL_CLANG | SGL_GCC
+#define SGL_INLINE __attribute__((always_inline))
+#endif
+
+#define SGL_NON_COPYABLE(cls)                                                                                          \
+    cls(const cls&) = delete;                                                                                          \
+    cls& operator=(const cls&) = delete
+
+#define SGL_NON_MOVABLE(cls)                                                                                           \
+    cls(cls&&) = delete;                                                                                               \
+    cls& operator=(cls&&) = delete
+
+#define SGL_NON_COPYABLE_AND_MOVABLE(cls)                                                                              \
+    SGL_NON_COPYABLE(cls);                                                                                             \
+    SGL_NON_MOVABLE(cls)
+
+// clang-format off
+namespace sgl::detail { template<typename... Args> inline void unused(Args&&...) {} }
+// clang-format on
+
+#define SGL_UNUSED(...) ::sgl::detail::unused(__VA_ARGS__)
+
+#define SGL_STRINGIZE(a) #a
+#define SGL_TO_STRING(a) SGL_STRINGIZE(a)
+#define SGL_CONCAT_STRINGS_(a, b) a##b
+#define SGL_CONCAT_STRINGS(a, b) SGL_CONCAT_STRINGS_(a, b)
+
+// -------------------------------------------------------------------------------------------------
+// Compiler warnings
+// -------------------------------------------------------------------------------------------------
+
+// Example usage:
+// SGL_DIAGNOSTIC_PUSH
+// SGL_DISABLE_MSVC_WARNING(4455)
+// SGL_DISABLE_CLANG_WARNING("-Wuser-defined-literals")
+// SGL_DISABLE_GCC_WARNING("-Wliteral-suffix")
+// inline float16_t operator""h(long double value) { return float16_t(static_cast<float>(value)); }
+// SGL_DIAGNOSTIC_POP
+
+#if SGL_MSVC
+#define SGL_DIAGNOSTIC_PUSH __pragma(warning(push))
+#define SGL_DIAGNOSTIC_POP __pragma(warning(pop))
+#define SGL_DISABLE_WARNING(warning_) __pragma(warning(disable : warning_))
+#define SGL_DISABLE_MSVC_WARNING(warning) SGL_DISABLE_WARNING(warning)
+#define SGL_DISABLE_CLANG_WARNING(warning)
+#define SGL_DISABLE_GCC_WARNING(warning)
+#elif SGL_CLANG
+#define SGL_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+#define SGL_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#define SGL_DISABLE_WARNING(warning) _Pragma(SGL_STRINGIZE(clang diagnostic ignored warning))
+#define SGL_DISABLE_MSVC_WARNING(warning)
+#define SGL_DISABLE_CLANG_WARNING(warning) SGL_DISABLE_WARNING(warning)
+#define SGL_DISABLE_GCC_WARNING(warning)
+#elif SGL_GCC
+#define SGL_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+#define SGL_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#define SGL_DISABLE_WARNING(warning) _Pragma(SGL_STRINGIZE(GCC diagnostic ignored warning))
+#define SGL_DISABLE_MSVC_WARNING(warning)
+#define SGL_DISABLE_CLANG_WARNING(warning)
+#define SGL_DISABLE_GCC_WARNING(warning) SGL_DISABLE_WARNING(warning)
+#endif
+
+// -------------------------------------------------------------------------------------------------
+// Enum flags
+// -------------------------------------------------------------------------------------------------
+
+// clang-format off
+/// Implement logical operators on a class enum for making it usable as a flags enum.
+#define SGL_ENUM_CLASS_OPERATORS(e_) \
+    inline e_ operator& (e_ a, e_ b) { return static_cast<e_>(static_cast<int>(a)& static_cast<int>(b)); } \
+    inline e_ operator| (e_ a, e_ b) { return static_cast<e_>(static_cast<int>(a)| static_cast<int>(b)); } \
+    inline e_& operator|= (e_& a, e_ b) { a = a | b; return a; }; \
+    inline e_& operator&= (e_& a, e_ b) { a = a & b; return a; }; \
+    inline e_  operator~ (e_ a) { return static_cast<e_>(~static_cast<int>(a)); } \
+    inline bool is_set(e_ val, e_ flag) { return (val & flag) != static_cast<e_>(0); } \
+    inline void flip_bit(e_& val, e_ flag) { val = is_set(val, flag) ? (val & (~flag)) : (val | flag); }
+// clang-format on

sgl/include/sgl/core/maths.h

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <algorithm>
+#include <concepts>
+
+namespace sgl {
+
+/// Clamp x to [lo..hi] range.
+template<typename T>
+constexpr T clamp(const T& x, const T& lo, const T& hi)
+{
+    return std::min(std::max(x, lo), hi);
+}
+
+/// Linearly interpolate between a and b.
+template<typename T, std::floating_point U>
+constexpr T lerp(const T& a, const T& b, const U& t)
+{
+    return (U(1) - t) * a + t * b;
+}
+
+/// Returns true if integer value is a power of two.
+template<std::integral T>
+constexpr bool is_power_of_two(T a)
+{
+    return (a & (a - (T)1)) == 0;
+}
+
+/// Divide a by b and round up to the next integer.
+template<std::integral T>
+constexpr T div_round_up(T a, T b)
+{
+    return (a + b - T(1)) / b;
+}
+
+/// Align an integer value to the given alignment.
+template<std::integral T>
+constexpr T align_to(T alignment, T value)
+{
+    return ((value + alignment - T(1)) / alignment) * alignment;
+}
+
+} // namespace sgl

sgl/include/sgl/core/memory_mapped_file.h

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+
+#include <cstdint>
+#include <filesystem>
+#include <limits>
+
+namespace sgl {
+
+/**
+ * Utility class for reading memory-mapped files.
+ */
+class SGL_API MemoryMappedFile {
+public:
+    enum class AccessHint {
+        /// Good overall performance.
+        normal,
+        /// Read file once with few seeks.
+        sequential,
+        /// Good for random access.
+        random
+    };
+
+    static constexpr size_t WHOLE_FILE = std::numeric_limits<size_t>::max();
+
+    /**
+     * Default constructor. Use open() for opening a file.
+     */
+    MemoryMappedFile() = default;
+
+    /**
+     * Constructor opening a file. Use is_open() to check if successful.
+     * \param path Path to open.
+     * \param mapped_size Number of bytes to map into memory (automatically clamped to the file size).
+     * \param access_hint Hint on how memory is accessed.
+     */
+    MemoryMappedFile(
+        const std::filesystem::path& path,
+        size_t mapped_size = WHOLE_FILE,
+        AccessHint access_hint = AccessHint::normal
+    );
+
+    /// Destructor. Closes the file.
+    ~MemoryMappedFile();
+
+    /**
+     * Open a file.
+     * \param path Path to open.
+     * \param mapped_size Number of bytes to map into memory (automatically clamped to the file size).
+     * \param access_hint Hint on how memory is accessed.
+     * \return True if file was successfully opened.
+     */
+    bool open(
+        const std::filesystem::path& path,
+        size_t mapped_size = WHOLE_FILE,
+        AccessHint access_hint = AccessHint::normal
+    );
+
+    /// Close the file.
+    void close();
+
+    /// True, if file successfully opened.
+    bool is_open() const { return m_mapped_data != nullptr; }
+
+    /// Get the file size in bytes.
+    size_t size() const { return m_size; }
+
+    /// Get the mapped data.
+    const void* data() const { return m_mapped_data; };
+
+    /// Get the mapped memory size in bytes.
+    size_t mapped_size() const { return m_mapped_size; };
+
+    /// Get the OS page size (for remap).
+    static size_t page_size();
+
+private:
+    MemoryMappedFile(const MemoryMappedFile&) = delete;
+    MemoryMappedFile(MemoryMappedFile&) = delete;
+    MemoryMappedFile& operator=(const MemoryMappedFile&) = delete;
+    MemoryMappedFile& operator=(const MemoryMappedFile&&) = delete;
+
+    /**
+     * Replace mapping by a new one of the same file.
+     * \param offset Offset from start of the file in bytes (must be multiple of page size).
+     * \param mapped_size Size of mapping in bytes.
+     * \return True if successful.
+     */
+    bool remap(uint64_t offset, size_t mapped_size);
+
+    std::filesystem::path m_path;
+    AccessHint m_access_hint = AccessHint::normal;
+    size_t m_size = 0;
+
+#if SGL_WINDOWS
+    using FileHandle = void*;
+    void* m_mapped_file{nullptr};
+#elif SGL_LINUX || SGL_MACOS
+    using FileHandle = int;
+#else
+#error "Unknown OS"
+#endif
+
+    FileHandle m_file = 0;
+    void* m_mapped_data = 0;
+    size_t m_mapped_size = 0;
+};
+
+} // namespace sgl

sgl/include/sgl/core/memory_mapped_file_stream.h

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/memory_stream.h"
+#include "sgl/core/memory_mapped_file.h"
+
+#include <filesystem>
+#include <memory>
+
+namespace sgl {
+
+class SGL_API MemoryMappedFileStream : public MemoryStream {
+    SGL_OBJECT(MemoryMappedFileStream)
+public:
+    MemoryMappedFileStream(
+        const std::filesystem::path& path,
+        size_t mapped_size = MemoryMappedFile::WHOLE_FILE,
+        MemoryMappedFile::AccessHint access_hint = MemoryMappedFile::AccessHint::normal
+    );
+    ~MemoryMappedFileStream();
+
+    const std::filesystem::path& path() const { return m_path; }
+
+    std::string to_string() const override;
+
+public:
+    std::filesystem::path m_path;
+    std::unique_ptr<MemoryMappedFile> m_file;
+};
+
+} // namespace sgl

sgl/include/sgl/core/memory_stream.h

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/stream.h"
+
+namespace sgl {
+
+class SGL_API MemoryStream : public Stream {
+    SGL_OBJECT(MemoryStream)
+public:
+    /// Create a read/write memory stream with the given initial capacity.
+    MemoryStream(size_t capacity = 1024);
+
+    /// Create a read-only memory stream from an existing buffer.
+    MemoryStream(const void* data, size_t size);
+
+    /// Create a read/write memory stream from an existing buffer.
+    MemoryStream(void* data, size_t size);
+
+    /// Destructor.
+    virtual ~MemoryStream();
+
+    virtual bool is_open() const override { return m_is_open; }
+
+    virtual bool is_readable() const override { return true; }
+
+    virtual bool is_writable() const override { return m_is_writable; }
+
+    virtual void close() override;
+
+    virtual void read(void* p, size_t size) override;
+
+    virtual void write(const void* p, size_t size) override;
+
+    virtual void seek(size_t pos) override { m_pos = pos; }
+
+    virtual void truncate(size_t size) override;
+
+    virtual size_t tell() const override { return m_pos; }
+
+    virtual size_t size() const override { return m_size; }
+
+    virtual void flush() override { }
+
+    /// Return the current capacity of the underlying buffer.
+    size_t capacity() const { return m_capacity; }
+
+    /// Return true if stream owns the underlying buffer.
+    bool owns_data() const { return m_owns_data; }
+
+    /// Return the underlying raw buffer.
+    const uint8_t* data() const { return m_data; }
+
+protected:
+    void resize(size_t new_size);
+
+    /// Current capacity of the underlying buffer.
+    size_t m_capacity;
+    /// Current size of the stream.
+    size_t m_size;
+    /// Current position in the stream.
+    size_t m_pos;
+    /// Pointer to the underlying buffer.
+    uint8_t* m_data;
+    /// True if the stream owns the underlying buffer.
+    bool m_owns_data;
+    /// True if the stream is open.
+    bool m_is_open;
+    /// True if the stream is writable.
+    bool m_is_writable;
+};
+
+} // namespace sgl