Discussion :

[Invité]

Bonjour a tous =)

J'ai un petit probleme dans mon application 3D concernant l'ajout de lumieres opengl. En effet, mes meshes .obj sont tres mal eclaires, que ce soit une sphere, un cube ou un monkey.

[Screen du bug]
[Screen du bug]


Mes normales de vertex sont importees depuis le fichier obj et sont stockees dans un VBO.
Je peux fournir du code au besoin.

Quelques questions :
- Les vertex normals sont bien supportees par glNormalPointer() ?
- Est-il necessaire de calculer les normales par face, dans quel cas sont-elles utilisees ?
- Le code d'initialisation des lumieres est-il correct ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
 
GLfloat matAmbient[] = {1.f,1.f,1.f,1.f};
GLfloat matDiffuse[] = {1.f,1.f,1.f,1.f};
 
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, matAmbient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, matDiffuse);
 
GLfloat positionLight[] = {0.f, 0.f, 5.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, positionLight);
 
glEnable(GL_LIGHT0);

(Desole pour l'absence d'accents, mon clavier a quelques soucis lui aussi ^^)

[Invité]

Tu ne donne pas de couleur à ta lumière ? Par défaut la lumière 0 est très sombre.

[Invité]

Salut,

Bin oui je peux modifier la couleur de la lumiere, mais il me semble que le probleme ne vient pas de la...
J'ai toujours des artefacts un peu partout sur mon mesh...

Et j'ai pourtant verifie mes normales, ca m'a l'air assez bon de ce cote...
Bizarre.

[TanEk]

Donne le code qui copie les normales de ton obj vers les vbos.

[Invité]

Ouep, pas de probleme :

Alors voici les structures que j'utilise (avec la SFML)

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
struct Vertex
{
    sf::Uint32      normal;
    ...
};
 
typedef std::vector<sf::Uint32>         Indexes;
typedef std::vector<Vertex>             Vertices;
typedef std::vector<sf::Vector3f>       Normals;
 
class MeshBuffer
{
    public:
        MeshBuffer();
 
        Vertices&           GetVertices();
        Normals&            GetNormals();
        Indexes&            GetIndexes();
 
    private:
        Vertices            myVertices;
        Normals             myNormals;
        Indexes             myIndexes;
};

Parsing des normales (vn 1.0 0.0 0.0)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
const sf::Vector3f& vn = GetVectorFromLine(line);
meshBuffer->GetNormals().push_back(vn);

Parsing des faces (f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// je recupere le vertex associe a son index
Vertex& vertex = meshBuffer->GetVertices()[vIndex];
// je recupere l'index de la normale (-1 bien sur)
sf::Uint32 vnIndex = Utils::GetFromString<sf::Uint32>(vnIndexStr, 0) - 1;
vertex.normal = vnIndex;

Remplissage du VBO

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
// Il y a autant de normales que de vertex (*3 pour chaque composante flottante)
sf::Uint32 normalSize = myIndexes.size() * 3;
 
// on declare le tableau pour notre vbo
glBindBuffer(GL_ARRAY_BUFFER, myNormalBufferID);
glBufferData(GL_ARRAY_BUFFER, normalSize * sizeof(float), NULL, GL_DYNAMIC_DRAW);
float* normals = new float[normalSize];
 
sf::Uint32 n = 0;
// on itere sur chaque index pour remplir notre tableau de normales
for (Indexes::iterator it = myIndexes.begin(); it != myIndexes.end(); ++it)
{
    Vertex& v = myVertices[*it];
    const sf::Vector3f& normal = myNormals[v.normal];
    normals[n + 0] = normal.x;
    normals[n + 1] = normal.y;
    normals[n + 2] = normal.z;
    n += 3;
}
 
glBufferSubData(GL_ARRAY_BUFFER, 0, normalSize * sizeof(float), normals);

Le parsing ne pose pas de probleme, j'ai verifie. Par contre il se peut que je me trompes quand au remplissage du vbo

[TanEk]

Comment utilises-tu le VBO dans le code d'affichage?