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

sgl/include/sgl/device/shader_object.h

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/config.h"
+#include "sgl/core/object.h"
+#include "sgl/core/type_utils.h"
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/shader_offset.h"
+#include "sgl/device/resource.h"
+
+#include <slang-gfx.h>
+
+#include <string_view>
+#include <vector>
+#include <map>
+
+namespace sgl {
+
+class SGL_API ShaderObject : public Object {
+    SGL_OBJECT(ShaderObject)
+public:
+    ShaderObject(ref<Device> device, gfx::IShaderObject* shader_object);
+
+    virtual ref<const TypeLayoutReflection> element_type_layout() const;
+
+    virtual uint32_t get_entry_point_count() const;
+    virtual ref<ShaderObject> get_entry_point(uint32_t index) = 0;
+
+    virtual ref<ShaderObject> get_object(const ShaderOffset& offset) = 0;
+    virtual void set_object(const ShaderOffset& offset, const ref<ShaderObject>& object);
+
+    virtual void set_resource(const ShaderOffset& offset, const ref<ResourceView>& resource_view);
+    virtual void set_sampler(const ShaderOffset& offset, const ref<Sampler>& sampler);
+    virtual void
+    set_acceleration_structure(const ShaderOffset& offset, const ref<AccelerationStructure>& acceleration_structure);
+    virtual void set_data(const ShaderOffset& offset, void const* data, size_t size);
+
+    virtual void set_cuda_tensor_view(const ShaderOffset& offset, const cuda::TensorView& tensor_view, bool is_uav);
+    virtual void get_cuda_interop_buffers(std::vector<ref<cuda::InteropBuffer>>& cuda_interop_buffers) const;
+
+    gfx::IShaderObject* gfx_shader_object() const { return m_shader_object; }
+
+protected:
+    ref<Device> m_device;
+    gfx::IShaderObject* m_shader_object;
+    std::vector<ref<cuda::InteropBuffer>> m_cuda_interop_buffers;
+};
+
+class SGL_API TransientShaderObject : public ShaderObject {
+    SGL_OBJECT(TransientShaderObject)
+public:
+    TransientShaderObject(ref<Device> device, gfx::IShaderObject* shader_object, CommandBuffer* command_buffer);
+
+    virtual ref<ShaderObject> get_entry_point(uint32_t index) override;
+
+    virtual ref<ShaderObject> get_object(const ShaderOffset& offset) override;
+    virtual void set_object(const ShaderOffset& offset, const ref<ShaderObject>& object) override;
+
+    virtual void set_resource(const ShaderOffset& offset, const ref<ResourceView>& resource_view) override;
+
+    virtual void get_cuda_interop_buffers(std::vector<ref<cuda::InteropBuffer>>& cuda_interop_buffers) const override;
+
+private:
+    CommandBuffer* m_command_buffer;
+    std::vector<ref<TransientShaderObject>> m_sub_objects;
+};
+
+class SGL_API MutableShaderObject : public ShaderObject {
+    SGL_OBJECT(MutableShaderObject)
+public:
+    MutableShaderObject(ref<Device> device, gfx::IShaderObject* shader_object);
+    MutableShaderObject(ref<Device> device, const ShaderProgram* shader_program);
+    MutableShaderObject(ref<Device> device, const TypeLayoutReflection* type_layout);
+    ~MutableShaderObject();
+
+    virtual ref<ShaderObject> get_entry_point(uint32_t index) override;
+
+    virtual ref<ShaderObject> get_object(const ShaderOffset& offset) override;
+    virtual void set_object(const ShaderOffset& offset, const ref<ShaderObject>& object) override;
+
+    virtual void set_resource(const ShaderOffset& offset, const ref<ResourceView>& resource_view) override;
+
+    void set_resource_states(CommandBuffer* command_buffer) const;
+
+    virtual void get_cuda_interop_buffers(std::vector<ref<cuda::InteropBuffer>>& cuda_interop_buffers) const override;
+
+private:
+    std::map<ShaderOffset, ref<ResourceView>> m_resource_views;
+    std::map<ShaderOffset, ref<MutableShaderObject>> m_sub_objects;
+};
+
+} // namespace sgl

sgl/include/sgl/device/shader_offset.h

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstdint>
+#include <compare>
+
+namespace sgl {
+
+/**
+ * Represents the offset of a shader variable relative to its enclosing type/buffer/block.
+ *
+ * A `ShaderOffset` can be used to store the offset of a shader variable that might use
+ * ordinary/uniform data, resources like textures/buffers/samplers, or some combination.
+ *
+ * A `ShaderOffset` can also encode an invalid offset, to indicate that a particular
+ * shader variable is not present.
+ */
+struct ShaderOffset {
+    uint32_t uniform_offset{INVALID};
+    uint32_t binding_range_index{INVALID};
+    uint32_t binding_array_index{INVALID};
+
+    /// Create an invalid offset.
+    static ShaderOffset invalid() { return {}; }
+
+    /// Create a zero offset.
+    static ShaderOffset zero() { return ShaderOffset(0, 0, 0); }
+
+    /// Default constructor. Creates an invalid offset.
+    ShaderOffset() = default;
+
+    /// Constructor.
+    ShaderOffset(uint32_t uniform_offset_, uint32_t binding_range_index_, uint32_t binding_array_index_)
+        : uniform_offset(uniform_offset_)
+        , binding_range_index(binding_range_index_)
+        , binding_array_index(binding_array_index_)
+    {
+    }
+
+    /// Check whether this offset is valid.
+    bool is_valid() const { return uniform_offset != INVALID; }
+
+    /// Adds another offset to this offset.
+    /// Returns an invalid offset if either offset is invalid.
+    ShaderOffset operator+(const ShaderOffset& other) const
+    {
+        if (is_valid() && other.is_valid()) {
+            return ShaderOffset(
+                uniform_offset + other.uniform_offset,
+                binding_range_index + other.binding_range_index,
+                binding_array_index + other.binding_array_index
+            );
+        } else {
+            return {};
+        }
+    }
+
+    /// Comparison.
+    auto operator<=>(const ShaderOffset&) const = default;
+
+private:
+    /// Invalid offset value.
+    static constexpr uint32_t INVALID = uint32_t(-1);
+};
+
+} // namespace sgl

sgl/include/sgl/device/shared_handle.h

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstdint>
+
+namespace sgl {
+
+using SharedResourceHandle = uintptr_t;
+using SharedFenceHandle = uintptr_t;
+
+} // namespace sgl

sgl/include/sgl/device/slang_utils.h

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <slang.h>
+#include <slang-com-ptr.h>
+
+#define SGL_CATCH_INTERNAL_SLANG_ERROR(expr)                                                                           \
+    try {                                                                                                              \
+        expr;                                                                                                          \
+    } catch (...) {                                                                                                    \
+        const char* slang_error = slang::getLastInternalErrorMessage();                                                \
+        throw sgl::SlangCompileError(fmt::format("Internal slang error: {}", slang_error));                            \
+    }
+
+namespace sgl {
+
+/// Implementation of slang's ISlangBlob interface to access an unowned blob of data.
+class UnownedSlangBlob : public ISlangBlob {
+public:
+    UnownedSlangBlob(const void* data, size_t size)
+        : m_data(data)
+        , m_size(size)
+    {
+    }
+
+    virtual SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() override { return m_data; }
+    virtual SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() override { return m_size; }
+
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) override
+    {
+        if (uuid == SLANG_UUID_ISlangBlob) {
+            *outObject = static_cast<ISlangBlob*>(this);
+            return SLANG_OK;
+        }
+        return SLANG_E_NO_INTERFACE;
+    }
+
+    virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() override
+    {
+        // Do not perform any reference counting.
+        return 2;
+    }
+
+    virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() override
+    {
+        // Do not perform any reference counting.
+        return 2;
+    }
+
+private:
+    const void* m_data;
+    size_t m_size;
+};
+
+} // namespace sgl

sgl/include/sgl/device/swapchain.h

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/formats.h"
+
+#include "sgl/core/macros.h"
+#include "sgl/core/platform.h"
+#include "sgl/core/object.h"
+
+#include <slang-gfx.h>
+
+namespace sgl {
+
+class Window;
+
+struct SwapchainDesc {
+    /// Format of the swapchain images.
+    Format format{Format::bgra8_unorm_srgb};
+    /// Width of the swapchain images in pixels.
+    uint32_t width{0};
+    /// Height of the swapchain images in pixels.
+    uint32_t height{0};
+    /// Number of swapchain images.
+    uint32_t image_count{3};
+    /// Enable/disable vertical synchronization.
+    bool enable_vsync{false};
+};
+
+class SGL_API Swapchain : public Object {
+    SGL_OBJECT(Swapchain)
+public:
+    Swapchain(SwapchainDesc desc, WindowHandle window_handle, ref<Device> device);
+    Swapchain(SwapchainDesc desc, Window* window, ref<Device> device);
+    ~Swapchain();
+
+    /// Returns the swapchain description.
+    const SwapchainDesc& desc() const { return m_desc; }
+
+    /// Returns the back buffer images.
+    const std::vector<ref<Texture>>& images() const { return m_images; }
+
+    /// Returns the back buffer image at position `index`.
+    const ref<Texture>& get_image(uint32_t index) const;
+
+    /// Present the next image in the swapchain.
+    void present();
+
+    /// Returns the index of next back buffer image that will be presented in the next `present` call.
+    /// Returns -1 if no image is available and the caller should skip the frame.
+    int acquire_next_image();
+
+    /// Resizes the back buffers of this swapchain. All render target views and framebuffers
+    /// referencing the back buffer images must be freed before calling this method.
+    void resize(uint32_t width, uint32_t height);
+
+    /// Returns true if the window is occluded.
+    bool is_occluded() const;
+
+    bool fullscreen_mode() const { return m_fullscreen; }
+    void set_fullscreen_mode(bool fullscreen);
+
+
+private:
+    void get_images();
+
+    SwapchainDesc m_desc;
+    ref<Device> m_device;
+    Slang::ComPtr<gfx::ISwapchain> m_gfx_swapchain;
+    bool m_fullscreen{false};
+    std::vector<ref<Texture>> m_images;
+};
+} // namespace sgl