#version 450 core
#extension GL_ARB_separate_shader_objects : enable

layout (constant_id = 0) const bool FOG = true;
layout (constant_id = 1) const bool PBR = true;
// FS spe
layout (constant_id = 8) const bool DO_CURVATURE = false;
layout (constant_id = 9) const bool CURV_DEPTH = true;

layout (binding = 0) uniform UniformBufferObject {
    mat4 view;
    mat4 proj;

    vec3 lightInvDirection_worldspace;

    vec4 fog; //color.rgb depth.a
} UBO;

layout(push_constant) uniform PushConst {
#ifndef INSTANCED
    mat4 model;
#endif

    vec4 sphereProj;
    float curvature;
} Push;

layout (location = 0) in vec3 Position_modelspace;
layout (location = 1) in uint Texture_model;
layout (location = 2) in vec3 Normal_modelspace;

#ifdef INSTANCED
layout (location = 6) in mat4 Model;
#endif

layout (location = 0) out VertexData {
    vec3 Position_modelspace;
    flat uint Texture;
    vec3 FaceNormal_modelspace;

    vec3 FaceNormal_worldspace;
    vec3 EyeDirection_cameraspace;
    vec3 LightDirection_cameraspace;

    float Depth;
} vs;

void main(){
#ifndef INSTANCED
    mat4 Model = Push.model;
#endif

    vs.Position_modelspace = Position_modelspace;

if(DO_CURVATURE) {
    if(Push.curvature > 0) {
        vec3 Position_areaspace = Position_modelspace + Push.sphereProj.xyz;
        vec2 sph = vec2(acos(Position_areaspace.z / length(Position_areaspace.xyz)), atan(Position_areaspace.y, Position_areaspace.x));
        float radius = CURV_DEPTH ?
            max(max(abs(Position_areaspace.x), abs(Position_areaspace.y)), abs(Position_areaspace.z)) :
            Push.sphereProj.w;
        vs.Position_modelspace = mix(vs.Position_modelspace, vec3(sin(sph.x)*cos(sph.y), sin(sph.x)*sin(sph.y), cos(sph.x)) * radius - Push.sphereProj.xyz, Push.curvature);
    }
}

    vec4 Position_cameraspace = UBO.view * Model * vec4(vs.Position_modelspace, 1);
    gl_Position = UBO.proj * Position_cameraspace;

if(FOG) {
    vs.Depth = length(Position_cameraspace.xyz) / UBO.fog.a;
}

    vs.Texture = Texture_model;

    vs.FaceNormal_modelspace = normalize(Normal_modelspace);
if(PBR) {
    // TODO: correct normal curvature
    vs.FaceNormal_worldspace = normalize((Model * vec4(vs.FaceNormal_modelspace, 0)).xyz);

    // Vector that goes from the vertex to the camera, in camera space.
    // In camera space, the camera is at the origin (0,0,0).
    vs.EyeDirection_cameraspace = vec3(0,0,0) - Position_cameraspace.xyz;

    // Vector that goes from the vertex to the light, in camera space
    vs.LightDirection_cameraspace = (UBO.view * vec4(UBO.lightInvDirection_worldspace,0)).xyz;
}
}
