#version 420 core
 
out vec3 WorldPos;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
 
const vec3 positions[4] = vec3[4](
        vec3(-1.0, 0.0, -1.0), // TL
        vec3(1.0, 0.0, -1.0), // BL
        vec3(1.0, 0.0, 1.0), // BR
        vec3(-1.0, 0.0, 1.0) // TL
    );
 
const int indices[6] = int[6](0, 2, 1, 2, 0, 3);
 
void main() {
    // gl_VertexID [0 : 5] because the shader is use a gldraw with 6 as parameters
    WorldPos = positions[indices[gl_VertexID]];
    vec4 Pos = projectionMatrix * viewMatrix * vec4(WorldPos, 1.0);
    gl_Position = Pos;
}

 
#version 420 core
in vec3 WorldPos;
out vec4 FragColor;
 
void main()
{
    float gridCellSize = 0.25;
    vec4 blackColor = vec4(0.0f, 0.0f, 0.0f, 1.0f);
 
    float lx = length(vec2(dFdx(WorldPos.x), dFdy(WorldPos.x)));
    float ly = length(vec2(dFdx(WorldPos.z), dFdy(WorldPos.z)));
    vec2 dxdy = vec2(lx, ly);
 
    float d = mod(WorldPos.z, gridCellSize);
    float lod0a = 1.0f - d / ly;
 
    FragColor = blackColor;
    FragColor.a *= lod0a;
}

 
void Render::moveGizmo(double &lastX, double &lastY)
{
    double mouseX, mouseY;
    Entity *obj = Gizmo::getObj();
    auto pos = obj->getMesh().getPos();
    auto vert = Gizmo::getGizmo()[3].getMesh().getVertices();
    std::array<double,3> axis = {0, 0, 0}, plane = {0, 0, 0}, axisWorld, planeWorld;
    int index = Gizmo::getArrPos()[3];
 
    if (index-- == 0)
        return ;
    axis[index] = 1.0;
    if (axis[0] == 1.0) plane = {0,0,1}; // X → plan XY
    if (axis[1] == 1.0) plane = {0,0,1}; // Y → plan XY
    if (axis[2] == 1.0) plane = {0,1,0}; // Z → plan XZ
    obj->turnAxis(axis, axisWorld);
    obj->turnAxis(plane, planeWorld);
    glfwGetCursorPos(Opengl::getWindow(), &mouseX, &mouseY);
    std::array<double, 3> dirLast, originLast, dirM, originM, interLast, interMouse;
 
    if (!unprojectMouse(lastX, lastY, dirLast[0], dirLast[1], dirLast[2], originLast))
        return ;
    if (!unprojectMouse(mouseX, mouseY, dirM[0], dirM[1], dirM[2], originM))
        return ;
    if (!getIntersection(planeWorld, originLast, dirLast, interLast))
        return ;
    if (!getIntersection(planeWorld, originM, dirM, interMouse))
        return ;
    std::array<double, 3> delta = {interMouse[0] - interLast[0], interMouse[1] - interLast[1], interMouse[2] - interLast[2]};
    double dot = delta[0]*axisWorld[0] + delta[1]*axisWorld[1] + delta[2]*axisWorld[2];
    std::array<double, 3> deltaAxis = {dot * axisWorld[0], dot * axisWorld[1], dot * axisWorld[2]};
    obj->setPos(pos[0] + deltaAxis[0],
                pos[1] + deltaAxis[1],
                pos[2] + deltaAxis[2]);
 
    lastX = mouseX;
    lastY = mouseY;
}

$input a_position, a_texcoord0
//$output v_texcoord0
$output v_position
$output v_normal
 
#include "common.sh"
 
//SAMPLER2D(s_texColor, 0);
uniform mat4 matview;
uniform vec4 eBias;
 
//out vec2 OutTexCoord0;
//out vec4 vertexColor; // Remplace l'ancien gl_BackColor
 
void main()
{
 
	// v_texcoord0 = a_texcoord0;
 
 
    gl_Position = mul(matview, vec4(a_position, 1.0) );
 
 
    v_position=a_position;
 
	v_normal = vec3(0,0,1);  // normale arbitraire
	gl_Position=gl_Position+eBias;
 
 
 
}

// fs_spot_lightonly.sc
$input v_normal, v_position
#include "common.sh"
 
// uniforms
uniform vec4 u_lightPos;   // xyz = position du spot, w = cos(cutoffAngle)
uniform vec4 u_lightDir;   // xyz = direction du spot normalisée
uniform vec4 u_lightColor; // rgb = couleur du spot
 
void main()
{
vec3 N = normalize(v_normal);
 
    // vecteur du fragment vers la lumière
    vec3 fragToLight = normalize(u_lightPos.xyz - v_position);
 
    // cos de l’angle entre direction du spot et fragment
    float cosTheta = dot(normalize(u_lightDir.xyz), fragToLight);
 
    // si on veut autoriser demi-angle > 90° (jusqu'à 180°)
    float cutoff = clamp(u_lightPos.w, -1.0, 1.0); // cos(demi-angle) peut être négatif
    float spot = smoothstep(cutoff, 1.0, cosTheta);
 
    // Lambert
    float ndotl = max(dot(N, fragToLight), 0.0);
 
    vec3 contrib = u_lightColor.rgb * ndotl * spot;
 
    gl_FragColor = vec4(contrib, 1.0);
}

 
#include <iostream>
#include <fstream>
#include <string>
 
char* chargement(std::string nom)
{
    char* adresse = nullptr;
    int taille;
 
    std::ifstream flux(nom, std::ios::in);
    if(!flux){std::cout << "fichier " << nom << " introuvable !\n";}
 
    flux.seekg(0, std::ios::end);
    taille = flux.tellg();
 
    flux.seekg(0, std::ios::beg);
    for (int i = 0; i<taille; i++)
    {
        flux.read(adresse+i, sizeof(char));
    }
    // ajouter \0
    adresse[taille] = '\0';
    // fermer le fichier
    flux.close();
    // renvoyer adresse
    return adresse;
 
}

 
            if (_OgldevMouse == OGLDEV_MOUSE_BUTTON_LEFT) {
                // Step 1: Convert mouse coordinates to Normalized Device Coordinates (NDC)
                float ndcX = ((2.0f * x) / WINDOW_WIDTH) - 1.0f;
                float ndcY = 1.0f - (2.0f * y) / WINDOW_HEIGHT; // Invert Y-axis
                Vector4f rayClip(ndcX, ndcY, -1.0f, 1.0f); // Ray in clip space
 
                std::cout << "mouse (raw) : " << x << ", " << y << std::endl;
                std::cout << "mouse (NDC) : " << ndcX << ", " << ndcY << std::endl;
 
                // Step 2: Unproject from clip space to view space
                Matrix4f projMatrix;
                projMatrix.InitPersProjTransform(m_persProjInfo);
                Matrix4f invProj = projMatrix.Inverse();
                Vector4f rayEye = invProj * rayClip;
                rayEye.z = -1.0f; // Set forward direction
                rayEye.w = 0.0f;  // This is a direction, not a point
 
                // Step 3: Unproject from view space to world space
                Matrix4f invView = m_pGameCamera->GetViewMatrix().Inverse();
                Vector3f rayWorld = (invView * rayEye).to3f();
 
                // Step 4: Define the grid plane (XZ plane at y = 0)
                Vector3f planeNormal(0.0f, 1.0f, 0.0f); // Normal of the XZ plane
                float planeD = 0.0f; // Plane equation: y = 0 -> 0*x + 1*y + 0*z = 0
 
                // Step 5: Compute ray-plane intersection
                Vector3f rayOrigin = m_pGameCamera->GetPos(); // Camera position
                float t = -(rayOrigin.Dot(planeNormal) + planeD) / (rayWorld.Dot(planeNormal));
 
                if (t > 0.0f) { // Intersection exists
                    Vector3f intersection = rayOrigin + rayWorld * t;
                    std::cout << "origin vector is        : " << rayOrigin.x << ", " << rayOrigin.y << ", " << rayOrigin.z << std::endl;
                    std::cout << "rayWorld vector is      : " << rayWorld.x << ", " << rayWorld.y << ", " << rayWorld.z << std::endl;
                    std::cout << "Mouse intersects grid at: " << intersection.x << ", " << intersection.y << ", " << intersection.z << std::endl;
 
                    // You can now use the intersection point for further logic
                } else {
                    std::cout << "No intersection with the grid." << std::endl;
                }
            }
        }