struct Camera {
  projection : mat4x4<f32>,
  inverseProjection : mat4x4<f32>,
  view : mat4x4<f32>,
  position : vec3<f32>,
  time : f32,
  outputSize : vec2<f32>,
  zNear : f32,
  zFar : f32,
}

@group(0) @binding(0) var<uniform> camera : Camera;

struct ClusterBounds {
  minAABB : vec3<f32>,
  maxAABB : vec3<f32>,
}

struct Clusters {
  bounds : array<ClusterBounds, 27648>,
}

@group(0) @binding(1) var<storage, read> clusters : Clusters;

struct ClusterLights {
  offset : u32,
  count : u32,
}

struct ClusterLightGroup {
  offset : atomic<u32>,
  lights : array<ClusterLights, 27648>,
  indices : array<u32, 1769472>,
}

@group(0) @binding(2) var<storage, read_write> clusterLights : ClusterLightGroup;

struct Light {
  position : vec3<f32>,
  range : f32,
  color : vec3<f32>,
  intensity : f32,
}

struct GlobalLights {
  ambient : vec3<f32>,
  dirColor : vec3<f32>,
  dirIntensity : f32,
  dirDirection : vec3<f32>,
  lightCount : u32,
  lights : array<Light>,
}

@group(0) @binding(3) var<storage, read> globalLights : GlobalLights;

const tileCount = vec3(32u, 18u, 48u);

fn linearDepth(depthSample : f32) -> f32 {
  return ((camera.zFar * camera.zNear) / fma(depthSample, (camera.zNear - camera.zFar), camera.zFar));
}

fn getTile(fragCoord : vec4<f32>) -> vec3<u32> {
  let sliceScale = (f32(tileCount.z) / log2((camera.zFar / camera.zNear)));
  let sliceBias = -(((f32(tileCount.z) * log2(camera.zNear)) / log2((camera.zFar / camera.zNear))));
  let zTile = u32(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0));
  return vec3(u32((fragCoord.x / (camera.outputSize.x / f32(tileCount.x)))), u32((fragCoord.y / (camera.outputSize.y / f32(tileCount.y)))), zTile);
}

fn getClusterIndex(fragCoord : vec4<f32>) -> u32 {
  let tile = getTile(fragCoord);
  return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}

fn sqDistPointAABB(point : vec3<f32>, minAABB : vec3<f32>, maxAABB : vec3<f32>) -> f32 {
  var sqDist = 0.0;
  for(var i : i32 = 0; (i < 3); i = (i + 1)) {
    let v = point[i];
    if ((v < minAABB[i])) {
      sqDist = (sqDist + ((minAABB[i] - v) * (minAABB[i] - v)));
    }
    if ((v > maxAABB[i])) {
      sqDist = (sqDist + ((v - maxAABB[i]) * (v - maxAABB[i])));
    }
  }
  return sqDist;
}

@compute @workgroup_size(4, 2, 4)
fn computeMain(@builtin(global_invocation_id) global_id : vec3<u32>) {
  let tileIndex = ((global_id.x + (global_id.y * tileCount.x)) + ((global_id.z * tileCount.x) * tileCount.y));
  var clusterLightCount = 0u;
  var cluserLightIndices : array<u32, 256>;
  for(var i = 0u; (i < globalLights.lightCount); i = (i + 1u)) {
    let range = globalLights.lights[i].range;
    var lightInCluster : bool = (range <= 0.0);
    if (!(lightInCluster)) {
      let lightViewPos = (camera.view * vec4(globalLights.lights[i].position, 1.0));
      let sqDist = sqDistPointAABB(lightViewPos.xyz, clusters.bounds[tileIndex].minAABB, clusters.bounds[tileIndex].maxAABB);
      lightInCluster = (sqDist <= (range * range));
    }
    if (lightInCluster) {
      cluserLightIndices[clusterLightCount] = i;
      clusterLightCount = (clusterLightCount + 1u);
    }
    if ((clusterLightCount == 256u)) {
      break;
    }
  }
  let lightCount = clusterLightCount;
  var offset = atomicAdd(&(clusterLights.offset), lightCount);
  if ((offset >= 1769472u)) {
    return;
  }
  for(var i = 0u; (i < clusterLightCount); i = (i + 1u)) {
    clusterLights.indices[(offset + i)] = cluserLightIndices[i];
  }
  clusterLights.lights[tileIndex].offset = offset;
  clusterLights.lights[tileIndex].count = clusterLightCount;
}