Compiler Explorer

Source code

#ifndef RESOURCECOLLECTION_HLSL
#define RESOURCECOLLECTION_HLSL

#define StructuredBufferHandle(T, name) \
    uint _##name; \
    StructuredBufferHandle<T> name() { return (StructuredBufferHandle<T>)_##name; }

#define RWStructuredBufferHandle(T, name) \
    uint _##name; \
    RWStructuredBufferHandle<T> name() { return (RWStructuredBufferHandle<T>)_##name; }

#define StructuredBufferOffset(T, name) \
    uint _##name; \
    StructuredBufferOffset<T> name() { return (StructuredBufferOffset<T>)_##name; }

template<typename T>
struct StructuredBufferHandle
{
    uint Index;
};

template<typename T>
struct RWStructuredBufferHandle
{
    uint Index;
};

template<typename T>
struct StructuredBufferOffset
{
    static const uint HandleBits = 12;
    static const uint OffsetBits = sizeof(uint) * 8 - HandleBits;
    static const uint MaxHandleIndex = (1u << HandleBits) - 1;
    static const uint MaxOffset = (1u << OffsetBits) - 1;

uint PackedOffset;

StructuredBufferHandle<T> GetHandle()
    {
        return (StructuredBufferHandle<T>)(PackedOffset & MaxHandleIndex);
    }

uint GetOffset()
    {
        return PackedOffset >> HandleBits;
    }

bool operator==(StructuredBufferOffset<T> other)
    {
        return PackedOffset == other.PackedOffset;
    }
};

template<typename T>
struct SubStructuredBuffer
{
    StructuredBuffer<T> Buffer;
    uint Offset;
    uint Length;

T operator[](uint index)
    {
        return Buffer[Offset + index];
    }

T Load(uint index)
    {
        return Buffer[Offset + index];
    }
};

template<typename T>
StructuredBuffer<T> GetStructuredBuffer(StructuredBufferHandle<T> handle)
{
    return ResourceDescriptorHeap[handle.Index];
}

template<typename T>
RWStructuredBuffer<T> GetRWStructuredBuffer(RWStructuredBufferHandle<T> handle)
{
    return ResourceDescriptorHeap[handle.Index];
}

/*template<typename T>
StructuredBuffer<T> GetStructuredBufferNonUniform(StructuredBufferHandle<T> handle)
{
    return ResourceDescriptorHeap[NonUniformResourceIndex(handle.Index)];
}*/

#define GetStructuredBufferNonUniform(handle) ResourceDescriptorHeap[NonUniformResourceIndex((handle).Index)];

/*template<typename T>
RWStructuredBuffer<T> GetRWStructuredBufferNonUniform(RWStructuredBufferHandle<T> handle)
{
    return ResourceDescriptorHeap[NonUniformResourceIndex(handle.Index)];
}*/

#define GetRWStructuredBufferNonUniform(handle) ResourceDescriptorHeap[NonUniformResourceIndex((handle).Index)];

template<typename T>
SubStructuredBuffer<T> GetSubStructuredBuffer(StructuredBufferOffset<T> offset)
{
    SubStructuredBuffer<T> result;
    result.Buffer = GetStructuredBuffer(offset.GetHandle());
    result.Offset = offset.GetOffset();
    result.Length = 0;
    return result;
}

template<typename T>
SubStructuredBuffer<T> GetSubStructuredBufferNonUniform(StructuredBufferOffset<T> offset)
{
    SubStructuredBuffer<T> result;
    result.Buffer = GetStructuredBufferNonUniform(offset.GetHandle());
    result.Offset = offset.GetOffset();
    result.Length = 0;
    return result;
}

#endif // RESOURCECOLLECTION_HLSL

cbuffer Parameters
{
    StructuredBufferHandle(StructuredBufferOffset<uint>, Buffers);
    RWStructuredBufferHandle(uint, Results);
};

[numthreads(32, 1, 1)]
void CSMain (uint threadID : SV_DispatchThreadID)
{
    StructuredBuffer<StructuredBufferOffset<uint> > buffers = GetStructuredBuffer(Buffers());

SubStructuredBuffer<uint> buffer = GetSubStructuredBufferNonUniform(buffers[threadID]);

RWStructuredBuffer<uint> results = GetRWStructuredBuffer(Results());
    results[threadID] = buffer[0];
}