IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

OpenGL Discussion :

Probleme lumineux ?


Sujet :

OpenGL

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre habitué
    Inscrit en
    Juin 2008
    Messages
    9
    Détails du profil
    Informations forums :
    Inscription : Juin 2008
    Messages : 9
    Par défaut Probleme lumineux ?
    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

  2. #2
    Membre émérite
    Avatar de Ange_blond
    Homme Profil pro
    Ingénieur développement en 3D temps réel
    Inscrit en
    Mars 2007
    Messages
    902
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Ingénieur développement en 3D temps réel
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2007
    Messages : 902
    Par défaut
    Salut

    ça peut aussi etre un probleme de facettes mal orientées.... as tu essayé de le lire avec un soft de modelisation et vérifer l'orientation des normales des facettes qui disparaissent dans ton rendu ?

  3. #3
    Expert confirmé
    Avatar de raptor70
    Inscrit en
    Septembre 2005
    Messages
    3 173
    Détails du profil
    Informations personnelles :
    Âge : 40

    Informations forums :
    Inscription : Septembre 2005
    Messages : 3 173
    Par défaut
    Citation Envoyé par Kaelian Voir le message
    J'ai pas comprit pourquoi c'était translucide.
    Le problème peut venir de deux choses, DepthBuffer mal utilisé ou Normal inversée ..

    Citation Envoyé par Kaelian Voir le message
    Quand je teste avec un cube, mon cube apparait gris.
    C'est normal qu'il soit gris, la lumière annule les couleurs passées par glColor*() car il faut définir des matériaux pour chaque objet. Si tu veux quand même utiliser les couleurs, utilise glEnable( GL_COLOR_MATERIAL ); qui défini automatique un matériel à partir d'une couleur données par glColor*();

  4. #4
    Membre habitué
    Inscrit en
    Juin 2008
    Messages
    9
    Détails du profil
    Informations forums :
    Inscription : Juin 2008
    Messages : 9
    Par défaut
    Bonjour,
    merci beaucoup pour vos réponses.

    Alors le problème venait en effet du DepthBuffer mal utilisé. J'suis vraiment bête v_v. Et merci pour l'information sur la couleur, j'savais pas du tout.
    *devrait se renseigner sur l'utilisation des lumières avec OpenGL :°*

    Problème résolu! ^^

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Ordinateur portable probleme écran noir mais lumineux
    Par derek corhs dans le forum Ordinateurs
    Réponses: 31
    Dernier message: 24/03/2010, 20h49
  2. Probleme de rafraichissement d'un BDGrid
    Par marmotte dans le forum Bases de données
    Réponses: 10
    Dernier message: 28/05/2004, 18h07
  3. Probleme sur les chaines de caractere
    Par scorpiwolf dans le forum C
    Réponses: 8
    Dernier message: 06/05/2002, 19h01
  4. [Kylix] Probleme d'execution de programmes...
    Par yopziggy dans le forum EDI
    Réponses: 19
    Dernier message: 03/05/2002, 14h50
  5. [Kylix] Probleme de nombre flottant!!
    Par yopziggy dans le forum EDI
    Réponses: 5
    Dernier message: 02/05/2002, 10h13

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo