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

sgl/include/sgl/device/native_formats.h

@@ -0,0 +1,342 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#include "sgl/device/formats.h"
+#include "sgl/core/macros.h"
+
+#if __has_include(<dxgiformat.h>)
+#include <dxgiformat.h>
+#else
+enum DXGI_FORMAT {
+    DXGI_FORMAT_UNKNOWN = 0,
+    DXGI_FORMAT_R32G32B32A32_TYPELESS = 1,
+    DXGI_FORMAT_R32G32B32A32_FLOAT = 2,
+    DXGI_FORMAT_R32G32B32A32_UINT = 3,
+    DXGI_FORMAT_R32G32B32A32_SINT = 4,
+    DXGI_FORMAT_R32G32B32_TYPELESS = 5,
+    DXGI_FORMAT_R32G32B32_FLOAT = 6,
+    DXGI_FORMAT_R32G32B32_UINT = 7,
+    DXGI_FORMAT_R32G32B32_SINT = 8,
+    DXGI_FORMAT_R16G16B16A16_TYPELESS = 9,
+    DXGI_FORMAT_R16G16B16A16_FLOAT = 10,
+    DXGI_FORMAT_R16G16B16A16_UNORM = 11,
+    DXGI_FORMAT_R16G16B16A16_UINT = 12,
+    DXGI_FORMAT_R16G16B16A16_SNORM = 13,
+    DXGI_FORMAT_R16G16B16A16_SINT = 14,
+    DXGI_FORMAT_R32G32_TYPELESS = 15,
+    DXGI_FORMAT_R32G32_FLOAT = 16,
+    DXGI_FORMAT_R32G32_UINT = 17,
+    DXGI_FORMAT_R32G32_SINT = 18,
+    DXGI_FORMAT_R32G8X24_TYPELESS = 19,
+    DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 20,
+    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = 21,
+    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22,
+    DXGI_FORMAT_R10G10B10A2_TYPELESS = 23,
+    DXGI_FORMAT_R10G10B10A2_UNORM = 24,
+    DXGI_FORMAT_R10G10B10A2_UINT = 25,
+    DXGI_FORMAT_R11G11B10_FLOAT = 26,
+    DXGI_FORMAT_R8G8B8A8_TYPELESS = 27,
+    DXGI_FORMAT_R8G8B8A8_UNORM = 28,
+    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29,
+    DXGI_FORMAT_R8G8B8A8_UINT = 30,
+    DXGI_FORMAT_R8G8B8A8_SNORM = 31,
+    DXGI_FORMAT_R8G8B8A8_SINT = 32,
+    DXGI_FORMAT_R16G16_TYPELESS = 33,
+    DXGI_FORMAT_R16G16_FLOAT = 34,
+    DXGI_FORMAT_R16G16_UNORM = 35,
+    DXGI_FORMAT_R16G16_UINT = 36,
+    DXGI_FORMAT_R16G16_SNORM = 37,
+    DXGI_FORMAT_R16G16_SINT = 38,
+    DXGI_FORMAT_R32_TYPELESS = 39,
+    DXGI_FORMAT_D32_FLOAT = 40,
+    DXGI_FORMAT_R32_FLOAT = 41,
+    DXGI_FORMAT_R32_UINT = 42,
+    DXGI_FORMAT_R32_SINT = 43,
+    DXGI_FORMAT_R24G8_TYPELESS = 44,
+    DXGI_FORMAT_D24_UNORM_S8_UINT = 45,
+    DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 46,
+    DXGI_FORMAT_X24_TYPELESS_G8_UINT = 47,
+    DXGI_FORMAT_R8G8_TYPELESS = 48,
+    DXGI_FORMAT_R8G8_UNORM = 49,
+    DXGI_FORMAT_R8G8_UINT = 50,
+    DXGI_FORMAT_R8G8_SNORM = 51,
+    DXGI_FORMAT_R8G8_SINT = 52,
+    DXGI_FORMAT_R16_TYPELESS = 53,
+    DXGI_FORMAT_R16_FLOAT = 54,
+    DXGI_FORMAT_D16_UNORM = 55,
+    DXGI_FORMAT_R16_UNORM = 56,
+    DXGI_FORMAT_R16_UINT = 57,
+    DXGI_FORMAT_R16_SNORM = 58,
+    DXGI_FORMAT_R16_SINT = 59,
+    DXGI_FORMAT_R8_TYPELESS = 60,
+    DXGI_FORMAT_R8_UNORM = 61,
+    DXGI_FORMAT_R8_UINT = 62,
+    DXGI_FORMAT_R8_SNORM = 63,
+    DXGI_FORMAT_R8_SINT = 64,
+    DXGI_FORMAT_A8_UNORM = 65,
+    DXGI_FORMAT_R1_UNORM = 66,
+    DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 67,
+    DXGI_FORMAT_R8G8_B8G8_UNORM = 68,
+    DXGI_FORMAT_G8R8_G8B8_UNORM = 69,
+    DXGI_FORMAT_BC1_TYPELESS = 70,
+    DXGI_FORMAT_BC1_UNORM = 71,
+    DXGI_FORMAT_BC1_UNORM_SRGB = 72,
+    DXGI_FORMAT_BC2_TYPELESS = 73,
+    DXGI_FORMAT_BC2_UNORM = 74,
+    DXGI_FORMAT_BC2_UNORM_SRGB = 75,
+    DXGI_FORMAT_BC3_TYPELESS = 76,
+    DXGI_FORMAT_BC3_UNORM = 77,
+    DXGI_FORMAT_BC3_UNORM_SRGB = 78,
+    DXGI_FORMAT_BC4_TYPELESS = 79,
+    DXGI_FORMAT_BC4_UNORM = 80,
+    DXGI_FORMAT_BC4_SNORM = 81,
+    DXGI_FORMAT_BC5_TYPELESS = 82,
+    DXGI_FORMAT_BC5_UNORM = 83,
+    DXGI_FORMAT_BC5_SNORM = 84,
+    DXGI_FORMAT_B5G6R5_UNORM = 85,
+    DXGI_FORMAT_B5G5R5A1_UNORM = 86,
+    DXGI_FORMAT_B8G8R8A8_UNORM = 87,
+    DXGI_FORMAT_B8G8R8X8_UNORM = 88,
+    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = 89,
+    DXGI_FORMAT_B8G8R8A8_TYPELESS = 90,
+    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = 91,
+    DXGI_FORMAT_B8G8R8X8_TYPELESS = 92,
+    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = 93,
+    DXGI_FORMAT_BC6H_TYPELESS = 94,
+    DXGI_FORMAT_BC6H_UF16 = 95,
+    DXGI_FORMAT_BC6H_SF16 = 96,
+    DXGI_FORMAT_BC7_TYPELESS = 97,
+    DXGI_FORMAT_BC7_UNORM = 98,
+    DXGI_FORMAT_BC7_UNORM_SRGB = 99,
+    DXGI_FORMAT_AYUV = 100,
+    DXGI_FORMAT_Y410 = 101,
+    DXGI_FORMAT_Y416 = 102,
+    DXGI_FORMAT_NV12 = 103,
+    DXGI_FORMAT_P010 = 104,
+    DXGI_FORMAT_P016 = 105,
+    DXGI_FORMAT_420_OPAQUE = 106,
+    DXGI_FORMAT_YUY2 = 107,
+    DXGI_FORMAT_Y210 = 108,
+    DXGI_FORMAT_Y216 = 109,
+    DXGI_FORMAT_NV11 = 110,
+    DXGI_FORMAT_AI44 = 111,
+    DXGI_FORMAT_IA44 = 112,
+    DXGI_FORMAT_P8 = 113,
+    DXGI_FORMAT_A8P8 = 114,
+    DXGI_FORMAT_B4G4R4A4_UNORM = 115,
+    DXGI_FORMAT_P208 = 130,
+    DXGI_FORMAT_V208 = 131,
+    DXGI_FORMAT_V408 = 132,
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE = 189,
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190,
+    DXGI_FORMAT_FORCE_UINT = 0xffffffff
+};
+#endif
+
+#if __has_include(<vulkan/vulkan.h>)
+#include <vulkan/vulkan.h>
+#else
+typedef enum VkFormat {
+    VK_FORMAT_UNDEFINED = 0,
+    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
+    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
+    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
+    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
+    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
+    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
+    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
+    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
+    VK_FORMAT_R8_UNORM = 9,
+    VK_FORMAT_R8_SNORM = 10,
+    VK_FORMAT_R8_USCALED = 11,
+    VK_FORMAT_R8_SSCALED = 12,
+    VK_FORMAT_R8_UINT = 13,
+    VK_FORMAT_R8_SINT = 14,
+    VK_FORMAT_R8_SRGB = 15,
+    VK_FORMAT_R8G8_UNORM = 16,
+    VK_FORMAT_R8G8_SNORM = 17,
+    VK_FORMAT_R8G8_USCALED = 18,
+    VK_FORMAT_R8G8_SSCALED = 19,
+    VK_FORMAT_R8G8_UINT = 20,
+    VK_FORMAT_R8G8_SINT = 21,
+    VK_FORMAT_R8G8_SRGB = 22,
+    VK_FORMAT_R8G8B8_UNORM = 23,
+    VK_FORMAT_R8G8B8_SNORM = 24,
+    VK_FORMAT_R8G8B8_USCALED = 25,
+    VK_FORMAT_R8G8B8_SSCALED = 26,
+    VK_FORMAT_R8G8B8_UINT = 27,
+    VK_FORMAT_R8G8B8_SINT = 28,
+    VK_FORMAT_R8G8B8_SRGB = 29,
+    VK_FORMAT_B8G8R8_UNORM = 30,
+    VK_FORMAT_B8G8R8_SNORM = 31,
+    VK_FORMAT_B8G8R8_USCALED = 32,
+    VK_FORMAT_B8G8R8_SSCALED = 33,
+    VK_FORMAT_B8G8R8_UINT = 34,
+    VK_FORMAT_B8G8R8_SINT = 35,
+    VK_FORMAT_B8G8R8_SRGB = 36,
+    VK_FORMAT_R8G8B8A8_UNORM = 37,
+    VK_FORMAT_R8G8B8A8_SNORM = 38,
+    VK_FORMAT_R8G8B8A8_USCALED = 39,
+    VK_FORMAT_R8G8B8A8_SSCALED = 40,
+    VK_FORMAT_R8G8B8A8_UINT = 41,
+    VK_FORMAT_R8G8B8A8_SINT = 42,
+    VK_FORMAT_R8G8B8A8_SRGB = 43,
+    VK_FORMAT_B8G8R8A8_UNORM = 44,
+    VK_FORMAT_B8G8R8A8_SNORM = 45,
+    VK_FORMAT_B8G8R8A8_USCALED = 46,
+    VK_FORMAT_B8G8R8A8_SSCALED = 47,
+    VK_FORMAT_B8G8R8A8_UINT = 48,
+    VK_FORMAT_B8G8R8A8_SINT = 49,
+    VK_FORMAT_B8G8R8A8_SRGB = 50,
+    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
+    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
+    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
+    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
+    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
+    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
+    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
+    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
+    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
+    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
+    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
+    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
+    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
+    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
+    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
+    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
+    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
+    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
+    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
+    VK_FORMAT_R16_UNORM = 70,
+    VK_FORMAT_R16_SNORM = 71,
+    VK_FORMAT_R16_USCALED = 72,
+    VK_FORMAT_R16_SSCALED = 73,
+    VK_FORMAT_R16_UINT = 74,
+    VK_FORMAT_R16_SINT = 75,
+    VK_FORMAT_R16_SFLOAT = 76,
+    VK_FORMAT_R16G16_UNORM = 77,
+    VK_FORMAT_R16G16_SNORM = 78,
+    VK_FORMAT_R16G16_USCALED = 79,
+    VK_FORMAT_R16G16_SSCALED = 80,
+    VK_FORMAT_R16G16_UINT = 81,
+    VK_FORMAT_R16G16_SINT = 82,
+    VK_FORMAT_R16G16_SFLOAT = 83,
+    VK_FORMAT_R16G16B16_UNORM = 84,
+    VK_FORMAT_R16G16B16_SNORM = 85,
+    VK_FORMAT_R16G16B16_USCALED = 86,
+    VK_FORMAT_R16G16B16_SSCALED = 87,
+    VK_FORMAT_R16G16B16_UINT = 88,
+    VK_FORMAT_R16G16B16_SINT = 89,
+    VK_FORMAT_R16G16B16_SFLOAT = 90,
+    VK_FORMAT_R16G16B16A16_UNORM = 91,
+    VK_FORMAT_R16G16B16A16_SNORM = 92,
+    VK_FORMAT_R16G16B16A16_USCALED = 93,
+    VK_FORMAT_R16G16B16A16_SSCALED = 94,
+    VK_FORMAT_R16G16B16A16_UINT = 95,
+    VK_FORMAT_R16G16B16A16_SINT = 96,
+    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
+    VK_FORMAT_R32_UINT = 98,
+    VK_FORMAT_R32_SINT = 99,
+    VK_FORMAT_R32_SFLOAT = 100,
+    VK_FORMAT_R32G32_UINT = 101,
+    VK_FORMAT_R32G32_SINT = 102,
+    VK_FORMAT_R32G32_SFLOAT = 103,
+    VK_FORMAT_R32G32B32_UINT = 104,
+    VK_FORMAT_R32G32B32_SINT = 105,
+    VK_FORMAT_R32G32B32_SFLOAT = 106,
+    VK_FORMAT_R32G32B32A32_UINT = 107,
+    VK_FORMAT_R32G32B32A32_SINT = 108,
+    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
+    VK_FORMAT_R64_UINT = 110,
+    VK_FORMAT_R64_SINT = 111,
+    VK_FORMAT_R64_SFLOAT = 112,
+    VK_FORMAT_R64G64_UINT = 113,
+    VK_FORMAT_R64G64_SINT = 114,
+    VK_FORMAT_R64G64_SFLOAT = 115,
+    VK_FORMAT_R64G64B64_UINT = 116,
+    VK_FORMAT_R64G64B64_SINT = 117,
+    VK_FORMAT_R64G64B64_SFLOAT = 118,
+    VK_FORMAT_R64G64B64A64_UINT = 119,
+    VK_FORMAT_R64G64B64A64_SINT = 120,
+    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
+    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
+    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
+    VK_FORMAT_D16_UNORM = 124,
+    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
+    VK_FORMAT_D32_SFLOAT = 126,
+    VK_FORMAT_S8_UINT = 127,
+    VK_FORMAT_D16_UNORM_S8_UINT = 128,
+    VK_FORMAT_D24_UNORM_S8_UINT = 129,
+    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
+    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
+    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
+    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
+    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
+    VK_FORMAT_BC2_UNORM_BLOCK = 135,
+    VK_FORMAT_BC2_SRGB_BLOCK = 136,
+    VK_FORMAT_BC3_UNORM_BLOCK = 137,
+    VK_FORMAT_BC3_SRGB_BLOCK = 138,
+    VK_FORMAT_BC4_UNORM_BLOCK = 139,
+    VK_FORMAT_BC4_SNORM_BLOCK = 140,
+    VK_FORMAT_BC5_UNORM_BLOCK = 141,
+    VK_FORMAT_BC5_SNORM_BLOCK = 142,
+    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
+    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
+    VK_FORMAT_BC7_UNORM_BLOCK = 145,
+    VK_FORMAT_BC7_SRGB_BLOCK = 146,
+    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
+    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
+    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
+    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
+    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
+    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
+    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
+    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
+    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
+    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
+    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
+    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
+    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
+    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
+    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
+    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
+    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
+    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
+    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
+    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
+    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
+    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
+    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
+    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
+    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
+    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
+    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
+    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
+    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
+    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
+    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
+    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
+    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
+    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
+    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
+    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
+    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
+    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+} VkFormat;
+#endif
+
+namespace sgl {
+
+/// Convert from sgl to DXGI format.
+DXGI_FORMAT SGL_API get_dxgi_format(Format format);
+
+/// Convert from DXGI to sgl format.
+Format SGL_API get_format(DXGI_FORMAT dxgi_format);
+
+/// Convert from sgl to Vulkan format.
+VkFormat SGL_API get_vulkan_format(Format format);
+
+/// Convert from Vulkan to sgl format.
+Format SGL_API get_format(VkFormat vk_format);
+
+} // namespace sgl

sgl/include/sgl/device/native_handle.h

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/error.h"
+
+#include <cstdint>
+
+namespace sgl {
+
+enum class NativeHandleType {
+    unknown,
+
+    ID3D12Device,
+    ID3D12Resource,
+    ID3D12PipelineState,
+    ID3D12Fence,
+    ID3D12CommandQueue,
+    ID3D12GraphicsCommandList,
+    D3D12_CPU_DESCRIPTOR_HANDLE,
+
+    VkInstance,
+    VkPhysicalDevice,
+    VkDevice,
+    VkImage,
+    VkImageView,
+    VkBuffer,
+    VkBufferView,
+    VkPipeline,
+    VkFence,
+    VkQueue,
+    VkCommandBuffer,
+    VkSampler,
+};
+
+template<typename T>
+struct NativeHandleTrait;
+
+/// Represents a native graphics API handle (e.g. D3D12 or Vulkan).
+/// Native handles are expected to fit into 64 bits.
+/// Type information and conversion from/to native handles is done
+/// using type traits from native_handle_traits.h which needs to be
+/// included when creating and accessing NativeHandle.
+/// This separation is done so we don't expose the heavy D3D12/Vulkan
+/// headers everywhere.
+class NativeHandle {
+public:
+    NativeHandle() = default;
+
+    template<typename T>
+    explicit NativeHandle(T native)
+    {
+        m_type = NativeHandleTrait<T>::type;
+        m_value = NativeHandleTrait<T>::pack(native);
+    }
+
+    NativeHandleType type() const { return m_type; }
+
+    bool is_valid() const { return m_type != NativeHandleType::unknown; }
+
+    template<typename T>
+    T as() const
+    {
+        SGL_ASSERT(m_type == NativeHandleTrait<T>::type);
+        return NativeHandleTrait<T>::unpack(m_value);
+    }
+
+private:
+    NativeHandleType m_type{NativeHandleType::unknown};
+    uint64_t m_value{0};
+};
+
+} // namespace sgl

sgl/include/sgl/device/native_handle_traits.h

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "native_handle.h"
+
+#include "sgl/core/config.h"
+
+#if SGL_HAS_D3D12
+#include <d3d12.h>
+#endif
+
+#if SGL_HAS_VULKAN
+#include <vulkan/vulkan.h>
+#endif
+
+#include "sgl/stl/bit.h" // Replace with <bit> when available on all platforms.
+
+namespace sgl {
+
+template<typename T>
+struct NativeHandleTrait { };
+
+#define SGL_NATIVE_HANDLE(T, TYPE)                                                                                     \
+    template<>                                                                                                         \
+    struct NativeHandleTrait<T> {                                                                                      \
+        static const NativeHandleType type = TYPE;                                                                     \
+        static uint64_t pack(T native)                                                                                 \
+        {                                                                                                              \
+            return stdx::bit_cast<uint64_t>(native);                                                                   \
+        }                                                                                                              \
+        static T unpack(uint64_t value)                                                                                \
+        {                                                                                                              \
+            return stdx::bit_cast<T>(value);                                                                           \
+        }                                                                                                              \
+    };
+
+#if SGL_HAS_D3D12
+SGL_NATIVE_HANDLE(ID3D12Device*, NativeHandleType::ID3D12Device);
+SGL_NATIVE_HANDLE(ID3D12Resource*, NativeHandleType::ID3D12Resource);
+SGL_NATIVE_HANDLE(ID3D12PipelineState*, NativeHandleType::ID3D12PipelineState);
+SGL_NATIVE_HANDLE(ID3D12Fence*, NativeHandleType::ID3D12Fence);
+SGL_NATIVE_HANDLE(ID3D12CommandQueue*, NativeHandleType::ID3D12CommandQueue);
+SGL_NATIVE_HANDLE(ID3D12GraphicsCommandList*, NativeHandleType::ID3D12GraphicsCommandList);
+SGL_NATIVE_HANDLE(D3D12_CPU_DESCRIPTOR_HANDLE, NativeHandleType::D3D12_CPU_DESCRIPTOR_HANDLE);
+#endif // SGL_HAS_D3D12
+
+#if SGL_HAS_VULKAN
+SGL_NATIVE_HANDLE(VkInstance, NativeHandleType::VkInstance);
+SGL_NATIVE_HANDLE(VkPhysicalDevice, NativeHandleType::VkPhysicalDevice);
+SGL_NATIVE_HANDLE(VkDevice, NativeHandleType::VkDevice);
+SGL_NATIVE_HANDLE(VkImage, NativeHandleType::VkImage);
+SGL_NATIVE_HANDLE(VkImageView, NativeHandleType::VkImageView);
+SGL_NATIVE_HANDLE(VkBuffer, NativeHandleType::VkBuffer);
+SGL_NATIVE_HANDLE(VkBufferView, NativeHandleType::VkBufferView);
+SGL_NATIVE_HANDLE(VkPipeline, NativeHandleType::VkPipeline);
+SGL_NATIVE_HANDLE(VkFence, NativeHandleType::VkFence);
+SGL_NATIVE_HANDLE(VkQueue, NativeHandleType::VkQueue);
+SGL_NATIVE_HANDLE(VkCommandBuffer, NativeHandleType::VkCommandBuffer);
+SGL_NATIVE_HANDLE(VkSampler, NativeHandleType::VkSampler);
+#endif // SGL_HAS_VULKAN
+
+#undef SGL_NATIVE_HANDLE
+
+} // namespace sgl

sgl/include/sgl/device/pipeline.h

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/device_resource.h"
+#include "sgl/device/types.h"
+#include "sgl/device/native_handle.h"
+
+#include "sgl/core/macros.h"
+#include "sgl/core/enum.h"
+#include "sgl/core/object.h"
+
+#include "sgl/math/vector_types.h"
+
+#include <slang-gfx.h>
+
+#include <map>
+#include <set>
+
+namespace sgl {
+
+
+/// Pipeline base class.
+class SGL_API Pipeline : public DeviceResource {
+    SGL_OBJECT(Pipeline)
+public:
+    Pipeline(ref<Device> device, ref<ShaderProgram> program);
+    virtual ~Pipeline();
+
+    gfx::IPipelineState* gfx_pipeline_state() const { return m_gfx_pipeline_state; }
+
+    /// Returns the native API handle:
+    /// - D3D12: ID3D12PipelineState*
+    /// - Vulkan: VkPipeline
+    NativeHandle get_native_handle() const;
+
+    void notify_program_reloaded();
+
+protected:
+    virtual void recreate() = 0;
+
+    Slang::ComPtr<gfx::IPipelineState> m_gfx_pipeline_state;
+
+private:
+    /// Pipelines store program (and thus maintain the ref count)
+    /// in their descriptor - this is just so we can register/unregister
+    /// the with program. However due to order of destruction
+    /// this still needs to hold a strong reference.
+    ref<ShaderProgram> m_program;
+};
+
+struct ComputePipelineDesc {
+    ref<ShaderProgram> program;
+};
+
+/// Compute pipeline.
+class SGL_API ComputePipeline : public Pipeline {
+public:
+    ComputePipeline(ref<Device> device, ComputePipelineDesc desc);
+
+    const ComputePipelineDesc& desc() const { return m_desc; }
+
+    /// Thread group size.
+    /// Used to determine the number of thread groups to dispatch.
+    uint3 thread_group_size() const { return m_thread_group_size; }
+
+    std::string to_string() const override;
+
+protected:
+    virtual void recreate() override;
+
+private:
+    ComputePipelineDesc m_desc;
+    uint3 m_thread_group_size;
+};
+
+struct GraphicsPipelineDesc {
+    ref<ShaderProgram> program;
+    ref<InputLayout> input_layout;
+    ref<FramebufferLayout> framebuffer_layout;
+    PrimitiveType primitive_type{PrimitiveType::triangle};
+    DepthStencilDesc depth_stencil;
+    RasterizerDesc rasterizer;
+    BlendDesc blend;
+};
+
+/// Graphics pipeline.
+class SGL_API GraphicsPipeline : public Pipeline {
+public:
+    GraphicsPipeline(ref<Device> device, GraphicsPipelineDesc desc);
+
+    std::string to_string() const override;
+    const GraphicsPipelineDesc& desc() const { return m_desc; }
+
+protected:
+    virtual void recreate() override;
+
+private:
+    GraphicsPipelineDesc m_desc;
+
+    // These are stored to ensure the layouts aren't freed when pipeline
+    // relies on them if it needs to be recreated for hot reload.
+    ref<const InputLayout> m_stored_input_layout;
+    ref<const FramebufferLayout> m_stored_framebuffer_layout;
+};
+
+struct HitGroupDesc {
+    std::string hit_group_name;
+    std::string closest_hit_entry_point;
+    std::string any_hit_entry_point;
+    std::string intersection_entry_point;
+};
+
+struct RayTracingPipelineDesc {
+    ref<ShaderProgram> program;
+    std::vector<HitGroupDesc> hit_groups;
+    uint32_t max_recursion{0};
+    uint32_t max_ray_payload_size{0};
+    uint32_t max_attribute_size{8};
+    RayTracingPipelineFlags flags{RayTracingPipelineFlags::none};
+};
+
+/// Ray tracing pipeline.
+class SGL_API RayTracingPipeline : public Pipeline {
+public:
+    RayTracingPipeline(ref<Device> device, RayTracingPipelineDesc desc);
+
+    std::string to_string() const override;
+
+protected:
+    virtual void recreate() override;
+
+private:
+    RayTracingPipelineDesc m_desc;
+};
+
+} // namespace sgl

sgl/include/sgl/device/print.h

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/shader_cursor.h"
+
+#include <map>
+#include <string>
+
+namespace sgl {
+
+/**
+ * \brief Debug printer.
+ *
+ * This class implements host-side support for shader debug printing.
+ */
+class DebugPrinter {
+public:
+    DebugPrinter(Device* device, size_t buffer_size = 4 * 1024 * 1024);
+
+    /// Add a map of hashed strings to the printer.
+    /// This needs to be called for any shader that uses debug printing.
+    void add_hashed_strings(const std::map<uint32_t, std::string>& hashed_strings);
+
+    /// Flush the print buffer and output any messages to stdout.
+    void flush();
+
+    /// Flush the print buffer and output any messages as a string.
+    std::string flush_to_string();
+
+    void bind(ShaderCursor cursor);
+
+private:
+    void flush_device(bool wait);
+
+    Device* m_device;
+
+    ref<Buffer> m_buffer;
+    ref<Buffer> m_readback_buffer;
+
+    std::map<uint32_t, std::string> m_hashed_strings;
+};
+
+} // namespace sgl