Bonjour tout le monde.
Je viens vous posez une question parce que j'ai un leger problème de lumière (apparament ça vient de là). Tout d'abord, j'ai créé un loader de fichier .obj dont voici le code:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
/**
    Loader de fichier .obj
    @author Kaelian
    @date 16/06/2008
*/
 
#include "ObjLoader.hpp"
#include <GL/gl.h>
 
//! Constructeur.
ObjLoader::ObjLoader(std::string filename) {
    // Initialisation des compteurs.
    vertexCounter = 0;
    normalCounter = 0;
    faceCounter = 0;
 
    // Initialisation des tailles.
    normalArraySize = 0;
    vertexArraySize = 0;
    faceArraySize = 0;
 
    // Ouverture du fichier.
    file.open(filename.c_str());
    if (file.fail()) {
        std::cerr << "Erreur - " << filename << " introuvable." << std::endl;
        exit(EXIT_FAILURE);
    }
 
    // Lecture de la taille des tableaux.
    readArraySize();
 
    // Chargement des données.
    loadData();
 
    // Fermeture du fichier.
    file.close();
}
 
//! Destructeur.
ObjLoader::~ObjLoader() {
    // Liberation de la mémoire.
    delete [] vertexArray;
    delete [] normalArray;
    delete [] faceArray;
}
 
//! Afficher le modèle.
void ObjLoader::show() {
    glBegin(GL_QUADS);
    for (unsigned int i = 0; i < (unsigned int)(faceArraySize); i++) {
        for (unsigned int j = 0; j < 4; j++) {
            int vertexIndex = faceArray[i].data[j][0] - 1;
            int normalIndex = faceArray[i].data[j][2] - 1;
            glColor3ub(255, 255, 255);
            glNormal3f(normalArray[normalIndex].x, normalArray[normalIndex].y,
                normalArray[normalIndex].z);
 
            glVertex3f(vertexArray[vertexIndex].x, vertexArray[vertexIndex].y,
                vertexArray[vertexIndex].z);
        }
    }
    glEnd();
}
 
//! Charger les données du modèle.
void ObjLoader::loadData() {
    std::string lineRead;
 
    // Lecture du fichier ligne par ligne.
    while (std::getline(file, lineRead)) {
        // Regarder quel type de donnée on exporte.
        if (lineRead[0] == 'v' && lineRead[1] == ' ') {
            exportVertex(lineRead.substr(2));
            vertexCounter++;
        }
        else if (lineRead[0] == 'v' && lineRead[1] == 'n') {
            exportNormal(lineRead.substr(2));
            normalCounter++;
        }
        else if (lineRead[0] == 'f') {
            exportFace(lineRead.substr(2));
            faceCounter++;
        }
    }
}
 
//! Lire les données des tableaux.
void ObjLoader::readArraySize() {
    std::string lineRead;
 
    // Lecture du global du fichier.
    while (std::getline(file, lineRead)) {
        // Regarder quel est le type de ligne lue.
        if (lineRead[0] == 'v') {
            if (lineRead[1] == 'n') {
                normalArraySize++;
            }
            else if (lineRead[1] == ' ') {
                vertexArraySize++;
            }
        }
        else if(lineRead[0] == 'f') {
            faceArraySize++;
        }
    }
 
    // Allocation des tableaux.
    vertexArray = new Vertex[vertexArraySize];
    normalArray = new Vertex[normalArraySize];
    faceArray = new Face[faceArraySize];
 
    // Replacer le curseur de lecture au début du fichier.
    file.clear();
    file.seekg(0, std::ios::beg);
}
 
//! Exportateur: vertex.
void ObjLoader::exportVertex(std::string line) {
    // Extration de la donnée.
    std::istringstream iss(line);
    iss >> vertexArray[vertexCounter].x;
    iss >> vertexArray[vertexCounter].y;
    iss >> vertexArray[vertexCounter].z;
}
 
//! Exportateur: normal.
void ObjLoader::exportNormal(std::string line) {
    // Extration de la donnée.
    std::istringstream iss(line);
    iss >> normalArray[normalCounter].x;
    iss >> normalArray[normalCounter].y;
    iss >> normalArray[normalCounter].z;
}
 
//! Exportateur: face.
void ObjLoader::exportFace(std::string line) {
    // Decouper la chaine en trois sous-chaines.
    std::vector<std::string> substring = parser(line, ' ');
 
    // Replissage du tableau data de la face.
    for (unsigned int i = 0; i < 4; i++) {
        std::vector<std::string> dataParse = parser(substring[i], '/');
        if (dataParse.size() == 1)
            dataParse.resize(3);
 
        for (unsigned int j = 0; j < 3; j++) {
            // Si la donnée est presente, la traiter. Sinon la valeur par defaut est 0.
            if (dataParse[j] != "") {
                faceArray[faceCounter].data[i][j] = stringTo<int>(dataParse[j]);
            }
            else {
                faceArray[faceCounter].data[i][j] = 0;
            }
        }
    }
}
Bref, je pense pas que ça ait d'importance. Ensuite voilà la scène de teste:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
/**
    Main de teste.
    @author Kaelian
    @date 16/06/2008
*/
 
#include <iostream>
#include <sstream>
#include "Other/sdlglutils.h"
#include "Camera/FreeFlyCamera.hpp"
#include "Loader/ObjLoader.hpp"
 
GLfloat lightAmbient[] = {0.5, 0.5, 0.5, 1.0};
GLfloat lightDiffuse[] = {1.0, 1.0, 1.0, 1.0};
GLfloat lightPosition[] = {200.0, 200.0, 200.0, 1.0};
 
void initSDL() {
    // Initialisation de la SDL.
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        std::cerr << "Erreur - " << SDL_GetError() << std::endl;
        exit(EXIT_FAILURE);
    }
 
    // Ouverture de la fenetre.
    SDL_WM_SetCaption("ObjLoader -- Created by Kaelian", NULL);
    if (SDL_SetVideoMode(640, 480, 32, SDL_OPENGL) == NULL) {
        std::cerr << "Erreur - " << SDL_GetError() << std::endl;
        exit(EXIT_FAILURE);
    }
}
 
void initOpenGL() {
    // Initialisation de la matrice de Projection.
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(70, (double)640/480, 1, 5000);
    glMatrixMode(GL_MODELVIEW);
 
    glEnable(GL_DEPTH_TEST);
 
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING);
    glEnable(GL_NORMALIZE);
 
    glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse);
    glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
}
 
void drawScene(FreeFlyCamera* camera, ObjLoader* obj) {
    // Vidage des buffers.
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    // Initialisation de la matrice de modélisation.
    glLoadIdentity();
 
    // Placement de la camera.
    camera->look();
 
    // Dessiner le modele.
    obj->show();
 
    // Forcer le rendu.
    glFlush();
    SDL_GL_SwapBuffers();
}
 
int main(int argc, char** argv) {
    // Initialisation de la SDL et d'OpenGL.
    initSDL();
    initOpenGL();
 
    // Creation de la camera et de notre modele.
    ObjLoader cube("data/cube.obj");
    ObjLoader anneau("data/anneau.obj");
    FreeFlyCamera camera(Vector3D(0, 0, 0));
 
    camera.setSpeed(50);
 
    SDL_Event event;
    bool running = true;
    unsigned int counterScreen = 0;
 
    while (running) {
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
                case SDL_QUIT:
                    running = false;
                    break;
                case SDL_KEYDOWN:
                    if (event.key.keysym.sym == SDLK_ESCAPE)
                        running = false;
                    else if (event.key.keysym.sym == SDLK_PRINT) {
                        // Determination du nom du screen.
                        std::ostringstream oss;
                        oss << counterScreen;
                        std::string screenName = "screenshot/screen_"+oss.str()+".png";
 
                        // Prendre le screen.
                        takeScreenshot(screenName.c_str());
                        counterScreen++;
                    }
                    else
                        camera.onKeyboard(event.key);
                    break;
                case SDL_KEYUP:
                    camera.onKeyboard(event.key);
                    break;
                case SDL_MOUSEMOTION:
                    camera.onMouseMotion(event.motion);
                    break;
            }
        }
 
        // Animer la camera.
        camera.animate();
 
        // Dessiner la scene.
        drawScene(&camera, &cube);
    }
 
    // Quitter proprepement.
    SDL_Quit();
    return EXIT_SUCCESS;
}
Voici les resultats d'affichage lorsque je charge un modele:
Rendu n°1
J'ai pas comprit pourquoi c'était translucide. Quand je teste avec un cube, mon cube apparait gris. Je suppose donc que j'ai un problème de lumière, mais je vois pas où. =/
Quelqu'un aurait une idée s'il-vous-plaît ? =x