#version 460

layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;

layout(set = 0, binding = 0) readonly buffer lv_tileBuffer {
    uint lv_tileData[];
} tileBuffer;


layout(set = 0, binding = 1) uniform  UniformBuffer {

mat4   inMtx;
mat4   viewMatrix;
vec4 cameraPos;

float scale;
float bias;
float zNear;
float zFar;
float radius;
float attScale;
float distScale;
uint m_enableDeferred;

} ubo;




struct Light {
    vec4 m_Position;
    vec4 m_Color;

    float m_linear;
    float m_quadratic;
    float m_radius;
    float m_pad;
};

const uint lv_totalNumLights = 64;
const uint lv_totalNumBins = 32;

layout(set = 0, binding = 2) uniform lv_lightData
{
    Light m_lights[lv_totalNumLights];
    uint m_sortedLightsIndices[lv_totalNumLights];

    uint m_bins[lv_totalNumBins];
} lightData;



layout(set = 0, binding = 3) uniform sampler2D lv_positions;
layout(set = 0, binding = 4) uniform sampler2D lv_normals;
layout(set = 0, binding = 5) uniform sampler2D lv_albedoSpecs;

layout(set = 0, binding = 6) uniform writeonly image2D lv_outputImage;


void main()
{

    ivec2 lv_uv = ivec2(gl_GlobalInvocationID.xy);

    vec4 lv_worldPos = vec4(texelFetch(lv_positions, lv_uv,0).xyz, 1.f);

    vec4 lv_viewPos = ubo.viewMatrix * lv_worldPos;

    uint lv_binIndex = uint(((-lv_viewPos.z - ubo.zNear)/(ubo.zFar - ubo.zNear)) * 8.f);

    uint lv_bin = lightData.m_bins[lv_binIndex];

    uint lv_minLightIndex = lv_bin & 0xFFFF;
    uint lv_maxLightIndex = (lv_bin >> 16) & 0xFFFF;
    vec3 lv_albedo = texelFetch(lv_albedoSpecs, lv_uv,0).rgb;
    vec3 lv_lightning = lv_albedo*0.1;

    if(lv_maxLightIndex != 0) {

        uvec2 lv_currentThreadGlobalID = gl_GlobalInvocationID.xy;

        uvec2 lv_tile = lv_currentThreadGlobalID/uint(8);

        uint lv_stride = 1024;

        uint lv_address = lv_tile.y*lv_stride + lv_tile.x*8;

        for(uint lv_lightIndex = lv_minLightIndex; lv_lightIndex <= lv_maxLightIndex; ++lv_lightIndex) {

            uint lv_wordID = lv_lightIndex / 32;
            uint lv_bit = lv_lightIndex % 32;

            if((tileBuffer.lv_tileData[lv_address + lv_wordID] & (1 << lv_bit)) != 0) {

                vec3 lv_fragPos = texelFetch(lv_positions, lv_uv,0).rgb;
                vec3 lv_normal = texelFetch(lv_normals, lv_uv,0).rgb;
                float lv_specular = texelFetch(lv_albedoSpecs, lv_uv,0).a;

                uint lv_globalLightIndex = lightData.m_sortedLightsIndices[lv_lightIndex];

                Light lv_light = lightData.m_lights[lv_globalLightIndex];

                vec3 lv_dir = normalize(ubo.cameraPos.xyz - lv_fragPos);


                vec3 lv_lightDir = normalize(lv_light.m_Position.xyz - lv_fragPos);
                vec3 lv_diffuse = max(dot(lv_normal, lv_lightDir), 0.0) * lv_albedo * lv_light.m_Color.rgb;

                //specular
                vec3 halfwayDir = normalize(lv_lightDir + lv_dir);
                float spec = pow(max(dot(lv_normal, halfwayDir), 0.0), 16.0);
                vec3 specular = lv_light.m_Color.rgb * spec * lv_specular;

                // attenuation
                float distance = length(lv_light.m_Position.xyz - lv_fragPos);
                float attenuation = 1.0 / (1.0 + lv_light.m_linear * distance + lv_light.m_quadratic * distance * distance);
                lv_diffuse *= attenuation;
                specular *= attenuation;
                lv_lightning += lv_diffuse + specular;


            }

        }

    }

    imageStore(lv_outputImage,lv_uv,vec4(lv_lightning, 1.f));

}