// Based on: https://github.com/frozein/VkGalaxy/blob/main/assets/shaders/particle.vert
#version 450

#define RANDOM_IA 16807
#define RANDOM_IM 2147483647
#define RANDOM_AM 1.0 / float(RANDOM_IM)
#define RANDOM_IQ 127773
#define RANDOM_IR 2836
#define RANDOM_MASK 123459876

int _SEED = 0;

void srand_cycle()
{
    _SEED ^= RANDOM_MASK;
    int k = _SEED / RANDOM_IQ;
    _SEED = RANDOM_IA * (_SEED - k * RANDOM_IQ) - RANDOM_IR * k;

    if (_SEED < 0)
        _SEED += RANDOM_IM;

    _SEED ^= RANDOM_MASK;
}

void srand_set(int seed)
{
    _SEED = seed;
    srand_cycle();
}

float rand()
{
    srand_cycle();
    return RANDOM_AM * _SEED;
}

#define NUM_VERTICES 6
const vec3 VERTICES[NUM_VERTICES] =
{
    vec3(-0.5, 0.0, -0.5),
    vec3( 0.5, 0.0, -0.5),
    vec3(-0.5, 0.0,  0.5),
    vec3( 0.5, 0.0, -0.5),
    vec3(-0.5, 0.0,  0.5),
    vec3( 0.5, 0.0,  0.5)
};

layout (location = 0) out vec2 out_tex;
layout (location = 1) out float temperature;
layout (location = 2) out flat uint out_type;

struct particle
{
    vec2 pos;
    float height;
    float angle;
    float tilt;
    float vel;
    float opacity;
    float temp;
};

layout (push_constant) uniform particle_info
{
    uint star_count;
    float time;
    float min_temp, max_temp;
    float star_size, dust_size, h2size;
    float h2dist;
}   info;

layout (binding = 0) uniform camera_info
{
    mat4 proj_view;
}   camera;

layout (std140, binding = 1) readonly buffer stars
{
    particle particles[];
} particles;

float ease_in_circ(float x)
{
    return x >= 1.0 ? 1.0 : 1.0 - sqrt(1.0 - x * x);
}

vec2 calc_pos(particle p)
{
    float angle = p.angle + p.vel * info.time;

    float ca = cos(angle);
    float sa = sin(angle);
    float ct = cos(p.tilt);
    float st = sin(p.tilt);

    vec2 pos = p.pos;

    return vec2(pos.x * ca * ct - pos.y * sa * st,
                pos.x * ca * st + pos.y * sa * ct);
}

void main(void)
{
    srand_set(gl_VertexIndex);
    vec3 pos = VERTICES[gl_VertexIndex % NUM_VERTICES];
    vec2 tex_pos = VERTICES[gl_VertexIndex & NUM_VERTICES].xz + vec2(0.5);

    particle p = particles.particles[gl_VertexIndex / NUM_VERTICES];
    uint type = (gl_VertexIndex / NUM_VERTICES) < info.star_count ? 1 : 0;
    float scale = 0.0;

    if(type == 0 && gl_VertexIndex / NUM_VERTICES % 150 == 0)
        type = 2;

    if(type == 0)  // Star
        scale = info.star_size;
    else if(type == 1)     // Dust
        scale = info.dust_size;
    else    // H-2 region
    {
        particle h2particle = p;
        h2particle.pos.x += info.h2dist;

        vec2 pos1 = calc_pos(h2particle);
        vec2 pos2 = calc_pos(p);
        float dist = distance(pos1, pos2);
        dist = ease_in_circ(dist / info.h2dist);

        scale = info.h2size * (1.0 - dist);
    }

    vec2 new_pos = calc_pos(p);
    vec3 world_space = vec3(new_pos.x, p.height, new_pos.y) * scale;

    out_type = type;
    temperature = info.min_temp + rand() * (info.max_temp - info.min_temp);

    gl_Position = camera.proj_view * vec4(world_space, 1.0);
}