#include <iostream>
#include "time.h"

#include "dispositif.h"
#include "raytracer.h"
#include "scene.cpp"

LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
void EnableOpenGL(HWND hwnd, HDC*, HGLRC*);
void DisableOpenGL(HWND, HDC, HGLRC);

using namespace std;

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
    WNDCLASSEX wcex;
    HWND hwnd;
    HDC hDC;
    HGLRC hRC;
    MSG msg;
    BOOL bQuit = FALSE;
    float theta = 0.0f;

    /* register window class */
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_OWNDC;
    wcex.lpfnWndProc = WindowProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = "GLSample";
    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);;


    if (!RegisterClassEx(&wcex))
        return 0;

    /* create main window */
    hwnd = CreateWindowEx(0,
                          "GLSample",
                          "Raytracer",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          800,
                          600,
                          NULL,
                          NULL,
                          hInstance,
                          NULL);

    ShowWindow(hwnd, nCmdShow);

    /* enable OpenGL for the window */
    EnableOpenGL(hwnd, &hDC, &hRC);

    PerfChrono chrono;
    Ecran* lcd = new Ecran(800,600);
    Scene *scene = new Scene();
    lancerDeRayon* rayTracer=new lancerDeRayon(800,600);
    Animation *animation;

    Camera* macamera = scene->ajouterCamera((Position3f){0.0f, 1.0f, -10000.0f});
            macamera->cibler((Vecteur){0.0f, 0.0f, 1.0f});

    Lumiere* soleil = scene->ajouterLumiere((Position3f){ 0.0, 240.0, -1000.0});
             soleil->colorer(1.f, 1.f, 1.f);
    Lumiere* lumiere = scene->ajouterLumiere((Position3f){640.0, 240.0 ,-100.0});
             lumiere->colorer(0.3f, 0.3f, 0.3f);

    Sphere* lune = scene->ajouterSphere((Position3f){ 50.0, 290.0, 0.0});
            lune->redimensionner(40);
            lune->indexMateriau(0);
    Sphere* planeteTerre = scene->ajouterSphere((Position3f){ 350.0, 290.0, 0.0});
            planeteTerre->redimensionner(100);
            planeteTerre->indexMateriau(1);

    /* program main loop */
    while (!bQuit)
    {
        /* check for messages */
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            /* handle or dispatch messages */
            if (msg.message == WM_QUIT)
            {
                bQuit = TRUE;
            }
            else
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else
        {
            /* OpenGL animation code goes here */
        cout<<"Frequence de l'horloge : "<<chrono.GetFreq()<<" Hz."<<endl;
        chrono.Start();

        lune->positioner(animation->orbite(planeteTerre->Position()));
        lcd->diffuser(rayTracer->trace(scene));

        cout<<(chrono.GetDiffNs()/1000000)<<endl;
        SwapBuffers(hDC);
        }
    }

    /* shutdown OpenGL */
    DisableOpenGL(hwnd, hDC, hRC);

    /* destroy the window explicitly */
    DestroyWindow(hwnd);

    return msg.wParam;
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CLOSE:
            PostQuitMessage(0);
        break;

        case WM_DESTROY:
            return 0;

        case WM_KEYDOWN:
        {
            switch (wParam)
            {
                case VK_ESCAPE:
                    PostQuitMessage(0);
                break;
            }
        }
        break;

        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }

    return 0;
}

void EnableOpenGL(HWND hwnd, HDC* hDC, HGLRC* hRC)
{
    PIXELFORMATDESCRIPTOR pfd;

    int iFormat;

    /* get the device context (DC) */
    *hDC = GetDC(hwnd);

    /* set the pixel format for the DC */
    ZeroMemory(&pfd, sizeof(pfd));

    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
                  PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;

    iFormat = ChoosePixelFormat(*hDC, &pfd);

    SetPixelFormat(*hDC, iFormat, &pfd);

    /* create and enable the render context (RC) */
    *hRC = wglCreateContext(*hDC);

    wglMakeCurrent(*hDC, *hRC);
}

void DisableOpenGL (HWND hwnd, HDC hDC, HGLRC hRC)
{
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(hRC);
    ReleaseDC(hwnd, hDC);
}

#ifndef Dispositif_loaded
#define Dispositif_loaded

#include <gl/gl.h>

class Ecran
{
      protected:
       unsigned int largeur, hauteur;

    public:
        Ecran(int Largeur, int Hauteur):largeur(Largeur),
                                        hauteur(Hauteur)
        {
        }
        void diffuser(unsigned char*  cellulesRVB)
        {
            glDrawPixels( largeur, hauteur, GL_RGB, GL_UNSIGNED_BYTE, cellulesRVB);
        }
};
#endif

#ifndef Raytracer_loaded
#define Raytracer_loaded

#include "geometrie.h"
#include "collision.h"
#include "scene.h"

class lancerDeRayon
{
    private:
        unsigned int largeur, hauteur;
        unsigned char*  cellulesRVB;
        float profondeur;
        float rouge , vert , bleu ;
        float coef ;
        int niveau ;
        Collision *collision;

    public:
        lancerDeRayon(unsigned int Largeur,unsigned int Hauteur):   largeur(Largeur),
                                                                    hauteur(Hauteur),
                                                                    cellulesRVB((unsigned char *) malloc( Largeur * Hauteur * 3 ))
        {
        }
       unsigned char* trace(Scene* scene)
        {
            int z=-1;
            for (int y = 0; y <hauteur; ++y)//on parcours chaque ligne
            {
                for (int x = 0; x < largeur; ++x)//pour chaque ligne, on parcours toutes ses colonnes
                {// on traite le pixel
                    rouge = 0, vert = 0, bleu = 0;
                    coef = 1.0f;
                    niveau = 0;
                    profondeur = 20000.0f;
                    // on initialise le rayon en fonction de la position de la camera et de sa direction
                     Rayon rayonActuel = { scene->positionCamera()+ (Vecteur){ float(x), float(y), 0.f }  , scene->directionCamera()};
                     do
                     {
                        // on cherche si un objet se trouve dans le champ du rayon
                            int indexSphere= -1;
                            for (unsigned int i = 0; i < scene->nbSpheres(); ++i)
                                if (collision->sphere(rayonActuel, scene->sphereId(i), profondeur))//en cas d'intersection on definit sa distance dans "profondeur"
                                    indexSphere = i;
                            if (indexSphere == -1)// si aucun objet n'est trouver on arrete le traitement et on passe au pixel suivant
                             break;

                        //en cas d'intersection avec un objet, on va defininir un nouveau rayon partant de cet objet
                           Position3f nouveauDepart = rayonActuel.depart + profondeur * rayonActuel.direction;

                           //on calcule la normale au point d'intersection
                           Vecteur normale = calculerNormale(nouveauDepart,scene->positionSphereId(indexSphere));
                          if( normale == 0)break;

                            //on recupere le materiau
                           Materiau materiauActuel = *scene->materiauId(scene->materiauSphere(indexSphere));

                        // calcul de la valeur d'éclairement au point
                           for (unsigned int j = 0; j < scene->nbLumieres(); ++j)
                           {
                                 Lumiere lumiereActuel = *scene->lumiereId(j);
                                 Vecteur distance = lumiereActuel.Position() - nouveauDepart;
                                 if (normale * distance <= 0.0f)
                                   continue;
                                 float profondeur = sqrtf(distance * distance);
                                 if ( profondeur <= 0.0f )
                                   continue;
                                 Rayon rayonDeLumiere;
                                 rayonDeLumiere.depart = nouveauDepart;
                                 rayonDeLumiere.direction = (1/profondeur) * distance;

                                 // calcul des ombres
                                 bool ombre = false;
                                 for (unsigned int i = 0; i < scene->nbLumieres(); ++i)
                                 {
                                    if (collision->sphere(rayonDeLumiere, scene->sphereId(i), profondeur))
                                    {
                                         ombre = true;
                                         break;
                                    }
                                 }
                                 if (!ombre)
                                 {
                                    // lambert
                                    float lambert = (rayonDeLumiere.direction * normale) * coef;
                                    rouge += lambert * lumiereActuel.Rouge() * materiauActuel.rouge;
                                    vert += lambert * lumiereActuel.Vert() * materiauActuel.vert;
                                    bleu += lambert * lumiereActuel.Bleu() * materiauActuel.bleu;
                                }
                           }

                           // on itére sur la prochaine reflexion
                           coef *= materiauActuel.reflection;
                           float reflet = 2.0f * (rayonActuel.direction * normale);
                           rayonActuel.depart = nouveauDepart;
                           rayonActuel.direction = rayonActuel.direction - reflet * normale;

                           niveau++;
                     }
                    while ((coef > 0.0f) && (niveau < 10));

                    cellulesRVB[z++]=((unsigned char)min(rouge*255.0f,255.0f));
                    cellulesRVB[z++]=((unsigned char)min(vert*255.0f, 255.0f));
                    cellulesRVB[z++]=((unsigned char)min(bleu*255.0f, 255.0f));
                }
            }
            return cellulesRVB;
        }
};
#endif

#ifndef Scene_loaded
#define Scene_loaded

#include "materiau.h"
#include "lumiere.h"
#include "animation.h"
#include "camera.h"

class Scene
{
    private:

        unsigned int nbmateriaux, nbspheres, nblumieres, nbcameras, CameraActuel;
        Materiau listeMateriaux[3];
        Sphere   listeSpheres[3];
        Lumiere  listeLumieres[3];
        Camera   listecameras[3];

    public:
        Scene();
        Camera*  ajouterCamera(Position3f position);
        Sphere*  ajouterSphere(Position3f position);
        Lumiere* ajouterLumiere(Position3f position);

        //pour le raytracer
        Position3f  positionCamera()const;
        Vecteur     directionCamera()const;

        int nbMateriaux()const;
        int nbSpheres()const;
        int nbLumieres()const;

        Sphere* sphereId(unsigned int i);
        Materiau* materiauId(unsigned int i);
        Lumiere* lumiereId(unsigned int i);
        unsigned int materiauSphere(unsigned int id)const;
        Position3f positionSphereId(unsigned int id)const;
};
#endif

#include "scene.h"

Scene::Scene()
{
    nbcameras=0;
    nbmateriaux=3, nbspheres=0, nblumieres=0;
    CameraActuel=0;

    listeMateriaux[0].rouge=0.0;
    listeMateriaux[0].vert=1.0;
    listeMateriaux[0].bleu=1.0;
    listeMateriaux[0].reflection=0.5;
    listeMateriaux[1].rouge=1.0;
    listeMateriaux[1].vert=0.0;
    listeMateriaux[1].bleu=1.0;
    listeMateriaux[1].reflection=0.5;

}
Camera* Scene::ajouterCamera(Position3f position)
{
    nbcameras++;
    listecameras[nbcameras-1].positioner(position);
    return &listecameras[nbcameras-1];
}
Sphere* Scene::ajouterSphere(Position3f position)
{
    nbspheres++;
    listeSpheres[nbspheres-1].positioner(position);
    return &listeSpheres[nbspheres-1];
}
Lumiere* Scene::ajouterLumiere(Position3f position)
{
    nblumieres++;
    listeLumieres[nblumieres-1].positioner(position);
    return &listeLumieres[nblumieres-1];
}
Position3f Scene::positionCamera()const
{
    return listecameras[CameraActuel].Position();
}
Vecteur Scene::directionCamera()const
{
    return listecameras[CameraActuel].direction();
}
int Scene::nbMateriaux()const
{
    return nbmateriaux;
}
int Scene::nbSpheres()const
{
    return nbspheres;
}
int Scene::nbLumieres()const
{
    return nblumieres;
}
Sphere* Scene::sphereId(unsigned int i)
{
    return &listeSpheres[i];
}
Materiau* Scene::materiauId(unsigned int i)
{
    return &listeMateriaux[i];
}
Lumiere* Scene::lumiereId(unsigned int i)
{
    return &listeLumieres[i];
}
unsigned int Scene::materiauSphere(unsigned int id)const
{
    return listeSpheres[id].Materiau();
}
Position3f Scene::positionSphereId(unsigned int id)const
{
    return  listeSpheres[id].Position();
}

#ifndef Materiau_loaded
#define Materiau_loaded

struct Materiau {
	float rouge, vert, bleu, reflection;
};

#endif

#ifndef Lumiere_loaded
#define Lumiere_loaded

class Lumiere
{
    private:
        Position3f position;
        float rouge, vert, bleu;

    public:
        void positioner(Position3f Position)
        {
             position = Position;
        }
        void colorer( float Rouge,float Vert,float Bleu)
        {
             rouge=Rouge;
             vert=Vert;
             bleu=Bleu;
        }
        Position3f Position()const
        {
            return position;
        }
        float Rouge()const
        {
            return rouge;
        }
        float Vert()const
        {
            return vert;
        }
        float Bleu()const
        {
            return bleu;
        }
};

#endif

#ifndef Animation_loaded
#define Animation_loaded

class Animation
{

    public:
        Animation();
        Position3f orbite(Position3f centre)
        {
            static float alpha=0;
            alpha+=0.01;
            if(alpha>360)alpha=0;
            float distance = 200.0f;

            return (Position3f){distance * cos(alpha)+centre.x, centre.y, distance * sin(alpha)+centre.z};
        }
};

#endif

#ifndef Camera_loaded
#define Camera_loaded

class Camera
{
    private:
        Position3f position;
        Vecteur cible;

    public:
        void positioner(Position3f Position)
        {
             position = Position;
        }
        void cibler(Vecteur Cible)
        {
             cible = Cible;
        }
        Vecteur direction()const
        {
            return cible;
        }
        Position3f Position()const
        {
            return position;
        }
};
#endif

#ifndef Collision_loaded
#define Collision_loaded

class Collision
{
    public:
        Collision();
        bool sphere(const Rayon rayon, const Sphere* sphere, float &profondeur)
         {
           // intersection rayon/sphere

           Vecteur distance = sphere->Position() - rayon.depart;
           float B = rayon.direction * distance;
           float delta = B*B - distance * distance + sphere->Taille() * sphere->Taille();
           if (delta < 0.0f)
             return false;
           float profondeur0 = B - sqrtf(delta);
           float profondeur1 = B + sqrtf(delta);
           bool colision = false;
           if ((profondeur0 > 0.1f) && (profondeur0 < profondeur))
           {
             profondeur = profondeur0;
             colision = true;
           }
           if ((profondeur1 > 0.1f) && (profondeur1 < profondeur))
           {
             profondeur = profondeur1;
             colision = true;
           }
           return colision;
         }
};
#endif

#ifndef Geometrie_loaded
#define Geometrie_loaded

#include <vector>
#include <cmath>
#include <limits>
#include <algorithm>
#define min(a,b) ((a)<(b)?(a):(b))

struct Position3f {	float x, y, z;};

struct Vecteur {float x, y, z;};

struct Rayon {
	Position3f depart;
	Vecteur direction;
};

class Sphere
{
    private:
        Position3f position;
        float taille;
        int materiau;

    public:
        void positioner(Position3f Position)
        {
             position = Position;
        }
        void  redimensionner (float Taille)
        {
             taille=Taille;
        }
        void indexMateriau(int index)
        {
            materiau=index;
        }
        Position3f Position()const
        {
            return position;
        }
        int Materiau()const
        {
            return materiau;
        }
        float  Taille()const
        {
             return taille;
        }
};

Position3f operator + (const Position3f&p, const Vecteur &v){return (Position3f){p.x + v.x, p.y + v.y, p.z + v.z };}
Position3f operator - (const Position3f&p, const Vecteur &v){return (Position3f){p.x - v.x, p.y - v.y, p.z - v.z };}

Vecteur operator - (const Position3f&p1, const Position3f &p2){return (Vecteur){p1.x - p2.x, p1.y - p2.y, p1.z - p2.z };}
Vecteur operator * (float c, const Vecteur &v){	return (Vecteur) {v.x *c, v.y * c, v.z * c };}
Vecteur operator - (const Vecteur&v1, const Vecteur &v2){return (Vecteur){v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };}
bool operator == (const Vecteur&v1, int null)
{
   if(v1.x==0 && v1.y==0 && v1.z==0)return true;
   else return false;
}

float operator * (const Vecteur&v1, const Vecteur &v2 ) {	return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;}

Vecteur calculerNormale(Position3f depart,Position3f direction)
{
     Vecteur normale= depart - direction;
     float temp = normale * normale;
     if (temp == 0.0f)return (Vecteur){0,0,0};

     temp = 1.0f / sqrtf(temp);
     return temp * normale;
}
#endif

#include "dispositif.h"//device pour les intimes ;)
#include "rendu.cpp"//raytracer
#include "scene.cpp"
#include "animation.h"

int main()
{ //______________________________________MOTEUR
    Animation *animation;
    C_Ecran* ecran = new C_Ecran(800,600);
    C_Rendu* rendu = new C_Rendu(800,600);
    C_Scene* scene = new C_Scene();
  //__________________________________________________________________________SCENE
    C_Camera*  macamera = scene->ajouterCamera(Vecteur(0.0, 1.0, -10000.0));
               macamera->cibler(Vecteur(0.0, 0.0, 1.0));

    C_Lumiere* soleil = scene->ajouterLumiere(Vecteur( 0.0, 240.0, -1000.0));
               soleil->colorer(1.0, 1.0, 1.0);
    C_Lumiere* lumiere = scene->ajouterLumiere(Vecteur(640.0, 240.0 ,-100.0));
               lumiere->colorer(0.3, 0.3, 0.3);

    I_Forme*   lune=new C_Sphere(Vecteur( 50.0, 290.0, 0.0));
               lune->redimensionner(40);
               lune->definirMateriau(0);
               scene->ajouterForme(lune);
    I_Forme*   planeteTerre=new C_Sphere(Vecteur( 350.0, 290.0, 0.0));
               planeteTerre->redimensionner(100);
               planeteTerre->definirMateriau(1);
               scene->ajouterForme(planeteTerre);
  //__________________________________________________________________BOUCLE PRINCIPALE
    while (!quitter())
    {
        lune->positioner(animation->orbite(planeteTerre->Position()));

        ecran->diffuser(rendu->lancerDeRayons(scene->parametres()));
    }
  //____________________AU REVOIR
    delete lune;
    delete planeteTerre;
    delete scene;
    delete rendu;
    delete ecran;
    return 0;
}

#ifndef Scene_loaded
    #include "lumiere.h"
    #include "camera.h"
    #include "sphere.h"

struct S_Scene//***********************************************************
{//structure contenant les paramètres de la scene à envoyer au raytracer
    Materiau   listeMateriaux[3];
    I_Forme*   listeFormes[3];
    C_Lumiere  listeLumieres[3];
    C_Camera*  cameraActuel;
    int        nbformes,    nblumieres;
    S_Scene(): nbformes(0), nblumieres(0){}
};//***********************************************************************

class C_Scene
{
    private://** ***************************
        int      nbcameras, idCameraActuel;
        C_Camera listeCameras[3];
        S_Scene* parametresScene;

    public://***** *********************************************
                   C_Scene();
         C_Camera* ajouterCamera(vecteur3f position);
              void ajouterForme(I_Forme* forme);
        C_Lumiere* ajouterLumiere(vecteur3f position);
          S_Scene& parametres()const {return *parametresScene;}
                   ~C_Scene() {delete parametresScene;}
};
    #define Scene_loaded
#endif

#include "scene.h"
//______________________________________________________________________________________INIT
C_Scene::C_Scene():nbcameras(0),idCameraActuel(0)
{
    parametresScene=new S_Scene;
    parametresScene->listeMateriaux[0].rouge=0.0;
    parametresScene->listeMateriaux[0].vert=1.0;
    parametresScene->listeMateriaux[0].bleu=1.0;
    parametresScene->listeMateriaux[0].reflection=0.0f;
    parametresScene-> listeMateriaux[1].rouge=1.0;
    parametresScene->listeMateriaux[1].vert=0.0;
    parametresScene->listeMateriaux[1].bleu=1.0;
    parametresScene-> listeMateriaux[1].reflection=1.0;
}//_____________________________________________________________________________________AJOUTER_CAMERA
C_Camera* C_Scene::ajouterCamera(vecteur3f position)
{   nbcameras++;
    listeCameras[idCameraActuel].positioner(position);
    parametresScene->cameraActuel=&listeCameras[idCameraActuel];
    return &listeCameras[idCameraActuel];
}//_____________________________________________________________________________________AJOUTER_FORME
void C_Scene::ajouterForme(I_Forme* forme)
{
    parametresScene->listeFormes[++parametresScene->nbformes-1]=forme;
}//_____________________________________________________________________________________AJOUTER_LUMIÈRE
C_Lumiere* C_Scene::ajouterLumiere(vecteur3f position)
{
    parametresScene->listeLumieres[++parametresScene->nblumieres-1].positioner(position);
    return &parametresScene->listeLumieres[parametresScene->nblumieres-1];
}

#ifndef Noeud_loaded
    #include "math.h"

class I_Noeud //Interface pour manipuler cameras, lumieres et formes dans la scene
{
    protected:
        vecteur3f position;

	public:
        virtual void positioner(const vecteur3f& Position){this->position = Position;}
        virtual vecteur3f Position()const{return position;}
};
    #define Noeud_loaded
#endif

#ifndef Camera_loaded
    #include "noeud.h"

class C_Camera : public I_Noeud
{
    private:
        vecteur3f cible;

    public:
        void cibler(const vecteur3f Cible){this->cible = Cible;}
        vecteur3f direction()const{return cible;}
};
    #define Camera_loaded
#endif

#ifndef Lumiere_loaded
    #include "noeud.h"

class C_Lumiere : public I_Noeud
{
    private:
        float rouge, vert, bleu;

    public:
        void colorer(const float Rouge,const float Vert,const float Bleu)
        {
             this->rouge=Rouge;
             this->vert=Vert;
             this->bleu=Bleu;
        }
        float Rouge()const {return rouge;}
        float  Vert()const {return vert; }
        float  Bleu()const {return bleu; }
};
    #define Lumiere_loaded
#endif

#ifndef Forme_loaded
    #include "noeud.h"

class I_Forme : public I_Noeud //Interface pour manipuler les sphères, cubes et autres formes géometriques
{
    protected:
        float taille;
        int   materiau;

    public:
                      I_Forme(){}
      //************* **********************************************************************
        virtual  void redimensionner (const     float Taille  ) {this->taille   = Taille;  }
        virtual  void definirMateriau(const       int index   ) {this->materiau = index;   }
      //************* ***************************************************
        virtual  bool collision(const Rayon &rayon, float &profondeur)=0;
      //************* **********************************
        virtual   int Materiau()const {return materiau;}
        virtual float Taille  ()const {return taille;  }
      //************* ************
        virtual       ~I_Forme(){}
};
    #define Forme_loaded
#endif

#ifndef Sphere_loaded
    #include "forme.h"

class C_Sphere : public I_Forme
{
    public:
          C_Sphere(vecteur3f Position)
          {
              this->position=Position;
          }
          bool collision(const Rayon &rayon, float &profondeur)
          {
               // intersection rayon/sphere
               vecteur3f distance = this->position - rayon.depart;
               float B = rayon.direction * distance;
               float delta = B*B - distance * distance + this->taille * this->taille;
               if (delta < 0.0f)return false;
               float profondeur0 = B - sqrtf(delta);
               bool colision = false;
               if ((profondeur0 > 0.1f) && (profondeur0 < profondeur))
               {
                 profondeur = profondeur0;
                 colision = true;
               }
               float profondeur1 = B + sqrtf(delta);
               if ((profondeur1 > 0.1f) && (profondeur1 < profondeur))
               {
                 profondeur = profondeur1;
                 colision = true;
               }
               return colision;
          }
          ~C_Sphere()
          {
          }
};
   #define Sphere_loaded
#endif

#ifndef Rendu_loaded
    #include <iostream>
    #include "math.h"
    #include "scene.h"
    #include "time.h"

class C_Rendu
{
    private:
        PerfChrono     chrono;
        unsigned char* pixelsRVB;
        int            largeur, hauteur, niveau;
        float          rouge, vert, bleu, coef, profondeur;

    public:
        C_Rendu(int Largeur, int Hauteur):pixelsRVB((unsigned char *) malloc( Largeur * Hauteur * 3 )),
                                          largeur(Largeur),
                                          hauteur(Hauteur)
        {
        }
        unsigned char* lancerDeRayons(const S_Scene& scene);

        ~C_Rendu(){delete pixelsRVB;}
};
    #define Rendu_loaded
#endif

#include "rendu.h"

unsigned char* C_Rendu::lancerDeRayons(const S_Scene& scene)
{
    std::cout<<"Frequence de l'horloge : "<<chrono.GetFreq()<<" Hz."<<std::endl;
    chrono.Start();
    int z=-1;
    vecteur3f positionCamera =scene.cameraActuel->Position();
    vecteur3f directionCamera=scene.cameraActuel->direction();

    for (int y = 0; y <hauteur; ++y)//boucle de parcours des lignes
    {
        for (int x = 0; x < largeur; ++x)//boucle de parcours des pixels
        {
            rouge = 0, vert = 0, bleu = 0, coef = 1.0f, niveau = 0, profondeur = 20000.0f;
            //on initialise le rayon en fonction de la position de la camera et de sa direction
            Rayon rayonActuel = { positionCamera + Vecteur( float(x), float(y), 0.f )  , directionCamera};

            do//boucle de reflexion
            {
                //Recherche de formes se trouvant dans le champ du rayon
                int indexForme= -1;
                for (int i = 0; i < scene.nbformes; ++i)
                    if (scene.listeFormes[i]->collision(rayonActuel, profondeur))//en cas d'intersection on definit sa distance dans "profondeur"
                        indexForme = i;
                if (indexForme == -1) break;

                //en cas d'intersection avec un objet, on va defininir un nouveau rayon partant de cet objet
                vecteur3f nouveauDepart = rayonActuel.depart + rayonActuel.direction * profondeur;
                //on calcule la normale au point d'intersection
                vecteur3f normale = nouveauDepart.calculerNormale(scene.listeFormes[indexForme]->Position());
                if( normale == 0)break;
                //on recupere le materiau
                Materiau materiauActuel = scene.listeMateriaux[scene.listeFormes[indexForme]->Materiau()];
                //calcul de la valeur d'éclairement au point
                for (int j = 0; j < scene.nblumieres; ++j)
                {
                    C_Lumiere lumiereActuel = scene.listeLumieres[j];
                    vecteur3f distance = lumiereActuel.Position() - nouveauDepart;
                    if (normale * distance <= 0.0f)
                        continue;
                    float profondeur = sqrtf(distance * distance);
                    if ( profondeur <= 0.0f )
                        continue;
                    Rayon rayonDeLumiere;
                    rayonDeLumiere.depart = nouveauDepart;
                    rayonDeLumiere.direction = distance * (1/profondeur)  ;

                    //calcul des ombres
                    bool ombre = false;
                    for (int i = 0; i < scene.nblumieres; ++i)
                    {
                        if (scene.listeFormes[i]->collision(rayonDeLumiere, profondeur))
                        {
                            ombre = true;
                            break;
                        }
                    }
                    if (!ombre)
                    {
                        // lambert
                        float lambert = (rayonDeLumiere.direction * normale) * coef;
                        rouge += lambert * lumiereActuel.Rouge() * materiauActuel.rouge;
                        vert += lambert * lumiereActuel.Vert() * materiauActuel.vert;
                        bleu += lambert * lumiereActuel.Bleu() * materiauActuel.bleu;
                    }
                }
                //on itére sur la prochaine reflexion
                coef *= materiauActuel.reflection;
                float reflet = 2.0f * (rayonActuel.direction * normale);
                rayonActuel.depart = nouveauDepart;
                rayonActuel.direction = rayonActuel.direction - normale * reflet;

                niveau++;
            }
            while ((coef > 0.0f) && (niveau < 10));

            pixelsRVB[z++]=(unsigned char)std::min(rouge*255.0f, 255.0f);
            pixelsRVB[z++]=(unsigned char)std::min(vert *255.0f, 255.0f);
            pixelsRVB[z++]=(unsigned char)std::min(bleu *255.0f, 255.0f);
        }
    }
    std::cout<<(chrono.GetDiffNs()/1000000)<<std::endl;
    return pixelsRVB;
}

#ifndef Math_loaded
    #include <vector>
    #include <cmath>
    #include <limits>
    #include <algorithm>

template<typename T> struct vecteur3//**************************************************************************VECTEUR3
{
    T X, Y, Z;

    vecteur3<T> operator + (const vecteur3<T>& v2)const {return (vecteur3<T>){X +v2.X,   Y +v2.Y,   Z +v2.Z};}
    vecteur3<T> operator - (const vecteur3<T>& v2)const {return (vecteur3<T>){X -v2.X,   Y -v2.Y,   Z -v2.Z};}
    vecteur3<T> operator * (const float& c)       const {return (vecteur3<T>){X *c,      Y *c,      Z *c   };}
    float       operator * ( vecteur3<T>& v2)     const {return               X *v2.X   +Y *v2.Y   +Z *v2.Z ;}
    bool        operator ==(const int& nb)        const {return              (X==nb    &&Y==nb    &&Z==nb ) ;}

    vecteur3<T> calculerNormale( vecteur3<T> direction)
    {
        vecteur3<T> normale= *this - direction;
        float temp = normale * normale;
        if (temp == 0.0f)return (vecteur3<T>){0,0,0};
        return normale * (1.0f / sqrtf(temp)) ;
    }
};//*************************************************************************************************************
typedef    vecteur3<float> vecteur3f;
vecteur3f  Vecteur(float x, float y, float z){return (vecteur3f){x,y,z};}

struct Rayon{//**************************************************************************************************RAYON
    vecteur3f depart, direction;
};//*************************************************************************************************************

struct Materiau {//**********************************************************************************************MATERIAU
	float rouge, vert, bleu, reflection;
};
    #define Math_loaded
#endif

#ifndef Dispositif_loaded
    #include <gl/gl.h>
    #if (defined WIN32 || defined WIN64)
        #include "win.h"
    #else
        #include "linux.h"
    #endif

class C_Ecran
{
    protected:
        unsigned int largeur, hauteur;

    public:
        C_Ecran(unsigned int Largeur,unsigned int Hauteur): largeur(Largeur),
                                                            hauteur(Hauteur)
        {
        }
        void diffuser(unsigned char*  cellulesRVB)const
        {
            glDrawPixels( largeur, hauteur, GL_RGB, GL_UNSIGNED_BYTE, cellulesRVB);
            swap();
        }
};
    #define Dispositif_loaded
#endif

#include <windows.h>
#define main Moteur

LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
void EnableOpenGL(HWND hwnd, HDC*, HGLRC*);
void DisableOpenGL(HWND, HDC, HGLRC);

using namespace std;

MSG msg;
HDC hDC;

int Moteur();

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
    WNDCLASSEX wcex;
    HWND hwnd;
    HGLRC hRC;

    /* register window class */
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_OWNDC;
    wcex.lpfnWndProc = WindowProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = "GLSample";
    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);;

    if (!RegisterClassEx(&wcex))
        return 0;

    /* create main window */
    hwnd = CreateWindowEx(0,
                          "GLSample",
                          "Raytracer",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          800,
                          600,
                          NULL,
                          NULL,
                          hInstance,
                          NULL);

    ShowWindow(hwnd, nCmdShow);

    /* enable OpenGL for the window */
    EnableOpenGL(hwnd, &hDC, &hRC);
    /* fake main*/
    Moteur();

    /* shutdown OpenGL */
    DisableOpenGL(hwnd, hDC, hRC);

    /* destroy the window explicitly */
    DestroyWindow(hwnd);

    return msg.wParam;
}
bool quitter()
{
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            /* handle or dispatch messages */
            if (msg.message == WM_QUIT)
            {
                return true;
            }
            else
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        return false;
}

void swap()
{
   SwapBuffers(hDC);
}
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CLOSE:
            PostQuitMessage(0);
        break;

        case WM_DESTROY:
            return 0;

        case WM_KEYDOWN:
        {
            switch (wParam)
            {
                case VK_ESCAPE:
                    PostQuitMessage(0);
                break;
            }
        }
        break;

        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }

    return 0;
}

void EnableOpenGL(HWND hwnd, HDC* hDC, HGLRC* hRC)
{
    PIXELFORMATDESCRIPTOR pfd;

    int iFormat;

    /* get the device context (DC) */
    *hDC = GetDC(hwnd);

    /* set the pixel format for the DC */
    ZeroMemory(&pfd, sizeof(pfd));

    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
                  PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;

    iFormat = ChoosePixelFormat(*hDC, &pfd);

    SetPixelFormat(*hDC, iFormat, &pfd);

    /* create and enable the render context (RC) */
    *hRC = wglCreateContext(*hDC);

    wglMakeCurrent(*hDC, *hRC);
}

void DisableOpenGL (HWND hwnd, HDC hDC, HGLRC hRC)
{
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(hRC);
    ReleaseDC(hwnd, hDC);
}

#ifndef Animation_loaded

class Animation
{
    public:
        Animation();
        vecteur3f orbite(vecteur3f centre)const
        {
            static float alpha=0;
            alpha+=0.01;
            if(alpha>360)alpha=0;
            float distance = 200.0f;

            return Vecteur(distance * cos(alpha)+centre.X, centre.Y, distance * sin(alpha)+centre.Z);
        }
};
    #define Animation_loaded
#endif