nv-sgl 0.6.0__cp313-cp313-win_amd64.whl

sgl/shaders/nvapi/nvShaderExtnEnums.h

@@ -0,0 +1,142 @@
+/*********************************************************************************************************\
+|*                                                                                                        *|
+|* SPDX-FileCopyrightText: Copyright (c) 2019-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.  *|
+|* SPDX-License-Identifier: MIT                                                                           *|
+|*                                                                                                        *|
+|* Permission is hereby granted, free of charge, to any person obtaining a                                *|
+|* copy of this software and associated documentation files (the "Software"),                             *|
+|* to deal in the Software without restriction, including without limitation                              *|
+|* the rights to use, copy, modify, merge, publish, distribute, sublicense,                               *|
+|* and/or sell copies of the Software, and to permit persons to whom the                                  *|
+|* Software is furnished to do so, subject to the following conditions:                                   *|
+|*                                                                                                        *|
+|* The above copyright notice and this permission notice shall be included in                             *|
+|* all copies or substantial portions of the Software.                                                    *|
+|*                                                                                                        *|
+|* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR                             *|
+|* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,                               *|
+|* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL                               *|
+|* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER                             *|
+|* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING                                *|
+|* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER                                    *|
+|* DEALINGS IN THE SOFTWARE.                                                                              *|
+|*                                                                                                        *|
+|*                                                                                                        *|
+\*********************************************************************************************************/
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////// NVIDIA SHADER EXTENSIONS ////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// This file can be included both from HLSL shader code as well as C++ code.
+// The app should call NvAPI_D3D11_IsNvShaderExtnOpCodeSupported() / NvAPI_D3D12_IsNvShaderExtnOpCodeSupported()
+// to check for support for every nv shader extension opcode it plans to use
+
+
+
+//----------------------------------------------------------------------------//
+//---------------------------- NV Shader Extn Version  -----------------------//
+//----------------------------------------------------------------------------//
+#define NV_SHADER_EXTN_VERSION                              1
+
+//----------------------------------------------------------------------------//
+//---------------------------- Misc constants --------------------------------//
+//----------------------------------------------------------------------------//
+#define NV_WARP_SIZE                                       32
+#define NV_WARP_SIZE_LOG2                                   5
+
+//----------------------------------------------------------------------------//
+//---------------------------- opCode constants ------------------------------//
+//----------------------------------------------------------------------------//
+
+
+#define NV_EXTN_OP_SHFL                                     1
+#define NV_EXTN_OP_SHFL_UP                                  2
+#define NV_EXTN_OP_SHFL_DOWN                                3
+#define NV_EXTN_OP_SHFL_XOR                                 4
+
+#define NV_EXTN_OP_VOTE_ALL                                 5
+#define NV_EXTN_OP_VOTE_ANY                                 6
+#define NV_EXTN_OP_VOTE_BALLOT                              7
+
+#define NV_EXTN_OP_GET_LANE_ID                              8
+#define NV_EXTN_OP_FP16_ATOMIC                             12
+#define NV_EXTN_OP_FP32_ATOMIC                             13
+
+#define NV_EXTN_OP_GET_SPECIAL                             19
+
+#define NV_EXTN_OP_UINT64_ATOMIC                           20
+
+#define NV_EXTN_OP_MATCH_ANY                               21 
+
+// FOOTPRINT - For Sample and SampleBias
+#define NV_EXTN_OP_FOOTPRINT                               28
+#define NV_EXTN_OP_FOOTPRINT_BIAS                          29
+
+#define NV_EXTN_OP_GET_SHADING_RATE                        30
+
+// FOOTPRINT - For SampleLevel and SampleGrad
+#define NV_EXTN_OP_FOOTPRINT_LEVEL                         31
+#define NV_EXTN_OP_FOOTPRINT_GRAD                          32
+
+// SHFL Generic
+#define NV_EXTN_OP_SHFL_GENERIC                            33
+
+#define NV_EXTN_OP_VPRS_EVAL_ATTRIB_AT_SAMPLE              51
+#define NV_EXTN_OP_VPRS_EVAL_ATTRIB_SNAPPED                52
+
+// HitObject API
+#define NV_EXTN_OP_HIT_OBJECT_TRACE_RAY                    67
+#define NV_EXTN_OP_HIT_OBJECT_MAKE_HIT                     68
+#define NV_EXTN_OP_HIT_OBJECT_MAKE_HIT_WITH_RECORD_INDEX   69
+#define NV_EXTN_OP_HIT_OBJECT_MAKE_MISS                    70
+#define NV_EXTN_OP_HIT_OBJECT_REORDER_THREAD               71
+#define NV_EXTN_OP_HIT_OBJECT_INVOKE                       72
+#define NV_EXTN_OP_HIT_OBJECT_IS_MISS                      73
+#define NV_EXTN_OP_HIT_OBJECT_GET_INSTANCE_ID              74
+#define NV_EXTN_OP_HIT_OBJECT_GET_INSTANCE_INDEX           75
+#define NV_EXTN_OP_HIT_OBJECT_GET_PRIMITIVE_INDEX          76
+#define NV_EXTN_OP_HIT_OBJECT_GET_GEOMETRY_INDEX           77
+#define NV_EXTN_OP_HIT_OBJECT_GET_HIT_KIND                 78
+#define NV_EXTN_OP_HIT_OBJECT_GET_RAY_DESC                 79
+#define NV_EXTN_OP_HIT_OBJECT_GET_ATTRIBUTES               80
+#define NV_EXTN_OP_HIT_OBJECT_GET_SHADER_TABLE_INDEX       81
+#define NV_EXTN_OP_HIT_OBJECT_LOAD_LOCAL_ROOT_TABLE_CONSTANT  82
+#define NV_EXTN_OP_HIT_OBJECT_IS_HIT                       83
+#define NV_EXTN_OP_HIT_OBJECT_IS_NOP                       84
+#define NV_EXTN_OP_HIT_OBJECT_MAKE_NOP                     85
+
+// Micro-map API
+#define NV_EXTN_OP_RT_TRIANGLE_OBJECT_POSITIONS            86
+#define NV_EXTN_OP_RT_MICRO_TRIANGLE_OBJECT_POSITIONS      87
+#define NV_EXTN_OP_RT_MICRO_TRIANGLE_BARYCENTRICS          88
+#define NV_EXTN_OP_RT_IS_MICRO_TRIANGLE_HIT                89
+#define NV_EXTN_OP_RT_IS_BACK_FACING                       90
+#define NV_EXTN_OP_RT_MICRO_VERTEX_OBJECT_POSITION         91
+#define NV_EXTN_OP_RT_MICRO_VERTEX_BARYCENTRICS            92
+
+//----------------------------------------------------------------------------//
+//-------------------- GET_SPECIAL subOpCode constants -----------------------//
+//----------------------------------------------------------------------------//
+#define NV_SPECIALOP_THREADLTMASK                           4
+#define NV_SPECIALOP_FOOTPRINT_SINGLELOD_PRED               5
+#define NV_SPECIALOP_GLOBAL_TIMER_LO                        9
+#define NV_SPECIALOP_GLOBAL_TIMER_HI                       10
+
+//----------------------------------------------------------------------------//
+//----------------------------- Texture Types  -------------------------------//
+//----------------------------------------------------------------------------//
+#define NV_EXTN_TEXTURE_1D                                  2
+#define NV_EXTN_TEXTURE_1D_ARRAY                            3
+#define NV_EXTN_TEXTURE_2D                                  4
+#define NV_EXTN_TEXTURE_2D_ARRAY                            5
+#define NV_EXTN_TEXTURE_3D                                  6
+#define NV_EXTN_TEXTURE_CUBE                                7
+#define NV_EXTN_TEXTURE_CUBE_ARRAY                          8
+
+
+//---------------------------------------------------------------------------//
+//----------------FOOTPRINT Enums for NvFootprint* extns---------------------//
+//---------------------------------------------------------------------------//
+#define NV_EXTN_FOOTPRINT_MODE_FINE                         0
+#define NV_EXTN_FOOTPRINT_MODE_COARSE                       1

sgl/shaders/sgl/device/blit.slang

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+
+// This shader uses preprocessor macros to adapt to different texture types and layouts.
+// Ideally we would use Slang's link time specialization to achieve the same effect,
+// but there are some limitations in the current implementation that prevent us from doing so.
+// Mainly we cannot use link time specialization to change the resource format of the source texture
+// as well as the render target output type.
+
+// This shader expects the following defines to be set externally:
+// - SRC_LAYOUT (LAYOUT_TEXTURE2D, LAYOUT_TEXTURE2D_ARRAY)
+// - SRC_TYPE (TYPE_FLOAT, TYPE_INT)
+// - DST_TYPE (TYPE_FLOAT, TYPE_INT)
+
+#define TYPE_FLOAT 0
+#define TYPE_INT 1
+
+#define LAYOUT_TEXTURE2D 0
+#define LAYOUT_TEXTURE2D_ARRAY 1
+
+
+#if SRC_TYPE == TYPE_FLOAT
+typedef float4 SrcType;
+#elif SRC_TYPE == TYPE_INT
+typedef uint4 SrcType;
+#else
+#error "Invalid SRC_TYPE"
+#endif
+
+#if DST_TYPE == TYPE_FLOAT
+typedef float4 DstType;
+#elif DST_TYPE == TYPE_INT
+typedef uint4 DstType;
+#else
+#error "Invalid DST_TYPE"
+#endif
+
+#if SRC_LAYOUT == LAYOUT_TEXTURE2D
+typedef Texture2D<SrcType> SrcTexture;
+#elif SRC_LAYOUT == LAYOUT_TEXTURE2D_ARRAY
+typedef Texture2DArray<SrcType> SrcTexture;
+#else
+#error "Invalid SRC_LAYOUT"
+#endif
+
+extension Texture2D
+{
+    SrcType sample(SamplerState s, float2 uv)
+    {
+#if SRC_TYPE == TYPE_FLOAT
+        return this.Sample(s, uv);
+#elif SRC_TYPE == TYPE_INT
+        return asuint(this.Sample(s, uv));
+#endif
+    }
+}
+
+extension Texture2DArray
+{
+    SrcType sample(SamplerState s, float2 uv)
+    {
+#if SRC_TYPE == TYPE_FLOAT
+        return this.Sample(s, float3(uv, 0));
+#elif SRC_TYPE == TYPE_INT
+        return asuint(this.Sample(s, float3(uv, 0)));
+#endif
+    }
+}
+
+SrcTexture src;
+SamplerState sampler;
+
+struct VSOut {
+    float4 pos : SV_Position;
+    float2 uv : UV;
+};
+
+[shader("vertex")]
+VSOut vs_main(uint vid: SV_VertexID)
+{
+    VSOut vs_out;
+    vs_out.uv = float2((vid << 1) & 2, vid & 2);
+    vs_out.pos = float4(vs_out.uv * float2(2, -2) + float2(-1, 1), 0, 1);
+    return vs_out;
+}
+
+[shader("fragment")]
+DstType fs_main(VSOut vs_out)
+    : SV_Target
+{
+    float2 uv = vs_out.uv;
+    let value = src.sample(sampler, uv);
+    return reinterpret<DstType>(value);
+}

sgl/shaders/sgl/device/nvapi.slang

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#if SGL_ENABLE_NVAPI
+#include "nvapi/nvHLSLExtns.h"
+#endif

sgl/shaders/sgl/device/nvapi.slangh

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#if SGL_ENABLE_NVAPI
+#include "nvapi/nvShaderExtnEnums.h"
+#endif
+import sgl.device.nvapi;

sgl/shaders/sgl/device/print.slang

@@ -0,0 +1,445 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef SGL_ENABLE_PRINT
+#define SGL_ENABLE_PRINT 0
+#endif
+
+namespace detail {
+
+enum class Kind {
+    scalar,
+    vector,
+    matrix,
+};
+
+/// Printable primitive types.
+enum class Type {
+    boolean,
+    int8,
+    int16,
+    int32,
+    int64,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    float16,
+    float32,
+    float64,
+};
+
+struct Layout {
+    Kind kind;
+    Type type;
+    uint rows;
+    uint cols;
+};
+
+/// Interface to print output.
+interface IPrintOutput {
+    /// Write a message and reserve space for writing the arguments.
+    /// \param fmt The format string.
+    /// \param arg_count The number of arguments.
+    /// \param total_data_count The total number of data elements in all arguments.
+    /// \param[out] offset Offset into the output buffer. This needs to be passed to \c write_arg calls.
+    /// \return True if the message was written successfully, false if there was not enough space.
+    bool write_msg(String fmt, uint arg_count, uint total_data_count, out uint offset);
+
+    /// Write a single printable argument.
+    /// \param[in,out] offset Offset into the output buffer.
+    void write_arg(inout uint offset, IPrintable arg);
+};
+
+/// Interface for printable types.
+interface IPrintable {
+    [ForceInline]
+    static Layout printable_layout();
+
+    /// The total number of data elements (each element is a \c uint).
+    [ForceInline]
+    static uint printable_data_count();
+
+    /// Get a printable data element.
+    /// \param index The index of the data element in range [0..printable_data_count()).
+    [ForceInline]
+    uint get_printable_data(uint index);
+};
+
+// clang-format off
+extension bool : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::boolean); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return asuint(this); }
+};
+
+extension int8_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::int8); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return asuint(this); }
+};
+
+extension int16_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::int16); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return asuint(this); }
+};
+
+extension int32_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::int32); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return asuint(this); }
+};
+
+extension int64_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::int64); }
+    [ForceInline]
+    static uint printable_data_count() { return 2; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return index == 0 ? uint(this & 0xffffffff) : uint(this >> 32); }
+};
+
+extension uint8_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::uint8); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return this; }
+};
+
+extension uint16_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::uint16); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return this; }
+};
+
+extension uint32_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::uint32); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return this; }
+};
+
+extension uint64_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::uint64); }
+    [ForceInline]
+    static uint printable_data_count() { return 2; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return index == 0 ? uint(this & 0xffffffffu) : uint(this >> 32); }
+};
+
+extension float16_t : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::float16); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return f32tof16(this); }
+}
+
+extension float : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::float32); }
+    [ForceInline]
+    static uint printable_data_count() { return 1; }
+    [ForceInline]
+    uint get_printable_data(uint index) { return asuint(this); }
+}
+
+extension double : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::scalar, Type::float64); }
+    [ForceInline]
+    static uint printable_data_count() { return 2; }
+    [ForceInline]
+    uint get_printable_data(uint index) { uint2 data; asuint(this, data.x, data.y); return data[index]; }
+}
+
+__generic<T : IPrintable, let N : int>
+extension vector<T, N> : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::vector, T::printable_layout().type, N); }
+    [ForceInline]
+    static uint printable_data_count() { return N * T::printable_data_count(); }
+    [ForceInline]
+    uint get_printable_data(uint index) { return this[index / T::printable_data_count()].get_printable_data(index % T::printable_data_count()); }
+};
+
+__generic<T : IPrintable, let R : int, let C : int, let L : int>
+extension matrix<T, R, C, L> : IPrintable {
+    [ForceInline]
+    static Layout printable_layout() { return Layout(Kind::matrix, T::printable_layout().type, R, C); }
+    static uint printable_data_count() { return R * C * T::printable_data_count(); }
+    [ForceInline]
+    uint get_printable_data(uint index) {
+        uint element_index = index / T::printable_data_count();
+        uint row = element_index / C;
+        uint col = element_index % C;
+        return this[row][col].get_printable_data(index % T::printable_data_count());
+    }
+};
+// clang-format on
+
+[ForceInline]
+void print(IPrintOutput output, String fmt)
+{
+    uint offset;
+    output.write_msg(fmt, 0, 0, offset);
+}
+
+[ForceInline]
+void print(IPrintOutput output, String fmt, IPrintable arg0)
+{
+    uint total_data_count = arg0.printable_data_count();
+    uint offset;
+    if (!output.write_msg(fmt, 1, total_data_count, offset))
+        return;
+    output.write_arg(offset, arg0);
+}
+
+[ForceInline]
+void print(IPrintOutput output, String fmt, IPrintable arg0, IPrintable arg1)
+{
+    uint total_data_count = arg0.printable_data_count() + arg1.printable_data_count();
+    uint offset;
+    if (!output.write_msg(fmt, 2, total_data_count, offset))
+        return;
+    output.write_arg(offset, arg0);
+    output.write_arg(offset, arg1);
+}
+
+[ForceInline]
+void print(IPrintOutput output, String fmt, IPrintable arg0, IPrintable arg1, IPrintable arg2)
+{
+    uint total_data_count = arg0.printable_data_count() + arg1.printable_data_count() + arg2.printable_data_count();
+    uint offset;
+    if (!output.write_msg(fmt, 3, total_data_count, offset))
+        return;
+    output.write_arg(offset, arg0);
+    output.write_arg(offset, arg1);
+    output.write_arg(offset, arg2);
+}
+
+[ForceInline]
+void print(IPrintOutput output, String fmt, IPrintable arg0, IPrintable arg1, IPrintable arg2, IPrintable arg3)
+{
+    uint total_data_count = arg0.printable_data_count() + arg1.printable_data_count() + arg2.printable_data_count()
+        + arg3.printable_data_count();
+    uint offset;
+    if (!output.write_msg(fmt, 4, total_data_count, offset))
+        return;
+    output.write_arg(offset, arg0);
+    output.write_arg(offset, arg1);
+    output.write_arg(offset, arg2);
+    output.write_arg(offset, arg3);
+}
+
+[ForceInline]
+void print(
+    IPrintOutput output,
+    String fmt,
+    IPrintable arg0,
+    IPrintable arg1,
+    IPrintable arg2,
+    IPrintable arg3,
+    IPrintable arg4
+)
+{
+    uint total_data_count = arg0.printable_data_count() + arg1.printable_data_count() + arg2.printable_data_count()
+        + arg3.printable_data_count() + arg4.printable_data_count();
+    ;
+    uint offset;
+    if (!output.write_msg(fmt, 5, total_data_count, offset))
+        return;
+    output.write_arg(offset, arg0);
+    output.write_arg(offset, arg1);
+    output.write_arg(offset, arg2);
+    output.write_arg(offset, arg3);
+    output.write_arg(offset, arg4);
+}
+
+[ForceInline]
+void print(
+    IPrintOutput output,
+    String fmt,
+    IPrintable arg0,
+    IPrintable arg1,
+    IPrintable arg2,
+    IPrintable arg3,
+    IPrintable arg4,
+    IPrintable arg5
+)
+{
+    uint total_data_count = arg0.printable_data_count() + arg1.printable_data_count() + arg2.printable_data_count()
+        + arg3.printable_data_count() + arg4.printable_data_count() + arg5.printable_data_count();
+    ;
+    uint offset;
+    if (!output.write_msg(fmt, 6, total_data_count, offset))
+        return;
+    output.write_arg(offset, arg0);
+    output.write_arg(offset, arg1);
+    output.write_arg(offset, arg2);
+    output.write_arg(offset, arg3);
+    output.write_arg(offset, arg4);
+    output.write_arg(offset, arg5);
+}
+
+[ForceInline]
+void print(
+    IPrintOutput output,
+    String fmt,
+    IPrintable arg0,
+    IPrintable arg1,
+    IPrintable arg2,
+    IPrintable arg3,
+    IPrintable arg4,
+    IPrintable arg5,
+    IPrintable arg6
+)
+{
+    uint total_data_count = arg0.printable_data_count() + arg1.printable_data_count() + arg2.printable_data_count()
+        + arg3.printable_data_count() + arg4.printable_data_count() + arg5.printable_data_count()
+        + arg6.printable_data_count();
+    ;
+    uint offset;
+    if (!output.write_msg(fmt, 7, total_data_count, offset))
+        return;
+    output.write_arg(offset, arg0);
+    output.write_arg(offset, arg1);
+    output.write_arg(offset, arg2);
+    output.write_arg(offset, arg3);
+    output.write_arg(offset, arg4);
+    output.write_arg(offset, arg5);
+    output.write_arg(offset, arg6);
+}
+
+[ForceInline]
+void print(
+    IPrintOutput output,
+    String fmt,
+    IPrintable arg0,
+    IPrintable arg1,
+    IPrintable arg2,
+    IPrintable arg3,
+    IPrintable arg4,
+    IPrintable arg5,
+    IPrintable arg6,
+    IPrintable arg7
+)
+{
+    uint total_data_count = arg0.printable_data_count() + arg1.printable_data_count() + arg2.printable_data_count()
+        + arg3.printable_data_count() + arg4.printable_data_count() + arg5.printable_data_count()
+        + arg6.printable_data_count() + arg7.printable_data_count();
+    ;
+    uint offset;
+    if (!output.write_msg(fmt, 8, total_data_count, offset))
+        return;
+    output.write_arg(offset, arg0);
+    output.write_arg(offset, arg1);
+    output.write_arg(offset, arg2);
+    output.write_arg(offset, arg3);
+    output.write_arg(offset, arg4);
+    output.write_arg(offset, arg5);
+    output.write_arg(offset, arg6);
+    output.write_arg(offset, arg7);
+}
+
+struct DebugPrinter : IPrintOutput {
+
+    /// Single buffer that contains the print messages.
+    /// The first 4 bytes of the buffer store the size of the data following.
+    RWByteAddressBuffer buffer;
+
+    [ForceInline]
+    bool write_msg(String fmt, uint arg_count, uint total_data_count, out uint offset)
+    {
+        uint buffer_capacity;
+        buffer.GetDimensions(buffer_capacity);
+
+        // Compute the size of the message.
+        uint size = (3 + arg_count + total_data_count) * sizeof(uint);
+
+        // Reserve space for the message.
+        offset = 0;
+        buffer.InterlockedAdd(0, size, offset);
+        offset += 4;
+        if (offset + size > buffer_capacity - 4) {
+            // Write sentinel value indicating that we have a buffer overlow.
+            buffer.Store(offset, 0xffffffff);
+            return false;
+        }
+
+        buffer.Store(offset, size);
+        buffer.Store(offset + 4, getStringHash(fmt));
+        buffer.Store(offset + 8, arg_count);
+        offset += 12;
+        return true;
+    }
+
+    [ForceInline]
+    void write_arg(inout uint offset, IPrintable arg)
+    {
+        Layout layout = arg.printable_layout();
+        uint size = (1 + arg.printable_data_count()) * sizeof(uint);
+        // Header: [kind:4][type:4][rows:4][cols:4][size:16]
+        uint header
+            = (uint(layout.kind) << 28) | (uint(layout.type) << 24) | (layout.rows << 20) | (layout.cols << 16) | size;
+        buffer.Store(offset, header);
+        for (uint i = 0; i < arg.printable_data_count(); ++i)
+            buffer.Store(offset + (i + 1) * 4, arg.get_printable_data(i));
+        offset += size;
+    }
+};
+
+} // namespace detail
+
+#if SGL_ENABLE_PRINT
+
+ParameterBlock<detail::DebugPrinter> g_debug_printer;
+
+// clang-format off
+[ForceInline] void print(String fmt) { detail::print(g_debug_printer, fmt); }
+[ForceInline] void print(String fmt, detail::IPrintable arg0) { detail::print(g_debug_printer, fmt, arg0); }
+[ForceInline] void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1) { detail::print(g_debug_printer, fmt, arg0, arg1); }
+[ForceInline] void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2) { detail::print(g_debug_printer, fmt, arg0, arg1, arg2); }
+[ForceInline] void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3) { detail::print(g_debug_printer, fmt, arg0, arg1, arg2, arg3); }
+[ForceInline] void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3, detail::IPrintable arg4) { detail::print(g_debug_printer, fmt, arg0, arg1, arg2, arg3, arg4); }
+[ForceInline] void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3, detail::IPrintable arg4, detail::IPrintable arg5) { detail::print(g_debug_printer, fmt, arg0, arg1, arg2, arg3, arg4, arg5); }
+[ForceInline] void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3, detail::IPrintable arg4, detail::IPrintable arg5, detail::IPrintable arg6) { detail::print(g_debug_printer, fmt, arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
+[ForceInline] void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3, detail::IPrintable arg4, detail::IPrintable arg5, detail::IPrintable arg6, detail::IPrintable arg7) { detail::print(g_debug_printer, fmt, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); }
+// clang-format on
+
+#else // SGL_ENABLE_PRINT
+
+// clang-format off
+void print(String fmt) { }
+void print(String fmt, detail::IPrintable arg0) { }
+void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1) { }
+void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2) { }
+void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3) { }
+void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3, detail::IPrintable arg4) { }
+void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3, detail::IPrintable arg4, detail::IPrintable arg5) { }
+void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3, detail::IPrintable arg4, detail::IPrintable arg5, detail::IPrintable arg6) { }
+void print(String fmt, detail::IPrintable arg0, detail::IPrintable arg1, detail::IPrintable arg2, detail::IPrintable arg3, detail::IPrintable arg4, detail::IPrintable arg5, detail::IPrintable arg6, detail::IPrintable arg7) { }
+// clang-format on
+
+#endif // SGL_ENABLE_PRINT