struct Configuration {
  gridSize: vec2f,
  aspect: vec2f,
  matrix: mat4x4f
};

@group(0) @binding(0) var<uniform> config: Configuration;
@group(0) @binding(1) var<storage> state: array<u32>;

struct VertexInput {
  @location(0) position: vec3f,
  @location(1) texture: vec2f,
  @location(2) normal: vec3f,
  @location(3) tangent: vec4f,
  @builtin(instance_index) instance: u32,
};

struct VertexOutput {
  @builtin(position) position: vec4f,
  @location(0) cell: vec2f,
  @location(1) normal: vec3f,
};

struct FragmentInput {
  @location(0) cell: vec2f,
  @location(1) normal: vec3f,
};

@vertex
fn vertexMain(input: VertexInput) -> VertexOutput
{
  let position = input.position * 0.5 + 0.5;
  let instance = f32(input.instance);

  let state = f32(state[input.instance]);
  let cell = vec2f(instance % config.gridSize.x, floor(instance / config.gridSize.y));
  let grid = (position * state + vec3f(cell, 0)) / config.gridSize.xxx;

  var output: VertexOutput;
  //output.position = (config.matrix * vec4f((grid * 2 - 1), 1)) * vec4f(config.aspect, 1, 1);
  output.position = config.matrix * vec4f((grid * 2 - 1), 1);

  //output.position = config.matrix * vec4f(input.position, 1);

  output.cell = cell / config.gridSize;
  output.normal = input.normal;
  return output;
}

@fragment
fn fragmentMain(input: FragmentInput) -> @location(0) vec4f
{
  return vec4f(input.normal * 0.5 + 0.5, 1);
}