// GLSL Compute Shader \"csmain\"
// Generated by XShaderCompiler
// 20/05/2019 12:04:28

#version 450

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

void GroupMemoryBarrierWithGroupSync()
{
    groupMemoryBarrier();
    barrier();
}

vec3 getDirFromCubeFace(uint cubeFace, vec2 uv)
{
    vec3 dir;
    if (cubeFace == 0u)
        dir = vec3(1.0f, -uv.y, -uv.x);
    else if (cubeFace == 1u)
        dir = vec3(-1.0f, -uv.y, uv.x);
    else if (cubeFace == 2u)
        dir = vec3(uv.x, 1.0f, uv.y);
    else if (cubeFace == 3u)
        dir = vec3(uv.x, -1.0f, -uv.y);
    else if (cubeFace == 4u)
        dir = vec3(uv.x, -uv.y, 1.0f);
    else
        dir = vec3(-uv.x, -uv.y, -1.0f);
    return dir;
}

float integrateProjectedCubeArea(float u, float v)
{
    return atan(u * v, sqrt(u * u + v * v + 1.0f));
}

float texelSolidAngle(float u, float v, float invFaceSize)
{
    float x0 = u - invFaceSize;
    float x1 = u + invFaceSize;
    float y0 = v - invFaceSize;
    float y1 = v + invFaceSize;
    return integrateProjectedCubeArea(x1, y1) - integrateProjectedCubeArea(x0, y1) - integrateProjectedCubeArea(x1, y0) + integrateProjectedCubeArea(x0, y0);
}

struct SHVector
{
    float v[25];
};

struct SHVectorRGB
{
    SHVector R;
    SHVector G;
    SHVector B;
};

void SHZero(inout SHVector v)
{
    for (int i = 0; i < 5 * 5; ++i)
        v.v[i] = 0.0f;
}

void SHMultiplyAdd(inout SHVector lhs, SHVector rhs, float c)
{
    for (int i = 0; i < 5 * 5; ++i)
        lhs.v[i] += rhs.v[i] * c;
}

void SHAdd(inout SHVector lhs, SHVector rhs)
{
    for (int i = 0; i < 5 * 5; ++i)
        lhs.v[i] += rhs.v[i];
}

SHVector SHBasis(vec3 dir)
{
    float x = dir.x;
    float y = dir.y;
    float z = dir.z;
    float x2 = x * x;
    float y2 = y * y;
    float z2 = z * z;
    float z3 = z2 * z;
    float x4 = x2 * x2;
    float y4 = y2 * y2;
    float z4 = z2 * z2;
    SHVector o;
    o.v[0] = 0.282095f;
    o.v[1] = -0.488603f * y;
    o.v[2] = 0.488603f * z;
    o.v[3] = -0.488603f * x;
    o.v[4] = 1.092548f * x * y;
    o.v[5] = -1.092548f * y * z;
    o.v[6] = 0.315392f * (3.0f * z2 - 1.0f);
    o.v[7] = -1.092548f * x * z;
    o.v[8] = 0.546274f * (x2 - y2);
    o.v[9] = -0.590043f * y * (3.0f * x2 - y2);
    o.v[10] = 2.890611f * y * x * z;
    o.v[11] = -0.646360f * y * (-1.0f + 5.0f * z2);
    o.v[12] = 0.373176f * (5.0f * z3 - 3.0f * z);
    o.v[13] = -0.457045f * x * (-1.0f + 5.0f * z2);
    o.v[14] = 1.445306f * (x2 - y2) * z;
    o.v[15] = -0.590043f * x * (x2 - 3.0f * y2);
    o.v[16] = 2.503340f * x * y * (x2 - y2);
    o.v[17] = -1.770130f * y * z * (3.0f * x2 - y2);
    o.v[18] = 0.946175f * y * x * (-1.0f + 7.0f * z2);
    o.v[19] = -0.669046f * y * z * (-3.0f + 7.0f * z2);
    o.v[20] = (105.0f * z4 - 90.0f * z2 + 9.0f) / 28.359261f;
    o.v[21] = -0.669046f * x * z * (-3.0f + 7.0f * z2);
    o.v[22] = 0.473087f * (x2 - y2) * (-1.0f + 7.0f * z2);
    o.v[23] = -1.770130f * x * z * (x2 - 3.0f * y2);
    o.v[24] = 0.625836f * (x4 - 6.0f * y2 * x2 + y4);
    return o;
}

struct SHCoeffsAndWeight
{
    SHVectorRGB coeffs;
    float       weight;
};

layout(binding = 1) uniform samplerCube gInputTex;

layout(std430, binding = 2) buffer gOutput
{
    SHCoeffsAndWeight xst_gOutput[];
};

layout(std140, binding = 3) uniform Params
{
    uint  gCubeFace;
    uint  gFaceSize;
    uvec2 gDispatchSize;
};

shared SHCoeffsAndWeight sCoeffs[64];

void main()
{
    SHCoeffsAndWeight data;
    data.weight = 0.0f;
    SHZero(data.coeffs.R);
    SHZero(data.coeffs.G);
    SHZero(data.coeffs.B);
    float invFaceSize = 1.0f / float(gFaceSize);
    uvec2 pixelCoords = gl_GlobalInvocationID.xy * 4u;
    uvec2 pixelCoordsEnd = pixelCoords + uvec2(4, 4);
    for (uint y = pixelCoords.y; y < pixelCoordsEnd.y; y++)
    {
        for (uint x = pixelCoords.x; x < pixelCoordsEnd.x; x++)
        {
            if (x >= gFaceSize || y >= gFaceSize)
                break;
            float u = 2.0f * (float(x) + 0.5f) * invFaceSize - 1.0f;
            float v = 2.0f * (float(y) + 0.5f) * invFaceSize - 1.0f;
            vec3 dir = getDirFromCubeFace(gCubeFace, vec2(u, v));
            dir = normalize(dir);
            float weight = texelSolidAngle(u, v, invFaceSize);
            SHVector shBasis = SHBasis(dir);
            vec3 radiance = textureLod(gInputTex, dir, 0).rgb;
            SHMultiplyAdd(data.coeffs.R, shBasis, radiance.r * weight);
            SHMultiplyAdd(data.coeffs.G, shBasis, radiance.g * weight);
            SHMultiplyAdd(data.coeffs.B, shBasis, radiance.b * weight);
            data.weight += weight;
        }
    }
    sCoeffs[gl_LocalInvocationIndex] = data;
    GroupMemoryBarrierWithGroupSync();
    int numThreads = 8 * 8;
    for (int tc = numThreads / 2; tc > 0; tc >>= 1)
    {
        if (gl_LocalInvocationIndex < uint(tc))
        {
            SHAdd(sCoeffs[gl_LocalInvocationIndex].coeffs.R, sCoeffs[gl_LocalInvocationIndex + uint(tc)].coeffs.R);
            SHAdd(sCoeffs[gl_LocalInvocationIndex].coeffs.G, sCoeffs[gl_LocalInvocationIndex + uint(tc)].coeffs.G);
            SHAdd(sCoeffs[gl_LocalInvocationIndex].coeffs.B, sCoeffs[gl_LocalInvocationIndex + uint(tc)].coeffs.B);
            sCoeffs[gl_LocalInvocationIndex].weight += sCoeffs[gl_LocalInvocationIndex + uint(tc)].weight;
        }
        GroupMemoryBarrierWithGroupSync();
    }
    if (gl_LocalInvocationIndex == 0u)
    {
        uint faceOffset = gDispatchSize.x * gDispatchSize.y * gCubeFace;
        uint outputIdx = faceOffset + gl_WorkGroupID.y * gDispatchSize.x + gl_WorkGroupID.x;
        xst_gOutput[outputIdx] = sCoeffs[0];
    }
}