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

sgl/include/sgl/app/app.h

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/object.h"
+#include "sgl/core/window.h"
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/device.h"
+#include "sgl/device/swapchain.h"
+#include "sgl/ui/fwd.h"
+
+#include <vector>
+
+namespace sgl {
+
+class AppWindow;
+
+struct AppDesc {
+    /// Device to use for rendering.
+    /// If not provided, a default device will be created.
+    ref<Device> device;
+};
+
+class SGL_API App : Object {
+    SGL_OBJECT(App)
+public:
+    App(AppDesc desc);
+    virtual ~App();
+
+    Device* device() const { return m_device; }
+
+    void run();
+    void run_frame();
+
+    void terminate();
+
+    void _add_window(AppWindow* window);
+    void _remove_window(AppWindow* window);
+
+private:
+    ref<Device> m_device;
+
+    std::vector<AppWindow*> m_windows;
+
+    bool m_terminate{false};
+};
+
+struct AppWindowDesc {
+    App* app{nullptr};
+    /// Width of the window in pixels.
+    uint32_t width{1920};
+    /// Height of the window in pixels.
+    uint32_t height{1280};
+    /// Title of the window.
+    std::string title{"sgl"};
+    /// Window mode.
+    WindowMode mode{WindowMode::normal};
+    /// Whether the window is resizable.
+    bool resizable{true};
+    /// Format of the swapchain images.
+    Format swapchain_format{Format::bgra8_unorm_srgb};
+    /// Enable/disable vertical synchronization.
+    bool enable_vsync{false};
+};
+
+class SGL_API AppWindow : Object {
+    SGL_OBJECT(AppWindow)
+public:
+    AppWindow(AppWindowDesc desc);
+    virtual ~AppWindow();
+
+    App* app() const { return m_app; }
+    Device* device() const { return m_device; }
+
+    ui::Screen* screen() const;
+
+    struct RenderContext {
+        Texture* swapchain_image;
+        Framebuffer* framebuffer;
+        CommandBuffer* command_buffer;
+    };
+
+    virtual void render(RenderContext render_context) { SGL_UNUSED(render_context); }
+    virtual void render_ui() { }
+
+    virtual void on_resize(uint32_t width, uint32_t height) { SGL_UNUSED(width, height); }
+    virtual void on_keyboard_event(const KeyboardEvent& event);
+    virtual void on_mouse_event(const MouseEvent& event) { SGL_UNUSED(event); }
+    virtual void on_gamepad_event(const GamepadEvent& event) { SGL_UNUSED(event); }
+    virtual void on_drop_files(std::span<const char*> files) { SGL_UNUSED(files); }
+
+    void _run_frame();
+    bool _should_close();
+
+private:
+    void create_framebuffers();
+
+    void handle_resize(uint32_t width, uint32_t height);
+    void handle_keyboard_event(const KeyboardEvent& event);
+    void handle_mouse_event(const MouseEvent& event);
+    void handle_gamepad_event(const GamepadEvent& event);
+    void handle_drop_files(std::span<const char*> files);
+
+    App* m_app;
+    Device* m_device;
+    ref<Window> m_window;
+    ref<Swapchain> m_swapchain;
+    std::vector<ref<Framebuffer>> m_framebuffers;
+    ref<ui::Context> m_ui_context;
+};
+
+} // namespace sgl

sgl/include/sgl/core/bitmap.h

@@ -0,0 +1,302 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+This is a modified version of the bitmap.h file from Mitsuba 3.0 found at
+https://github.com/mitsuba-renderer/mitsuba3/blob/master/include/mitsuba/core/bitmap.h
+
+Original license below:
+
+Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+You are under no obligation whatsoever to provide any bug fixes, patches, or
+upgrades to the features, functionality or performance of the source code
+("Enhancements") to anyone; however, if you choose to make your Enhancements
+available either publicly, or directly to the author of this software, without
+imposing a separate written license agreement for such Enhancements, then you
+hereby grant the following license: a non-exclusive, royalty-free perpetual
+license to install, use, modify, prepare derivative works, incorporate into
+other computer software, distribute, and sublicense such enhancements or
+derivative works thereof, in binary and source code form.
+*/
+
+#pragma once
+
+#include "sgl/core/macros.h"
+#include "sgl/core/object.h"
+#include "sgl/core/enum.h"
+#include "sgl/core/stream.h"
+#include "sgl/core/struct.h"
+
+#include <filesystem>
+#include <future>
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+namespace sgl {
+
+class SGL_API Bitmap : public Object {
+    SGL_OBJECT(Bitmap)
+public:
+    enum class FileFormat {
+        unknown,
+        auto_,
+        png,
+        jpg,
+        bmp,
+        tga,
+        hdr,
+        exr,
+    };
+
+    SGL_ENUM_INFO(
+        FileFormat,
+        {
+            {FileFormat::unknown, "unknown"},
+            {FileFormat::auto_, "auto"},
+            {FileFormat::png, "png"},
+            {FileFormat::jpg, "jpg"},
+            {FileFormat::bmp, "bmp"},
+            {FileFormat::tga, "tga"},
+            {FileFormat::hdr, "hdr"},
+            {FileFormat::exr, "exr"},
+        }
+    );
+
+    enum class PixelFormat {
+        /// Luminance only.
+        y,
+        /// Luminance + alpha.
+        ya,
+        /// Red.
+        r,
+        /// Red + green.
+        rg,
+        /// RGB.
+        rgb,
+        /// RGB + alpha.
+        rgba,
+        /// Arbitrary multi-channel.
+        multi_channel,
+    };
+
+    static constexpr uint32_t PIXEL_FORMAT_COUNT = uint32_t(PixelFormat::multi_channel) + 1;
+
+    SGL_ENUM_INFO(
+        PixelFormat,
+        {
+            {PixelFormat::y, "y"},
+            {PixelFormat::ya, "ya"},
+            {PixelFormat::r, "r"},
+            {PixelFormat::rg, "rg"},
+            {PixelFormat::rgb, "rgb"},
+            {PixelFormat::rgba, "rgba"},
+            {PixelFormat::multi_channel, "multi_channel"},
+        }
+    );
+
+    using ComponentType = Struct::Type;
+
+    Bitmap(
+        PixelFormat pixel_format,
+        ComponentType component_type,
+        uint32_t width,
+        uint32_t height,
+        uint32_t channel_count = 0,
+        const std::vector<std::string>& channel_names = {},
+        void* data = nullptr
+    );
+
+    Bitmap(Stream* stream, FileFormat format = FileFormat::auto_);
+
+    Bitmap(const std::filesystem::path& path, FileFormat format = FileFormat::auto_);
+
+    /// Copy constructor.
+    Bitmap(const Bitmap& other);
+
+    /// Move constructor.
+    Bitmap(Bitmap&& other);
+
+    /// Destructor.
+    ~Bitmap();
+
+    /// Load a list of bitmaps from multiple paths. Uses multi-threading to load bitmaps in parallel.
+    static std::vector<ref<Bitmap>>
+    read_multiple(std::span<std::filesystem::path> paths, FileFormat format = FileFormat::auto_);
+
+    void write(Stream* stream, FileFormat format = FileFormat::auto_, int quality = -1) const;
+    void write(const std::filesystem::path& path, FileFormat format = FileFormat::auto_, int quality = -1) const;
+
+    void write_async(const std::filesystem::path& path, FileFormat format = FileFormat::auto_, int quality = -1) const;
+
+    /// The pixel format.
+    PixelFormat pixel_format() const { return m_pixel_format; }
+
+    /// The component type.
+    ComponentType component_type() const { return m_component_type; }
+
+    /// Struct describing the pixel layout.
+    const Struct* pixel_struct() const { return m_pixel_struct; }
+
+    /// The width of the bitmap in pixels.
+    uint32_t width() const { return m_width; }
+
+    /// The height of the bitmap in pixels.
+    uint32_t height() const { return m_height; }
+
+    /// The total number of pixels in the bitmap.
+    size_t pixel_count() const { return static_cast<size_t>(m_width) * m_height; }
+
+    /// The number of channels in the bitmap.
+    uint32_t channel_count() const { return static_cast<uint32_t>(m_pixel_struct->field_count()); }
+
+    /// The names of the channels in the bitmap.
+    std::vector<std::string> channel_names() const;
+
+    /// True if the bitmap is in sRGB gamma space.
+    bool srgb_gamma() const { return m_srgb_gamma; }
+
+    /// Set the sRGB gamma flag.
+    /// Note that this does not convert the pixel values, it only sets the flag and adjusts the pixel struct.
+    void set_srgb_gamma(bool srgb_gamma);
+
+    /// Returns true if the bitmap has an alpha channel.
+    bool has_alpha() const { return m_pixel_format == PixelFormat::ya || m_pixel_format == PixelFormat::rgba; }
+
+    /// The number of bytes per pixel.
+    size_t bytes_per_pixel() const { return m_pixel_struct->size(); }
+
+    /// The total size of the bitmap in bytes.
+    size_t buffer_size() const { return pixel_count() * bytes_per_pixel(); }
+
+    /// The raw image data.
+    void* data() { return m_data.get(); }
+    const void* data() const { return m_data.get(); }
+
+    /// The raw image data as uint8_t.
+    uint8_t* uint8_data() { return m_data.get(); }
+    const uint8_t* uint8_data() const { return m_data.get(); }
+
+    template<typename T>
+    T* data_as()
+    {
+        return reinterpret_cast<T*>(m_data.get());
+    }
+    template<typename T>
+    const T* data_as() const
+    {
+        return reinterpret_cast<const T*>(m_data.get());
+    }
+
+    /// True if bitmap is empty.
+    bool empty() const { return m_width == 0 || m_height == 0; }
+
+    /// Clears the bitmap to zeros.
+    void clear();
+
+    /// Vertically flip the bitmap.
+    void vflip();
+
+    /**
+     * \brief Split bitmap into multiple bitmaps, each containing the channels with the same prefix.
+     *
+     * For example, if the bitmap has channels `albedo.R`, `albedo.G`, `albedo.B`, `normal.R`, `normal.G`, `normal.B`,
+     * this function will return two bitmaps, one containing the channels `albedo.R`, `albedo.G`, `albedo.B` and the
+     * other containing the channels `normal.R`, `normal.G`, `normal.B`.
+     *
+     * Common pixel formats (e.g. `y`, `rgb`, `rgba`) are automatically detected and used for the split bitmaps.
+     *
+     * Any channels that do not have a prefix will be returned in the bitmap with the empty prefix.
+     *
+     * \return Returns a list of (prefix, bitmap) pairs.
+     */
+    std::vector<std::pair<std::string, ref<Bitmap>>> split() const;
+
+    ref<Bitmap> convert(PixelFormat pixel_format, ComponentType component_type, bool srgb_gamma) const;
+
+    void convert(Bitmap* target) const;
+
+    /// Equality operator.
+    bool operator==(const Bitmap& other) const;
+
+    /// Inequality operator.
+    bool operator!=(const Bitmap& other) const { return !operator==(other); }
+
+    std::string to_string() const override;
+
+    static FileFormat detect_file_format(Stream* stream);
+
+    static void static_init();
+    static void static_shutdown();
+
+private:
+    void rebuild_pixel_struct(uint32_t channel_count = 0, const std::vector<std::string>& channel_names = {});
+
+    void read(Stream* stream, FileFormat format);
+
+    void check_required_format(
+        std::string_view file_format,
+        std::vector<Bitmap::PixelFormat> allowed_pixel_formats,
+        std::vector<Bitmap::ComponentType> allowed_component_types
+    ) const;
+
+    void read_stb(Stream* stream, const char* format, bool is_srgb, bool is_hdr);
+
+    void read_png(Stream* stream);
+    void write_png(Stream* stream, int compression) const;
+
+    void read_jpg(Stream* stream);
+    void write_jpg(Stream* stream, int quality) const;
+
+    void read_bmp(Stream* stream);
+    void write_bmp(Stream* stream) const;
+
+    void read_tga(Stream* stream);
+    void write_tga(Stream* stream) const;
+
+    void read_hdr(Stream* stream);
+    void write_hdr(Stream* stream) const;
+
+    void read_exr(Stream* stream);
+    void write_exr(Stream* stream, int quality) const;
+
+    PixelFormat m_pixel_format;
+    ComponentType m_component_type;
+    ref<Struct> m_pixel_struct;
+    uint32_t m_width;
+    uint32_t m_height;
+    bool m_srgb_gamma;
+    std::unique_ptr<uint8_t[]> m_data;
+    bool m_owns_data;
+};
+
+SGL_ENUM_REGISTER(Bitmap::FileFormat);
+SGL_ENUM_REGISTER(Bitmap::PixelFormat);
+
+} // namespace sgl

sgl/include/sgl/core/crypto.h

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+
+#include <array>
+#include <string>
+#include <string_view>
+#include <cstdint>
+#include <cstdlib>
+
+namespace sgl {
+
+/**
+ * Helper to compute SHA-1 hash.
+ */
+class SGL_API SHA1 {
+public:
+    /// Message digest.
+    using Digest = std::array<uint8_t, 20>;
+
+    SHA1();
+
+    SHA1(const void* data, size_t len)
+        : SHA1()
+    {
+        update(data, len);
+    }
+
+    SHA1(std::string_view str)
+        : SHA1()
+    {
+        update(str);
+    }
+
+    SHA1(const SHA1&) = default;
+    SHA1(SHA1&&) = delete;
+
+    SHA1& operator=(const SHA1&) = default;
+    SHA1& operator=(SHA1&&) = delete;
+
+    /**
+     * Update hash by adding one byte.
+     * \param byte Byte to hash.
+     */
+    SHA1& update(uint8_t byte);
+
+    /**
+     * Update hash by adding the given data.
+     * \param data Data to hash.
+     * \param len Length of data in bytes.
+     */
+    SHA1& update(const void* data, size_t len);
+
+    /**
+     * Update hash by adding the given string.
+     * \param str String to hash.
+     */
+    SHA1& update(std::string_view str) { return update(str.data(), str.size()); }
+
+    /**
+     * Update hash by adding the given basic value.
+     * \param value to hash.
+     */
+    template<typename T>
+    SHA1& update(const T& value)
+        requires std::is_fundamental_v<T> || std::is_enum_v<T>
+    {
+        return update(&value, sizeof(value));
+    }
+
+    /// Return the message digest.
+    Digest digest() const;
+
+    /// Return the message digest as a hex string.
+    std::string hex_digest() const;
+
+private:
+    void add_byte(uint8_t x);
+    void process_block(const uint8_t* ptr);
+    Digest finalize();
+
+    uint32_t m_index;
+    uint64_t m_bits;
+    uint32_t m_state[5];
+    uint8_t m_buf[64];
+};
+}; // namespace sgl

sgl/include/sgl/core/data_type.h

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+#include "sgl/core/enum.h"
+
+namespace sgl {
+
+enum class DataType {
+    void_,
+    bool_,
+    int8,
+    int16,
+    int32,
+    int64,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    float16,
+    float32,
+    float64,
+};
+
+SGL_ENUM_INFO(
+    DataType,
+    {
+        {DataType::void_, "void"},
+        {DataType::bool_, "bool"},
+        {DataType::int8, "int8"},
+        {DataType::int16, "int16"},
+        {DataType::int32, "int32"},
+        {DataType::int64, "int64"},
+        {DataType::uint8, "uint8"},
+        {DataType::uint16, "uint16"},
+        {DataType::uint32, "uint32"},
+        {DataType::uint64, "uint64"},
+        {DataType::float16, "float16"},
+        {DataType::float32, "float32"},
+        {DataType::float64, "float64"},
+    }
+);
+SGL_ENUM_REGISTER(DataType);
+
+} // namespace sgl

sgl/include/sgl/core/dds_file.h

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/object.h"
+#include "sgl/core/enum.h"
+#include "sgl/core/stream.h"
+
+#include <filesystem>
+
+namespace sgl {
+
+/**
+ * \brief Helper class for loading DDS files.
+ */
+class SGL_API DDSFile : public Object {
+    SGL_OBJECT(DDSFile)
+public:
+    SGL_NON_COPYABLE_AND_MOVABLE(DDSFile);
+
+    explicit DDSFile(Stream* stream);
+    explicit DDSFile(const std::filesystem::path& path);
+    ~DDSFile();
+
+    enum class TextureType {
+        texture_1d,
+        texture_2d,
+        texture_3d,
+        texture_cube,
+    };
+
+    SGL_ENUM_INFO(
+        TextureType,
+        {
+            {TextureType::texture_1d, "texture_1d"},
+            {TextureType::texture_2d, "texture_2d"},
+            {TextureType::texture_3d, "texture_3d"},
+            {TextureType::texture_cube, "texture_cube"},
+        }
+    );
+
+    const uint8_t* data() const { return m_data; }
+    size_t size() const { return m_size; }
+
+    const uint8_t* resource_data() const { return m_data + m_header_size; }
+    size_t resource_size() const { return m_size - m_header_size; }
+
+    uint32_t dxgi_format() const { return m_dxgi_format; }
+    TextureType type() const { return m_type; }
+
+    uint32_t width() const { return m_width; }
+    uint32_t height() const { return m_height; }
+    uint32_t depth() const { return m_depth; }
+    uint32_t mip_count() const { return m_mip_count; }
+    uint32_t array_size() const { return m_array_size; }
+
+    uint32_t row_pitch() const { return m_row_pitch; }
+    uint32_t slice_pitch() const { return m_slice_pitch; }
+    uint32_t bits_per_pixel_or_block() const { return m_bits_per_pixel_or_block; }
+    uint32_t block_width() const { return m_block_width; }
+    uint32_t block_height() const { return m_block_height; }
+    bool compressed() const { return m_compressed; }
+    bool srgb() const { return m_srgb; }
+
+    /**
+     * \brief Get a pointer to the start of the data for the specified mip and slice.
+     *
+     * \param mip Mip level.
+     * \param slice Slice index (array index, face index  or volume slice index).
+     * \return Pointer to the start of the data.
+     */
+    const uint8_t* get_subresource_data(uint32_t mip, uint32_t slice);
+
+    virtual std::string to_string() const override;
+
+    static bool detect_dds_file(Stream* stream);
+
+private:
+    bool decode_header(const uint8_t* data, size_t size);
+
+    uint8_t* m_data{nullptr};
+    size_t m_size{0};
+
+    uint32_t m_dxgi_format;
+    TextureType m_type;
+    uint32_t m_width;
+    uint32_t m_height;
+    uint32_t m_depth;
+    uint32_t m_mip_count;
+    uint32_t m_array_size;
+    uint32_t m_row_pitch;
+    uint32_t m_slice_pitch;
+    uint32_t m_bits_per_pixel_or_block;
+    uint32_t m_block_width;
+    uint32_t m_block_height;
+    bool m_compressed;
+    bool m_srgb;
+    size_t m_header_size;
+};
+
+SGL_ENUM_REGISTER(DDSFile::TextureType);
+
+} // namespace sgl