#ifndef BUILTIN_COMMON_HLSL
#define BUILTIN_COMMON_HLSL

struct Vertex
{
    float4 position;
    float4 normal;
    float4 tangent;
    float4 uv;
    float4 color;
};

#define SIZEOF_VERTEX 80 // bytes

// Resource descriptor heap definitions

#define GLOBAL_TEXTURE2D_HEAP ResourceDescriptorHeap
#define GLOBAL_TEXTURE3D_HEAP ResourceDescriptorHeap
#define GLOBAL_TEXTURECUBE_HEAP ResourceDescriptorHeap
#define GLOBAL_TEXTURE2D_ARRAY_HEAP ResourceDescriptorHeap
#define GLOBAL_TEXTURECUBE_ARRAY_HEAP ResourceDescriptorHeap
#define GLOBAL_BUFFER_HEAP ResourceDescriptorHeap
#define GLOBAL_SAMPLER_HEAP SamplerDescriptorHeap

// Bindless resource type definitions

#define TEXTURE2D uint
#define TEXTURE3D uint
#define TEXTURECUBE uint
#define TEXTURE2D_ARRAY uint
#define TEXTURECUBE_ARRAY uint

#define SAMPLER uint

#define STRUCT_BUFFER uint
#define BYTE_ADDRESS_BUFFER uint


// Texture and sampler access macros

#define GET_TEXTURE2D(id) GLOBAL_TEXTURE2D_HEAP[id]
#define GET_TEXTURE2D_ARRAY(id) GLOBAL_TEXTURE2D_ARRAY_HEAP[id]
#define GET_TEXTURE3D(id) GLOBAL_TEXTURE3D_HEAP[id]
#define GET_TEXTURECUBE(id) GLOBAL_TEXTURECUBE_HEAP[id]
#define GET_TEXTURECUBE_ARRAY(id) GLOBAL_TEXTURECUBE_ARRAY_HEAP[id]
#define GET_BUFFER(id) GLOBAL_BUFFER_HEAP[id]
#define GET_SAMPLER(id) GLOBAL_SAMPLER_HEAP[id]

#define SAMPLE_TEXTURE2D(texId, sampId, uv) SampleTexture2D(texId, sampId, uv)
#define SAMPLE_TEXTURE2D_LEVEL(texId, sampId, uv, level) SampleTexture2DLevel(texId, sampId, uv, level)
#define SAMPLE_TEXTURE2D_ARRAY(texId, sampId, uvw) SampleTextureArray(texId, sampId, uvw)

#define MESH_SHADER_THREADS(x) [NumThreads(x, 1, 1)]


static inline float4 SampleTexture2D(uint texId, uint sampId, float2 uv)
{
    Texture2D tex = GET_TEXTURE2D(texId);
    SamplerState samp = GET_SAMPLER(sampId);
    return tex.Sample(samp, uv);
}

static inline float4 SampleTexture2DLevel(uint texId, uint sampId, float2 uv, float level)
{
    Texture2D tex = GET_TEXTURE2D(texId);
    SamplerState samp = GET_SAMPLER(sampId);
    return tex.SampleLevel(samp, uv, level);
}

static inline float4 SampleTextureArray(uint texId, uint sampId, float3 uvw)
{
    Texture2DArray tex = GET_TEXTURE2D_ARRAY(texId);
    SamplerState samp = GET_SAMPLER(sampId);
    return tex.Sample(samp, uvw);
}

static inline Vertex LoadVertexData(uint vertexID, uint groupID, BYTE_ADDRESS_BUFFER vertexBuffer, BYTE_ADDRESS_BUFFER indexBuffer)
{
    // Fetch bindless buffers
    ByteAddressBuffer vertices = GET_BUFFER(vertexBuffer);
    ByteAddressBuffer indices = GET_BUFFER(indexBuffer);
    
    // Compute the triangle’s vertex indices
    uint indexOffset = (groupID * 3 + vertexID) * 4; // uint32 index
    uint vertexIndex = indices.Load(indexOffset);
    
    // Load vertex attributes
    uint vertexOffset = vertexIndex * SIZEOF_VERTEX;
    Vertex v;
    v.position = asfloat(vertices.Load4(vertexOffset + 0));
    v.normal = asfloat(vertices.Load4(vertexOffset + 16));
    v.tangent = asfloat(vertices.Load4(vertexOffset + 32));
    v.uv = asfloat(vertices.Load4(vertexOffset + 48));
    v.color = asfloat(vertices.Load4(vertexOffset + 64));
    
    return v;
}

#endif // BUILTIN_COMMON_HLSL