1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#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];
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

#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 = "Frequence de l'horloge : ";
wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);;

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

/* create main window */
hwnd = CreateWindowEx(0,
" Hz.",
"GLSample",
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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#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